@thehoneyjar/sigil-anchor 4.3.1

package/dist/cli/index.js

@@ -0,0 +1,3514 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { readFile, mkdir, writeFile, readdir, unlink, rm } from 'node:fs/promises';
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { EventEmitter } from 'eventemitter3';
+import { z } from 'zod';
+
+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
+};
+var LensContextSchema = 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()
+});
+var LensExitCode = {
+  ...ExitCode,
+  LENS_WARNING: 11,
+  LENS_ERROR: 10
+};
+
+// 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 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 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 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 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 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;
+  }
+}
+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;
+}
+
+// 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 }
+  };
+}
+function getExitCode(result) {
+  switch (result.status) {
+    case "VALID":
+      return 0;
+    case "DRIFT":
+      return 1;
+    case "DECEPTIVE":
+      return 2;
+    default:
+      return 3;
+  }
+}
+
+// src/warden/adversarial-warden.ts
+var ZONE_RELEVANCE = {
+  critical: [
+    "button",
+    "form",
+    "modal",
+    "dialog",
+    "action",
+    "input",
+    "transaction",
+    "payment",
+    "claim",
+    "withdraw",
+    "deposit",
+    "transfer",
+    "swap",
+    "stake",
+    "mint",
+    "burn"
+  ],
+  elevated: [
+    "button",
+    "form",
+    "modal",
+    "dialog",
+    "action",
+    "delete",
+    "remove",
+    "revoke",
+    "terminate",
+    "confirmation"
+  ],
+  standard: [
+    "button",
+    "form",
+    "modal",
+    "dialog",
+    "action",
+    "input",
+    "card",
+    "list",
+    "table",
+    "save",
+    "edit",
+    "create",
+    "update"
+  ],
+  local: [
+    "toggle",
+    "switch",
+    "checkbox",
+    "radio",
+    "select",
+    "dropdown",
+    "tooltip",
+    "accordion",
+    "tab",
+    "theme",
+    "preference",
+    "filter",
+    "sort"
+  ]
+};
+var AdversarialWarden = class {
+  learnedRules = [];
+  /**
+   * Add a learned rule to the warden
+   *
+   * @param rule - The learned rule to add
+   */
+  addLearnedRule(rule) {
+    this.learnedRules.push(rule);
+  }
+  /**
+   * Clear all learned rules
+   */
+  clearLearnedRules() {
+    this.learnedRules = [];
+  }
+  /**
+   * Get all learned rules
+   */
+  getLearnedRules() {
+    return [...this.learnedRules];
+  }
+  /**
+   * Check if cited zone is relevant to the component type
+   *
+   * Critical zone should only be cited for buttons, forms, modals, actions
+   * Citing critical for a tooltip is suspicious
+   *
+   * @param citedZone - The zone cited by the agent
+   * @param componentName - The component name
+   * @returns Check result
+   */
+  checkRelevance(citedZone, componentName) {
+    const componentLower = componentName.toLowerCase();
+    const relevantTypes = ZONE_RELEVANCE[citedZone];
+    const isRelevant = relevantTypes.some(
+      (type) => componentLower.includes(type)
+    );
+    if (!isRelevant) {
+      const zoneIndex = ZONE_HIERARCHY.indexOf(citedZone);
+      if (zoneIndex <= 1) {
+        return {
+          passed: false,
+          reason: `Zone "${citedZone}" is unnecessarily restrictive for component "${componentName}"`
+        };
+      }
+    }
+    return {
+      passed: true,
+      reason: `Zone "${citedZone}" is appropriate for component "${componentName}"`
+    };
+  }
+  /**
+   * Check learned rules against a grounding statement
+   *
+   * @param statement - Parsed grounding statement
+   * @returns Check result with missing rule citations
+   */
+  checkLearnedRules(statement) {
+    const missingRules = [];
+    for (const rule of this.learnedRules) {
+      if (!rule.grounding_requirement?.must_cite)
+        continue;
+      const triggerMatches = this.checkRuleTrigger(rule, statement);
+      if (!triggerMatches)
+        continue;
+      const citationPresent = this.checkCitationPresent(rule, statement);
+      if (!citationPresent) {
+        missingRules.push(rule.id);
+      }
+    }
+    if (missingRules.length > 0) {
+      return {
+        passed: false,
+        reason: `Missing required rule citations: ${missingRules.join(", ")}`
+      };
+    }
+    return {
+      passed: true,
+      reason: "All required rule citations present"
+    };
+  }
+  /**
+   * Check if a rule's trigger matches the statement
+   */
+  checkRuleTrigger(rule, statement) {
+    const trigger = rule.rule.trigger;
+    if (trigger.component_name_contains) {
+      const matches = trigger.component_name_contains.some(
+        (pattern) => statement.component.toLowerCase().includes(pattern.toLowerCase())
+      );
+      if (!matches)
+        return false;
+    }
+    if (trigger.zone) {
+      if (statement.citedZone !== trigger.zone)
+        return false;
+    }
+    if (trigger.effect && statement.inferredEffect !== trigger.effect) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Check if required citation is present in statement
+   */
+  checkCitationPresent(rule, statement) {
+    const mustCite = rule.grounding_requirement?.must_cite;
+    if (!mustCite)
+      return true;
+    const rawLower = statement.raw.toLowerCase();
+    if (mustCite.zone && statement.citedZone !== mustCite.zone) {
+      return false;
+    }
+    if (mustCite.physics) {
+      for (const physics of mustCite.physics) {
+        if (!rawLower.includes(physics.toLowerCase())) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  /**
+   * Run full adversarial validation
+   *
+   * @param input - Raw text or parsed statement
+   * @param options - Validation options
+   * @returns Extended warden result with adversarial checks
+   */
+  async validate(input, options) {
+    const statement = typeof input === "string" ? parseGroundingStatement(input) : input;
+    const baseResult = await validateGrounding(statement, options);
+    const relevanceCheck = statement.component ? this.checkRelevance(
+      statement.citedZone ?? "standard",
+      statement.component
+    ) : { passed: true, reason: "No component to check" };
+    const learnedRulesCheck = this.checkLearnedRules(statement);
+    let status = baseResult.status;
+    let correction = baseResult.correction;
+    if (!relevanceCheck.passed && status === "VALID") {
+      status = "DRIFT";
+      correction = relevanceCheck.reason;
+    }
+    if (!learnedRulesCheck.passed && status === "VALID") {
+      status = "DRIFT";
+      correction = learnedRulesCheck.reason;
+    }
+    return {
+      ...baseResult,
+      status,
+      ...correction !== void 0 && { correction },
+      adversarialChecks: {
+        relevance: relevanceCheck,
+        learnedRules: learnedRulesCheck
+      }
+    };
+  }
+};
+function getHierarchyDescription() {
+  return ZONE_HIERARCHY.map((zone, i) => {
+    const restrictiveness = i === 0 ? "most restrictive" : i === ZONE_HIERARCHY.length - 1 ? "least restrictive" : "";
+    return `${zone}${restrictiveness ? ` (${restrictiveness})` : ""}`;
+  }).join(" > ");
+}
+
+// src/warden/lens-validator.ts
+var ZONE_SEVERITY = {
+  critical: "error",
+  elevated: "error",
+  standard: "warning",
+  local: "info"
+};
+function checkDataSourceMismatch(context, zone) {
+  const { observedValue, onChainValue, component } = context;
+  if (observedValue === void 0 || onChainValue === void 0) {
+    return null;
+  }
+  const normalizedObserved = normalizeValue(observedValue);
+  const normalizedOnChain = normalizeValue(onChainValue);
+  if (normalizedObserved !== normalizedOnChain) {
+    const severity = zone ? ZONE_SEVERITY[zone] : "warning";
+    return {
+      type: "data_source_mismatch",
+      severity,
+      message: `Displayed value "${observedValue}" doesn't match on-chain value "${onChainValue}"`,
+      component,
+      ...zone !== void 0 && { zone },
+      expected: onChainValue,
+      actual: observedValue,
+      suggestion: "Use on-chain data source for accuracy, or add refresh mechanism"
+    };
+  }
+  return null;
+}
+function checkStaleIndexedData(context, zone) {
+  const { indexedValue, onChainValue, component } = context;
+  if (indexedValue === void 0 || onChainValue === void 0) {
+    return null;
+  }
+  const normalizedIndexed = normalizeValue(indexedValue);
+  const normalizedOnChain = normalizeValue(onChainValue);
+  if (normalizedIndexed !== normalizedOnChain) {
+    const severity = zone ? ZONE_SEVERITY[zone] : "warning";
+    return {
+      type: "stale_indexed_data",
+      severity,
+      message: `Indexed value "${indexedValue}" doesn't match on-chain value "${onChainValue}"`,
+      component,
+      ...zone !== void 0 && { zone },
+      expected: onChainValue,
+      actual: indexedValue,
+      suggestion: "Consider using on-chain reads for critical data or reducing indexer lag"
+    };
+  }
+  return null;
+}
+function checkLensFinancialSource(context, zone) {
+  const { dataSource, component } = context;
+  if (zone !== "critical") {
+    return null;
+  }
+  if (dataSource === "indexed" || dataSource === "mixed") {
+    return {
+      type: "lens_financial_check",
+      severity: "error",
+      message: `Financial component "${component}" uses ${dataSource} data source`,
+      component,
+      zone,
+      suggestion: "Financial operations must use on-chain data for transaction amounts"
+    };
+  }
+  return null;
+}
+function checkImpersonationLeak(context) {
+  const { impersonatedAddress, realAddress, observedValue, component } = context;
+  if (!realAddress || !observedValue) {
+    return null;
+  }
+  const normalizedReal = realAddress.toLowerCase();
+  const normalizedObserved = observedValue.toLowerCase();
+  if (normalizedObserved.includes(normalizedReal) && !normalizedObserved.includes(impersonatedAddress.toLowerCase())) {
+    return {
+      type: "impersonation_leak",
+      severity: "error",
+      message: `Component "${component}" shows real address instead of impersonated address`,
+      component,
+      expected: impersonatedAddress,
+      actual: observedValue,
+      suggestion: "Use lens-aware account hook to get the correct address context"
+    };
+  }
+  return null;
+}
+function normalizeValue(value) {
+  let normalized = value.trim();
+  if (normalized.endsWith("n")) {
+    normalized = normalized.slice(0, -1);
+  }
+  if (normalized.startsWith("0x")) {
+    normalized = normalized.toLowerCase();
+  }
+  if (normalized.includes(".")) {
+    normalized = normalized.replace(/\.?0+$/, "");
+  }
+  return normalized;
+}
+function validateLensContext(context, zone) {
+  const issues = [];
+  const dataSourceMismatch = checkDataSourceMismatch(context, zone);
+  if (dataSourceMismatch)
+    issues.push(dataSourceMismatch);
+  const staleIndexed = checkStaleIndexedData(context, zone);
+  if (staleIndexed)
+    issues.push(staleIndexed);
+  const financialSource = checkLensFinancialSource(context, zone);
+  if (financialSource)
+    issues.push(financialSource);
+  const impersonationLeak = checkImpersonationLeak(context);
+  if (impersonationLeak)
+    issues.push(impersonationLeak);
+  const hasErrors = issues.some((issue) => issue.severity === "error");
+  const hasWarnings = issues.some((issue) => issue.severity === "warning");
+  let summary;
+  if (issues.length === 0) {
+    summary = "All lens validation checks passed";
+  } else if (hasErrors) {
+    const errorCount = issues.filter((i) => i.severity === "error").length;
+    summary = `${errorCount} error(s) found in lens validation`;
+  } else if (hasWarnings) {
+    const warningCount = issues.filter((i) => i.severity === "warning").length;
+    summary = `${warningCount} warning(s) found in lens validation`;
+  } else {
+    summary = `${issues.length} informational issue(s) found`;
+  }
+  return {
+    valid: !hasErrors,
+    issues,
+    summary
+  };
+}
+function getLensExitCode(result) {
+  if (result.valid && result.issues.length === 0) {
+    return LensExitCode.PASS;
+  }
+  const hasErrors = result.issues.some((issue) => issue.severity === "error");
+  if (hasErrors) {
+    return LensExitCode.LENS_ERROR;
+  }
+  const hasWarnings = result.issues.some((issue) => issue.severity === "warning");
+  if (hasWarnings) {
+    return LensExitCode.LENS_WARNING;
+  }
+  return LensExitCode.PASS;
+}
+
+// src/cli/index.ts
+var VERSION = "4.3.1";
+var NETWORKS = {
+  mainnet: {
+    name: "mainnet",
+    chainId: 1,
+    rpcUrl: process.env["ETH_RPC_URL"] ?? "https://eth.llamarpc.com"
+  },
+  sepolia: {
+    name: "sepolia",
+    chainId: 11155111,
+    rpcUrl: process.env["SEPOLIA_RPC_URL"] ?? "https://rpc.sepolia.org"
+  },
+  arbitrum: {
+    name: "arbitrum",
+    chainId: 42161,
+    rpcUrl: process.env["ARBITRUM_RPC_URL"] ?? "https://arb1.arbitrum.io/rpc"
+  },
+  optimism: {
+    name: "optimism",
+    chainId: 10,
+    rpcUrl: process.env["OPTIMISM_RPC_URL"] ?? "https://mainnet.optimism.io"
+  },
+  polygon: {
+    name: "polygon",
+    chainId: 137,
+    rpcUrl: process.env["POLYGON_RPC_URL"] ?? "https://polygon-rpc.com"
+  },
+  base: {
+    name: "base",
+    chainId: 8453,
+    rpcUrl: process.env["BASE_RPC_URL"] ?? "https://mainnet.base.org"
+  }
+};
+var program = new Command();
+program.name("anchor").description("Ground truth enforcement for Sigil design physics").version(VERSION);
+program.command("fork <network>").description("Spawn an Anvil fork of the specified network").option("-b, --block <number>", "Block number to fork at").option("-p, --port <number>", "RPC port (auto-assigned if not specified)").option("-s, --session <id>", "Session ID to associate with fork").option("--rpc-url <url>", "Custom RPC URL (overrides network default)").action(async (networkName, options) => {
+  const manager = new ForkManager();
+  await manager.init();
+  let network = NETWORKS[networkName.toLowerCase()];
+  if (!network) {
+    if (options.rpcUrl) {
+      network = {
+        name: networkName,
+        chainId: 1,
+        // Will be detected from RPC
+        rpcUrl: options.rpcUrl
+      };
+    } else {
+      console.error(`Unknown network: ${networkName}`);
+      console.error(`Available networks: ${Object.keys(NETWORKS).join(", ")}`);
+      console.error("Or provide a custom RPC URL with --rpc-url");
+      process.exit(1);
+    }
+  }
+  if (options.rpcUrl) {
+    network = { ...network, rpcUrl: options.rpcUrl };
+  }
+  try {
+    console.log(`Forking ${network.name}...`);
+    const fork = await manager.fork({
+      network,
+      ...options.block !== void 0 && { blockNumber: parseInt(options.block, 10) },
+      ...options.port !== void 0 && { port: parseInt(options.port, 10) },
+      ...options.session !== void 0 && { sessionId: options.session }
+    });
+    console.log("");
+    console.log("Fork created successfully:");
+    console.log("");
+    console.log(`  ID:        ${fork.id}`);
+    console.log(`  Network:   ${fork.network.name}`);
+    console.log(`  Chain ID:  ${fork.network.chainId}`);
+    console.log(`  Block:     ${fork.blockNumber}`);
+    console.log(`  RPC URL:   ${fork.rpcUrl}`);
+    console.log(`  PID:       ${fork.pid}`);
+    console.log("");
+    console.log("Environment variables:");
+    const env = manager.exportEnv(fork.id);
+    for (const [key, value] of Object.entries(env)) {
+      console.log(`  export ${key}=${value}`);
+    }
+  } catch (error) {
+    console.error("Failed to create fork:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("forks").description("List all active forks").option("--json", "Output as JSON").action(async (options) => {
+  const manager = new ForkManager();
+  await manager.init();
+  const forks = manager.list();
+  if (options.json) {
+    console.log(JSON.stringify(forks, null, 2));
+    return;
+  }
+  if (forks.length === 0) {
+    console.log("No active forks.");
+    return;
+  }
+  console.log("Active forks:");
+  console.log("");
+  for (const fork of forks) {
+    const age = Math.round((Date.now() - fork.createdAt.getTime()) / 1e3 / 60);
+    console.log(`  ${fork.id}`);
+    console.log(`    Network:  ${fork.network.name} (chain ${fork.network.chainId})`);
+    console.log(`    Block:    ${fork.blockNumber}`);
+    console.log(`    RPC:      ${fork.rpcUrl}`);
+    console.log(`    Age:      ${age} minutes`);
+    if (fork.sessionId) {
+      console.log(`    Session:  ${fork.sessionId}`);
+    }
+    console.log("");
+  }
+});
+program.command("kill <fork-id>").description("Kill a specific fork").action(async (forkId) => {
+  const manager = new ForkManager();
+  await manager.init();
+  const fork = manager.get(forkId);
+  if (!fork) {
+    console.error(`Fork not found: ${forkId}`);
+    process.exit(1);
+  }
+  await manager.kill(forkId);
+  console.log(`Fork ${forkId} terminated.`);
+});
+program.command("kill-all").description("Kill all active forks").action(async () => {
+  const manager = new ForkManager();
+  await manager.init();
+  const forks = manager.list();
+  if (forks.length === 0) {
+    console.log("No active forks to kill.");
+    return;
+  }
+  await manager.killAll();
+  console.log(`Killed ${forks.length} fork(s).`);
+});
+program.command("env <fork-id>").description("Export environment variables for a fork").option("--format <type>", "Output format: shell, fish, or json", "shell").action(async (forkId, options) => {
+  const manager = new ForkManager();
+  await manager.init();
+  try {
+    const env = manager.exportEnv(forkId);
+    switch (options.format) {
+      case "json":
+        console.log(JSON.stringify(env, null, 2));
+        break;
+      case "fish":
+        for (const [key, value] of Object.entries(env)) {
+          console.log(`set -x ${key} ${value}`);
+        }
+        break;
+      case "shell":
+      default:
+        for (const [key, value] of Object.entries(env)) {
+          console.log(`export ${key}=${value}`);
+        }
+        break;
+    }
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("snapshot").description("Create a new EVM snapshot").requiredOption("-f, --fork <id>", "Fork ID to snapshot").requiredOption("-s, --session <id>", "Session ID").option("-t, --task <id>", "Task ID to associate with snapshot").option("-d, --description <text>", "Description of the snapshot").action(async (options) => {
+  const forkManager = new ForkManager();
+  await forkManager.init();
+  const fork = forkManager.get(options.fork);
+  if (!fork) {
+    console.error(`Fork not found: ${options.fork}`);
+    process.exit(1);
+  }
+  const snapshotManager = new SnapshotManager();
+  await snapshotManager.init(options.session);
+  try {
+    const snapshot = await snapshotManager.create(
+      {
+        forkId: options.fork,
+        sessionId: options.session,
+        ...options.task !== void 0 && { taskId: options.task },
+        ...options.description !== void 0 && { description: options.description }
+      },
+      fork.rpcUrl
+    );
+    console.log("Snapshot created:");
+    console.log("");
+    console.log(`  ID:          ${snapshot.id}`);
+    console.log(`  Block:       ${snapshot.blockNumber}`);
+    console.log(`  Session:     ${snapshot.sessionId}`);
+    if (snapshot.taskId) {
+      console.log(`  Task:        ${snapshot.taskId}`);
+    }
+    if (snapshot.description) {
+      console.log(`  Description: ${snapshot.description}`);
+    }
+  } catch (error) {
+    console.error("Failed to create snapshot:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("revert <snapshot-id>").description("Revert to a previous EVM snapshot").requiredOption("-f, --fork <id>", "Fork ID to revert").requiredOption("-s, --session <id>", "Session ID").action(async (snapshotId, options) => {
+  const forkManager = new ForkManager();
+  await forkManager.init();
+  const fork = forkManager.get(options.fork);
+  if (!fork) {
+    console.error(`Fork not found: ${options.fork}`);
+    process.exit(1);
+  }
+  const snapshotManager = new SnapshotManager();
+  await snapshotManager.init(options.session);
+  const snapshot = snapshotManager.get(snapshotId);
+  if (!snapshot) {
+    console.error(`Snapshot not found: ${snapshotId}`);
+    process.exit(1);
+  }
+  try {
+    const success = await snapshotManager.revert(fork.rpcUrl, snapshotId);
+    if (success) {
+      console.log(`Reverted to snapshot ${snapshotId}`);
+      console.log(`  Block: ${snapshot.blockNumber}`);
+    } else {
+      console.error("Revert failed");
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error("Failed to revert:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("snapshots").description("List all snapshots for a session").requiredOption("-s, --session <id>", "Session ID").option("--json", "Output as JSON").action(async (options) => {
+  const snapshotManager = new SnapshotManager();
+  await snapshotManager.init(options.session);
+  const snapshots = snapshotManager.list();
+  if (options.json) {
+    console.log(JSON.stringify(snapshots, null, 2));
+    return;
+  }
+  if (snapshots.length === 0) {
+    console.log("No snapshots for this session.");
+    return;
+  }
+  console.log(`Snapshots for session ${options.session}:`);
+  console.log("");
+  for (const snap of snapshots) {
+    const age = Math.round((Date.now() - snap.createdAt.getTime()) / 1e3 / 60);
+    console.log(`  ${snap.id}`);
+    console.log(`    Block: ${snap.blockNumber}`);
+    console.log(`    Fork:  ${snap.forkId}`);
+    console.log(`    Age:   ${age} minutes`);
+    if (snap.taskId) {
+      console.log(`    Task:  ${snap.taskId}`);
+    }
+    console.log("");
+  }
+});
+program.command("session <network>").description("Create a new Anchor session").option("-b, --block <number>", "Block number to fork at").option("--rpc-url <url>", "Custom RPC URL (overrides network default)").action(async (networkName, options) => {
+  let network = NETWORKS[networkName.toLowerCase()];
+  if (!network) {
+    if (options.rpcUrl) {
+      network = {
+        name: networkName,
+        chainId: 1,
+        rpcUrl: options.rpcUrl
+      };
+    } else {
+      console.error(`Unknown network: ${networkName}`);
+      console.error(`Available networks: ${Object.keys(NETWORKS).join(", ")}`);
+      process.exit(1);
+    }
+  }
+  if (options.rpcUrl) {
+    network = { ...network, rpcUrl: options.rpcUrl };
+  }
+  const sessionManager = new SessionManager();
+  await sessionManager.init();
+  try {
+    console.log(`Creating session on ${network.name}...`);
+    const session = await sessionManager.create(
+      network,
+      options.block ? { blockNumber: parseInt(options.block, 10) } : void 0
+    );
+    console.log("");
+    console.log("Session created:");
+    console.log("");
+    console.log(`  Session ID:  ${session.metadata.id}`);
+    console.log(`  Network:     ${session.metadata.network.name}`);
+    console.log(`  Fork ID:     ${session.fork.id}`);
+    console.log(`  Block:       ${session.fork.blockNumber}`);
+    console.log(`  RPC URL:     ${session.fork.rpcUrl}`);
+    console.log(`  Status:      ${session.metadata.status}`);
+    console.log("");
+    console.log("To resume this session later:");
+    console.log(`  anchor resume ${session.metadata.id}`);
+  } catch (error) {
+    console.error("Failed to create session:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("sessions").description("List all sessions").option("--status <status>", "Filter by status (active, suspended, complete, failed)").option("--json", "Output as JSON").action(async (options) => {
+  const sessionManager = new SessionManager();
+  await sessionManager.init();
+  const filter = options.status ? { status: options.status } : void 0;
+  const sessions = sessionManager.list(filter);
+  if (options.json) {
+    console.log(JSON.stringify(sessions, null, 2));
+    return;
+  }
+  if (sessions.length === 0) {
+    console.log("No sessions found.");
+    return;
+  }
+  console.log("Sessions:");
+  console.log("");
+  for (const session of sessions) {
+    const age = Math.round((Date.now() - session.lastActivity.getTime()) / 1e3 / 60);
+    console.log(`  ${session.id}`);
+    console.log(`    Network:  ${session.network.name}`);
+    console.log(`    Status:   ${session.status}`);
+    console.log(`    Block:    ${session.initialBlock}`);
+    console.log(`    Age:      ${age} minutes`);
+    console.log("");
+  }
+});
+program.command("resume <session-id>").description("Resume an existing session").action(async (sessionId) => {
+  const sessionManager = new SessionManager();
+  await sessionManager.init();
+  try {
+    console.log(`Resuming session ${sessionId}...`);
+    const session = await sessionManager.resume(sessionId);
+    console.log("");
+    console.log("Session resumed:");
+    console.log("");
+    console.log(`  Session ID:  ${session.metadata.id}`);
+    console.log(`  Network:     ${session.metadata.network.name}`);
+    console.log(`  Fork ID:     ${session.fork.id}`);
+    console.log(`  Block:       ${session.fork.blockNumber}`);
+    console.log(`  RPC URL:     ${session.fork.rpcUrl}`);
+    console.log(`  Status:      ${session.metadata.status}`);
+    const pending = session.taskGraph.getTasksByStatus("pending").length;
+    const running = session.taskGraph.getTasksByStatus("running").length;
+    const complete = session.taskGraph.getTasksByStatus("complete").length;
+    const blocked = session.taskGraph.getTasksByStatus("blocked").length;
+    console.log("");
+    console.log("Task Graph:");
+    console.log(`  Pending:   ${pending}`);
+    console.log(`  Running:   ${running}`);
+    console.log(`  Complete:  ${complete}`);
+    console.log(`  Blocked:   ${blocked}`);
+  } catch (error) {
+    console.error("Failed to resume session:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("status <session-id>").description("Show session status").option("--json", "Output as JSON").action(async (sessionId, options) => {
+  const sessionManager = new SessionManager();
+  await sessionManager.init();
+  const metadata = sessionManager.get(sessionId);
+  if (!metadata) {
+    console.error(`Session not found: ${sessionId}`);
+    process.exit(1);
+  }
+  if (options.json) {
+    console.log(JSON.stringify(metadata, null, 2));
+    return;
+  }
+  console.log("Session Status:");
+  console.log("");
+  console.log(`  ID:            ${metadata.id}`);
+  console.log(`  Network:       ${metadata.network.name}`);
+  console.log(`  Status:        ${metadata.status}`);
+  console.log(`  Initial Block: ${metadata.initialBlock}`);
+  console.log(`  Current Fork:  ${metadata.forkId}`);
+  console.log(`  Created:       ${metadata.createdAt.toISOString()}`);
+  console.log(`  Last Activity: ${metadata.lastActivity.toISOString()}`);
+});
+program.command("graph <session-id>").description("Show task graph for a session").option("--json", "Output as JSON").action(async (sessionId, options) => {
+  const taskGraph = new TaskGraph({ sessionId, autoSave: false });
+  await taskGraph.init();
+  const data = taskGraph.toJSON();
+  if (options.json) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  if (data.tasks.length === 0) {
+    console.log("No tasks in graph.");
+    return;
+  }
+  console.log(`Task Graph for session ${sessionId}:`);
+  console.log("");
+  const byStatus = /* @__PURE__ */ new Map();
+  for (const task of data.tasks) {
+    const existing = byStatus.get(task.status) ?? [];
+    existing.push(task);
+    byStatus.set(task.status, existing);
+  }
+  const statusOrder = ["running", "pending", "complete", "blocked", "failed"];
+  for (const status of statusOrder) {
+    const tasks = byStatus.get(status);
+    if (!tasks || tasks.length === 0)
+      continue;
+    console.log(`  ${status.toUpperCase()} (${tasks.length}):`);
+    for (const task of tasks) {
+      console.log(`    ${task.id}`);
+      console.log(`      Type: ${task.type}`);
+      if (task.snapshotId) {
+        console.log(`      Snapshot: ${task.snapshotId}`);
+      }
+      if (task.dependencies.length > 0) {
+        console.log(`      Dependencies: ${task.dependencies.join(", ")}`);
+      }
+    }
+    console.log("");
+  }
+});
+program.command("checkpoint <session-id>").description("Create a checkpoint for a session").requiredOption("-f, --fork <id>", "Fork ID to checkpoint").action(async (sessionId, options) => {
+  const forkManager = new ForkManager();
+  await forkManager.init();
+  const fork = forkManager.get(options.fork);
+  if (!fork) {
+    console.error(`Fork not found: ${options.fork}`);
+    process.exit(1);
+  }
+  const checkpointManager = new CheckpointManager();
+  await checkpointManager.init(sessionId, options.fork);
+  try {
+    console.log("Creating checkpoint...");
+    const checkpoint = await checkpointManager.create(fork.rpcUrl);
+    console.log("");
+    console.log("Checkpoint created:");
+    console.log("");
+    console.log(`  ID:             ${checkpoint.id}`);
+    console.log(`  Session:        ${checkpoint.sessionId}`);
+    console.log(`  Fork:           ${checkpoint.forkId}`);
+    console.log(`  Block:          ${checkpoint.blockNumber}`);
+    console.log(`  Snapshot Range: ${checkpoint.snapshotRange.first} - ${checkpoint.snapshotRange.last}`);
+    console.log(`  Snapshot Count: ${checkpoint.snapshotCount}`);
+  } catch (error) {
+    console.error("Failed to create checkpoint:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("checkpoints <session-id>").description("List checkpoints for a session").option("--json", "Output as JSON").action(async (sessionId, options) => {
+  const checkpointManager = new CheckpointManager();
+  await checkpointManager.init(sessionId, "list-only");
+  const checkpoints = checkpointManager.list();
+  if (options.json) {
+    console.log(JSON.stringify(checkpoints, null, 2));
+    return;
+  }
+  if (checkpoints.length === 0) {
+    console.log("No checkpoints for this session.");
+    return;
+  }
+  console.log(`Checkpoints for session ${sessionId}:`);
+  console.log("");
+  for (const cp of checkpoints) {
+    const age = Math.round((Date.now() - cp.createdAt.getTime()) / 1e3 / 60);
+    console.log(`  ${cp.id}`);
+    console.log(`    Block:          ${cp.blockNumber}`);
+    console.log(`    Fork:           ${cp.forkId}`);
+    console.log(`    Snapshot Range: ${cp.snapshotRange.first} - ${cp.snapshotRange.last}`);
+    console.log(`    Age:            ${age} minutes`);
+    console.log("");
+  }
+});
+program.command("restore <checkpoint-id>").description("Restore session from a checkpoint").requiredOption("-s, --session <id>", "Session ID").action(async (checkpointId, options) => {
+  const sessionManager = new SessionManager();
+  await sessionManager.init();
+  const metadata = sessionManager.get(options.session);
+  if (!metadata) {
+    console.error(`Session not found: ${options.session}`);
+    process.exit(1);
+  }
+  const forkManager = new ForkManager();
+  await forkManager.init();
+  const checkpointManager = new CheckpointManager();
+  await checkpointManager.init(options.session, metadata.forkId);
+  const checkpoint = checkpointManager.get(checkpointId);
+  if (!checkpoint) {
+    console.error(`Checkpoint not found: ${checkpointId}`);
+    process.exit(1);
+  }
+  try {
+    console.log(`Restoring from checkpoint ${checkpointId}...`);
+    const fork = await checkpointManager.restore(checkpointId, forkManager, metadata.network);
+    console.log("");
+    console.log("Restored successfully:");
+    console.log("");
+    console.log(`  New Fork ID:  ${fork.id}`);
+    console.log(`  Block:        ${fork.blockNumber}`);
+    console.log(`  RPC URL:      ${fork.rpcUrl}`);
+  } catch (error) {
+    console.error("Failed to restore:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("validate").description("Validate a grounding statement against Sigil physics").option("-f, --file <path>", "Read statement from file").option("-t, --text <statement>", "Statement text to validate").option("--physics <path>", "Path to physics rules file").option("--vocabulary <path>", "Path to vocabulary file").option("--lens <json>", "Lens context JSON for data source validation").option("--lens-file <path>", "Read lens context from JSON file").option("--zone <zone>", "Zone for lens validation (critical, elevated, standard, local)").option("--json", "Output as JSON").option("--exit-code", "Exit with validation status code").action(async (options) => {
+  let statement;
+  let lensContext;
+  let zone;
+  if (options.zone) {
+    const validZones = ["critical", "elevated", "standard", "local"];
+    if (!validZones.includes(options.zone)) {
+      console.error(`Invalid zone: ${options.zone}. Must be one of: ${validZones.join(", ")}`);
+      process.exit(1);
+    }
+    zone = options.zone;
+  }
+  if (options.lens) {
+    try {
+      const parsed = JSON.parse(options.lens);
+      const validated = LensContextSchema.safeParse(parsed);
+      if (!validated.success) {
+        console.error("Invalid lens context:", validated.error.message);
+        process.exit(1);
+      }
+      lensContext = validated.data;
+    } catch {
+      console.error("Failed to parse lens context JSON");
+      process.exit(1);
+    }
+  } else if (options.lensFile) {
+    try {
+      const content = await readFile(options.lensFile, "utf-8");
+      const parsed = JSON.parse(content);
+      const validated = LensContextSchema.safeParse(parsed);
+      if (!validated.success) {
+        console.error("Invalid lens context:", validated.error.message);
+        process.exit(1);
+      }
+      lensContext = validated.data;
+    } catch {
+      console.error(`Failed to read lens context file: ${options.lensFile}`);
+      process.exit(1);
+    }
+  }
+  if (options.file) {
+    try {
+      statement = await readFile(options.file, "utf-8");
+    } catch {
+      console.error(`Failed to read file: ${options.file}`);
+      process.exit(1);
+    }
+  } else if (options.text) {
+    statement = options.text;
+  }
+  if (!statement && !lensContext) {
+    console.error("Provide a statement with -f (file) or -t (text), or lens context with --lens or --lens-file");
+    process.exit(1);
+  }
+  try {
+    const validateOptions = {};
+    if (options.physics)
+      validateOptions.physicsPath = options.physics;
+    if (options.vocabulary)
+      validateOptions.vocabularyPath = options.vocabulary;
+    let groundingResult;
+    if (statement) {
+      groundingResult = await validateGrounding(statement, validateOptions);
+    }
+    let lensResult;
+    if (lensContext) {
+      const effectiveZone = zone ?? groundingResult?.requiredZone ?? "standard";
+      lensResult = validateLensContext(lensContext, effectiveZone);
+    }
+    const combinedResult = {
+      ...groundingResult && {
+        status: groundingResult.status,
+        checks: groundingResult.checks,
+        requiredZone: groundingResult.requiredZone,
+        citedZone: groundingResult.citedZone,
+        correction: groundingResult.correction
+      },
+      ...lensResult && {
+        lens_validation: {
+          valid: lensResult.valid,
+          issues: lensResult.issues,
+          summary: lensResult.summary
+        }
+      }
+    };
+    if (options.json) {
+      console.log(JSON.stringify(combinedResult, null, 2));
+    } else {
+      if (groundingResult) {
+        const statusEmoji = groundingResult.status === "VALID" ? "\u2713" : groundingResult.status === "DRIFT" ? "\u26A0" : "\u2717";
+        console.log(`${statusEmoji} Status: ${groundingResult.status}`);
+        console.log("");
+        console.log("Grounding Checks:");
+        console.log(`  Relevance:  ${groundingResult.checks.relevance.passed ? "\u2713" : "\u2717"} ${groundingResult.checks.relevance.reason}`);
+        console.log(`  Hierarchy:  ${groundingResult.checks.hierarchy.passed ? "\u2713" : "\u2717"} ${groundingResult.checks.hierarchy.reason}`);
+        console.log(`  Rules:      ${groundingResult.checks.rules.passed ? "\u2713" : "\u2717"} ${groundingResult.checks.rules.reason}`);
+        console.log("");
+        console.log(`Required Zone: ${groundingResult.requiredZone}`);
+        console.log(`Cited Zone:    ${groundingResult.citedZone ?? "(none)"}`);
+        if (groundingResult.correction) {
+          console.log("");
+          console.log(`Correction: ${groundingResult.correction}`);
+        }
+      }
+      if (lensResult) {
+        if (groundingResult)
+          console.log("");
+        const lensEmoji = lensResult.valid ? "\u2713" : "\u2717";
+        console.log(`${lensEmoji} Lens Validation: ${lensResult.summary}`);
+        if (lensResult.issues.length > 0) {
+          console.log("");
+          console.log("Lens Issues:");
+          for (const issue of lensResult.issues) {
+            const severityEmoji = issue.severity === "error" ? "\u2717" : issue.severity === "warning" ? "\u26A0" : "\u2139";
+            console.log(`  ${severityEmoji} [${issue.type}] ${issue.message}`);
+            if (issue.suggestion) {
+              console.log(`    \u2192 ${issue.suggestion}`);
+            }
+          }
+        }
+      }
+    }
+    if (options.exitCode) {
+      let exitCode = 0;
+      if (groundingResult) {
+        exitCode = Math.max(exitCode, getExitCode(groundingResult));
+      }
+      if (lensResult) {
+        exitCode = Math.max(exitCode, getLensExitCode(lensResult));
+      }
+      process.exit(exitCode);
+    }
+  } catch (error) {
+    console.error("Validation error:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("physics").description("Show loaded physics rules").option("-p, --path <path>", "Path to physics file").option("--json", "Output as JSON").action(async (options) => {
+  try {
+    const physics = await loadPhysics(options.path);
+    if (options.json) {
+      const obj = {};
+      for (const [key, value] of physics) {
+        obj[key] = value;
+      }
+      console.log(JSON.stringify(obj, null, 2));
+      return;
+    }
+    console.log("Physics Rules:");
+    console.log("");
+    console.log("  Effect          Sync          Timing   Confirmation");
+    console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    for (const [effect, rule] of physics) {
+      const effectPad = effect.padEnd(14);
+      const syncPad = rule.sync.padEnd(12);
+      const timingPad = `${rule.timing}ms`.padEnd(7);
+      console.log(`  ${effectPad}  ${syncPad}  ${timingPad}  ${rule.confirmation}`);
+    }
+  } catch (error) {
+    console.error("Failed to load physics:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("vocabulary").description("Show loaded vocabulary").option("-p, --path <path>", "Path to vocabulary file").option("--json", "Output as JSON").action(async (options) => {
+  try {
+    const vocabulary = await loadVocabulary(options.path);
+    if (options.json) {
+      const obj = {
+        effects: Object.fromEntries(vocabulary.effects),
+        typeOverrides: Object.fromEntries(vocabulary.typeOverrides),
+        domainDefaults: Object.fromEntries(vocabulary.domainDefaults)
+      };
+      console.log(JSON.stringify(obj, null, 2));
+      return;
+    }
+    console.log("Vocabulary:");
+    console.log("");
+    console.log("Effect Keywords:");
+    for (const [effect, entry] of vocabulary.effects) {
+      console.log(`  ${effect}: ${entry.keywords.slice(0, 8).join(", ")}${entry.keywords.length > 8 ? "..." : ""}`);
+    }
+    console.log("");
+    console.log("Type Overrides:");
+    for (const [type, effect] of vocabulary.typeOverrides) {
+      console.log(`  ${type} \u2192 ${effect}`);
+    }
+  } catch (error) {
+    console.error("Failed to load vocabulary:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("warden").description("Run adversarial warden validation").option("-f, --file <path>", "Read statement from file").option("-t, --text <statement>", "Statement text to test").option("--hierarchy", "Show zone hierarchy").option("--physics <path>", "Path to physics rules file").option("--vocabulary <path>", "Path to vocabulary file").option("--json", "Output as JSON").option("--exit-code", "Exit with validation status code").action(async (options) => {
+  if (options.hierarchy) {
+    console.log("Zone Hierarchy:");
+    console.log("");
+    console.log(`  ${getHierarchyDescription()}`);
+    console.log("");
+    console.log("Zones:");
+    for (const zone of ZONE_HIERARCHY) {
+      const index = ZONE_HIERARCHY.indexOf(zone);
+      const restriction = index === 0 ? "(most restrictive)" : index === ZONE_HIERARCHY.length - 1 ? "(least restrictive)" : "";
+      console.log(`  ${index + 1}. ${zone} ${restriction}`);
+    }
+    return;
+  }
+  let statement;
+  if (options.file) {
+    try {
+      statement = await readFile(options.file, "utf-8");
+    } catch {
+      console.error(`Failed to read file: ${options.file}`);
+      process.exit(1);
+    }
+  } else if (options.text) {
+    statement = options.text;
+  } else {
+    console.error("Provide a statement with -f (file) or -t (text), or use --hierarchy");
+    process.exit(1);
+  }
+  try {
+    const warden = new AdversarialWarden();
+    const validateOptions = {};
+    if (options.physics)
+      validateOptions.physicsPath = options.physics;
+    if (options.vocabulary)
+      validateOptions.vocabularyPath = options.vocabulary;
+    const result = await warden.validate(statement, validateOptions);
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      const statusEmoji = result.status === "VALID" ? "\u2713" : result.status === "DRIFT" ? "\u26A0" : "\u2717";
+      console.log(`${statusEmoji} Status: ${result.status}`);
+      console.log("");
+      console.log("Grounding Checks:");
+      console.log(`  Relevance:  ${result.checks.relevance.passed ? "\u2713" : "\u2717"} ${result.checks.relevance.reason}`);
+      console.log(`  Hierarchy:  ${result.checks.hierarchy.passed ? "\u2713" : "\u2717"} ${result.checks.hierarchy.reason}`);
+      console.log(`  Rules:      ${result.checks.rules.passed ? "\u2713" : "\u2717"} ${result.checks.rules.reason}`);
+      console.log("");
+      console.log("Adversarial Checks:");
+      console.log(`  Relevance:     ${result.adversarialChecks.relevance.passed ? "\u2713" : "\u2717"} ${result.adversarialChecks.relevance.reason}`);
+      console.log(`  Learned Rules: ${result.adversarialChecks.learnedRules.passed ? "\u2713" : "\u2717"} ${result.adversarialChecks.learnedRules.reason}`);
+      console.log("");
+      console.log(`Required Zone: ${result.requiredZone}`);
+      console.log(`Cited Zone:    ${result.citedZone ?? "(none)"}`);
+      if (result.correction) {
+        console.log("");
+        console.log(`Correction: ${result.correction}`);
+      }
+    }
+    if (options.exitCode) {
+      process.exit(getExitCode(result));
+    }
+  } catch (error) {
+    console.error("Warden error:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("version").description("Show Anchor version").action(() => {
+  console.log(`Anchor v${VERSION}`);
+  console.log("Ground truth enforcement for Sigil design physics.");
+});
+program.parse();
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.js.map