@exagent/agent 0.1.38 → 0.1.39

package/dist/cli.mjs

@@ -1,19 +1,823 @@
 #!/usr/bin/env node
 import {
   AgentRuntime,
+  FileStore,
+  NATIVE_ETH,
+  PaperExecutor,
+  RiskManager,
+  SimulatedPortfolio,
+  __esm,
+  __export,
+  __toCommonJS,
+  createLLMAdapter,
   encryptEnvFile,
+  formatSessionReport,
   getAllStrategyTemplates,
+  getTokenDecimals,
+  init_adapter,
+  init_executor,
+  init_loader,
+  init_portfolio,
+  init_results,
+  init_risk,
+  init_store,
+  init_trading,
   loadConfig,
   loadSecureEnv,
+  loadStrategy,
+  portfolio_exports,
+  results_exports,
+  saveSessionResult,
   validateConfig
-} from "./chunk-27O4UUAA.mjs";
+} from "./chunk-EPXZ6MEW.mjs";
+
+// src/backtest/data-loader.ts
+import * as fs from "fs";
+import * as path from "path";
+var WETH_BASE, STABLECOINS, KNOWN_POOLS, HistoricalDataLoader;
+var init_data_loader = __esm({
+  "src/backtest/data-loader.ts"() {
+    "use strict";
+    init_trading();
+    WETH_BASE = "0x4200000000000000000000000000000000000006";
+    STABLECOINS = /* @__PURE__ */ new Set([
+      "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+      // USDC
+      "0xd9aaec86b65d86f6a7b5b1b0c42ffa531710b6ca",
+      // USDbC
+      "0x50c5725949a6f0c72e6c4a641f24049a917db0cb",
+      // DAI
+      "0xfde4c96c8593536e31f229ea8f37b2ada2699bb2",
+      // USDT
+      "0x60a3e35cc302bfa44cb288bc5a4f316fdb1adb42",
+      // EURC
+      "0x417ac0e078398c154edacc20b41affd5af7f93e1"
+      // crvUSD
+    ]);
+    KNOWN_POOLS = {
+      // WETH / USDC pools
+      [WETH_BASE]: "0xd0b53d9277642d899df5c87a3966a349a798f224",
+      // AERO / WETH
+      "0x940181a94a35a4569e4529a3cdfb74e38fd98631": "0x7f670f78b17dec44c5b03398e1d13ff0e19b5f1e",
+      // VIRTUAL / WETH
+      "0x0b3e328455c4059eeb9e3f84b5543f74e24e7e1b": "0x34a1e3db82f669f8cf5bce07f2f1c09c14f1b3d4",
+      // BRETT / WETH
+      "0x532f27101965dd16442e59d40670faf5ebb142e4": "0xba3f945812a83471d709bce9c3ca699a19fb46f7",
+      // cbETH / WETH
+      "0x2ae3f1ec7f1f5012cfeab0185bfc7aa3cf0dec22": "0x44bc50d92990e0b15c0c300bfef4e07c073f59a0",
+      // DEGEN / WETH
+      "0x4ed4e862860bed51a9570b96d89af5e1b0efefed": "0xc9034c3e7f58003e6ae0c8438e7c8f4598d5acaa",
+      // TOSHI / WETH
+      "0xac1bd2486aaf3b5c0fc3fd868558b082a531b2b4": "0xb1afe803fa26b0d4196d4e2c9da0b3baa8e2a54e",
+      // HIGHER / WETH
+      "0x0578d8a44db98b23bf096a382e016e29a5ce0ffe": "0x1fc1f3a29b82d75b2e0e8f48e6b88d0ed6e5e740",
+      // WELL / WETH
+      "0xa88594d404727625a9437c3f886c7643be7dbffc": "0x89dc31c0f71a09e6a8c15e0d0e95853e6b1d0c88",
+      // MOG / WETH
+      "0x2da56acb9ea78330f947bd57c54119debda7af71": "0x5c88b527b4bc4e52e2f7e21f5a26cbb4d4e1032c",
+      // MORPHO / WETH
+      "0xbaa5cc21fd487b8fcc2f632f3f4e8d37262987a5": "0xd4e5d3f43da7a2db7c01b08e7b33b0c1e9e7f9a5",
+      // KEYCAT / WETH
+      "0x9a26f5433671751c3276a065f57e5a02d2817973": "0x2e4784446a0a06df3d1a69afb54b2956b5bc0098"
+    };
+    HistoricalDataLoader = class {
+      cacheDir;
+      network;
+      rateLimitRpm;
+      requestTimestamps = [];
+      candles = /* @__PURE__ */ new Map();
+      // token -> candles
+      poolMappings = /* @__PURE__ */ new Map();
+      // token -> pool
+      timestamps = [];
+      constructor(options) {
+        this.cacheDir = options?.cacheDir || path.join(process.cwd(), "data", "backtest", "price-cache");
+        this.network = options?.network || "base";
+        this.rateLimitRpm = options?.rateLimitRpm || 28;
+        this.loadPoolMappings();
+      }
+      /**
+       * Prefetch OHLCV data for all tokens in the given time range.
+       * Downloads and caches data upfront so buildMarketData() is instant.
+       */
+      async prefetch(tokens, startTime, endTime, interval, onProgress) {
+        const timeframe = interval === "daily" ? "day" : "hour";
+        const normalizedTokens = tokens.map((t) => t.toLowerCase());
+        for (let i = 0; i < normalizedTokens.length; i++) {
+          const token = normalizedTokens[i];
+          if (STABLECOINS.has(token)) {
+            onProgress?.({ token, current: i + 1, total: normalizedTokens.length, status: "stablecoin" });
+            continue;
+          }
+          const lookupToken = token === NATIVE_ETH.toLowerCase() ? WETH_BASE : token;
+          const cached = this.loadCachedOHLCV(lookupToken, timeframe);
+          if (cached && this.isCacheValid(cached, startTime, endTime)) {
+            this.candles.set(token, cached.candles);
+            if (token === NATIVE_ETH.toLowerCase()) {
+              this.candles.set(WETH_BASE, cached.candles);
+            }
+            onProgress?.({ token, current: i + 1, total: normalizedTokens.length, status: "cached" });
+            continue;
+          }
+          const pool = await this.resolvePool(lookupToken);
+          if (!pool) {
+            console.warn(`  [BACKTEST] No pool found for ${token} \u2014 prices will be $0`);
+            onProgress?.({ token, current: i + 1, total: normalizedTokens.length, status: "failed" });
+            continue;
+          }
+          try {
+            const candles = await this.fetchOHLCV(pool, timeframe, startTime, endTime);
+            this.candles.set(token, candles);
+            if (token === NATIVE_ETH.toLowerCase()) {
+              this.candles.set(WETH_BASE, candles);
+            }
+            this.saveCachedOHLCV(lookupToken, timeframe, pool, candles);
+            onProgress?.({ token, current: i + 1, total: normalizedTokens.length, status: "fetching" });
+          } catch (err) {
+            console.warn(`  [BACKTEST] Failed to fetch OHLCV for ${token}: ${err instanceof Error ? err.message : err}`);
+            onProgress?.({ token, current: i + 1, total: normalizedTokens.length, status: "failed" });
+          }
+        }
+        this.buildTimestamps(startTime, endTime, interval);
+      }
+      /**
+       * Build a synthetic MarketData object for a given historical timestamp.
+       * Uses the closest candle close price ≤ timestamp for each token.
+       */
+      buildMarketData(timestamp, balances, tokens) {
+        const prices = {};
+        const volume24h = {};
+        const priceChange24h = {};
+        for (const token of tokens) {
+          const key = token.toLowerCase();
+          if (STABLECOINS.has(key)) {
+            prices[key] = 1;
+            volume24h[key] = 0;
+            priceChange24h[key] = 0;
+            continue;
+          }
+          const candles = this.candles.get(key);
+          if (!candles || candles.length === 0) {
+            prices[key] = 0;
+            continue;
+          }
+          const candle = this.findClosestCandle(candles, timestamp);
+          if (candle) {
+            prices[key] = candle.close;
+            volume24h[key] = candle.volume;
+            priceChange24h[key] = candle.open > 0 ? (candle.close - candle.open) / candle.open * 100 : 0;
+          } else {
+            prices[key] = 0;
+          }
+        }
+        const nativeKey = NATIVE_ETH.toLowerCase();
+        if (!prices[nativeKey] && prices[WETH_BASE]) {
+          prices[nativeKey] = prices[WETH_BASE];
+        }
+        if (prices[nativeKey] && !prices[WETH_BASE]) {
+          prices[WETH_BASE] = prices[nativeKey];
+        }
+        let portfolioValue = 0;
+        for (const [token, balance] of Object.entries(balances)) {
+          const price = prices[token.toLowerCase()] || 0;
+          const decimals = getTokenDecimals(token);
+          portfolioValue += Number(balance) / Math.pow(10, decimals) * price;
+        }
+        return {
+          timestamp,
+          prices,
+          balances,
+          portfolioValue,
+          volume24h,
+          priceChange24h,
+          network: { chainId: 8453 }
+        };
+      }
+      /**
+       * Get all timestamps for the backtest loop.
+       * Returns sorted array of timestamps matching the candle interval.
+       */
+      getTimestamps() {
+        return [...this.timestamps];
+      }
+      /**
+       * Clear all cached data.
+       */
+      clearCache() {
+        if (fs.existsSync(this.cacheDir)) {
+          fs.rmSync(this.cacheDir, { recursive: true, force: true });
+        }
+        this.candles.clear();
+        this.poolMappings.clear();
+        this.timestamps = [];
+      }
+      // --- Private: Pool Resolution ---
+      async resolvePool(token) {
+        const key = token.toLowerCase();
+        if (KNOWN_POOLS[key]) {
+          return KNOWN_POOLS[key];
+        }
+        if (this.poolMappings.has(key)) {
+          return this.poolMappings.get(key);
+        }
+        await this.rateLimit();
+        try {
+          const url = `https://api.geckoterminal.com/api/v2/networks/${this.network}/tokens/${key}/pools?page=1`;
+          const res = await fetch(url, {
+            headers: { "Accept": "application/json" }
+          });
+          if (!res.ok) {
+            if (res.status === 429) {
+              await this.exponentialBackoff(1);
+              return this.resolvePool(token);
+            }
+            return null;
+          }
+          const data = await res.json();
+          const pools = data?.data;
+          if (!pools || pools.length === 0) return null;
+          const pool = pools[0]?.id;
+          if (!pool) return null;
+          const poolAddress = pool.includes("_") ? pool.split("_")[1] : pool;
+          this.poolMappings.set(key, poolAddress);
+          this.savePoolMappings();
+          return poolAddress;
+        } catch (err) {
+          console.warn(`  [BACKTEST] Pool lookup failed for ${token}: ${err instanceof Error ? err.message : err}`);
+          return null;
+        }
+      }
+      // --- Private: OHLCV Fetching ---
+      async fetchOHLCV(pool, timeframe, startTime, endTime) {
+        const allCandles = [];
+        let beforeTimestamp = Math.floor(endTime / 1e3);
+        while (true) {
+          await this.rateLimit();
+          const url = `https://api.geckoterminal.com/api/v2/networks/${this.network}/pools/${pool}/ohlcv/${timeframe}?aggregate=1&before_timestamp=${beforeTimestamp}&limit=1000&currency=usd`;
+          let res;
+          try {
+            res = await fetch(url, {
+              headers: { "Accept": "application/json" }
+            });
+          } catch (err) {
+            await this.exponentialBackoff(1);
+            continue;
+          }
+          if (res.status === 429) {
+            await this.exponentialBackoff(1);
+            continue;
+          }
+          if (!res.ok) {
+            throw new Error(`GeckoTerminal OHLCV fetch failed: ${res.status}`);
+          }
+          const data = await res.json();
+          const ohlcvList = data?.data?.attributes?.ohlcv_list;
+          if (!ohlcvList || ohlcvList.length === 0) break;
+          for (const candle of ohlcvList) {
+            const ts = candle[0];
+            const tsMs = ts * 1e3;
+            if (tsMs < startTime) continue;
+            if (tsMs > endTime) continue;
+            allCandles.push({
+              timestamp: ts,
+              open: candle[1],
+              high: candle[2],
+              low: candle[3],
+              close: candle[4],
+              volume: candle[5]
+            });
+          }
+          const oldestTimestamp = ohlcvList[ohlcvList.length - 1][0];
+          if (oldestTimestamp * 1e3 <= startTime) break;
+          beforeTimestamp = oldestTimestamp - 1;
+          if (ohlcvList.length < 100) break;
+        }
+        allCandles.sort((a, b) => a.timestamp - b.timestamp);
+        const seen = /* @__PURE__ */ new Set();
+        const unique = allCandles.filter((c) => {
+          if (seen.has(c.timestamp)) return false;
+          seen.add(c.timestamp);
+          return true;
+        });
+        return unique;
+      }
+      // --- Private: Timestamp Building ---
+      buildTimestamps(startTime, endTime, interval) {
+        const timestampSet = /* @__PURE__ */ new Set();
+        for (const candles of this.candles.values()) {
+          for (const candle of candles) {
+            const tsMs = candle.timestamp * 1e3;
+            if (tsMs >= startTime && tsMs <= endTime) {
+              timestampSet.add(tsMs);
+            }
+          }
+        }
+        this.timestamps = Array.from(timestampSet).sort((a, b) => a - b);
+        if (this.timestamps.length === 0) {
+          const step = interval === "daily" ? 864e5 : 36e5;
+          let ts = startTime;
+          while (ts <= endTime) {
+            this.timestamps.push(ts);
+            ts += step;
+          }
+        }
+      }
+      // --- Private: Candle Lookup ---
+      findClosestCandle(candles, timestampMs) {
+        const targetSec = Math.floor(timestampMs / 1e3);
+        let lo = 0;
+        let hi = candles.length - 1;
+        let best = null;
+        while (lo <= hi) {
+          const mid = Math.floor((lo + hi) / 2);
+          if (candles[mid].timestamp <= targetSec) {
+            best = candles[mid];
+            lo = mid + 1;
+          } else {
+            hi = mid - 1;
+          }
+        }
+        return best;
+      }
+      // --- Private: Rate Limiting ---
+      async rateLimit() {
+        const now = Date.now();
+        const windowMs = 6e4;
+        this.requestTimestamps = this.requestTimestamps.filter((t) => now - t < windowMs);
+        if (this.requestTimestamps.length >= this.rateLimitRpm) {
+          const oldest = this.requestTimestamps[0];
+          const waitMs = windowMs - (now - oldest) + 100;
+          if (waitMs > 0) {
+            await new Promise((resolve) => setTimeout(resolve, waitMs));
+          }
+        }
+        this.requestTimestamps.push(Date.now());
+      }
+      async exponentialBackoff(attempt) {
+        const maxAttempts = 3;
+        if (attempt > maxAttempts) {
+          throw new Error("Max retries exceeded for GeckoTerminal API");
+        }
+        const waitMs = Math.pow(2, attempt) * 1e3 + Math.random() * 1e3;
+        console.warn(`  [BACKTEST] Rate limited, waiting ${(waitMs / 1e3).toFixed(1)}s (attempt ${attempt}/${maxAttempts})`);
+        await new Promise((resolve) => setTimeout(resolve, waitMs));
+      }
+      // --- Private: Disk Cache ---
+      getCacheDir() {
+        const dir = path.join(this.cacheDir, this.network);
+        if (!fs.existsSync(dir)) {
+          fs.mkdirSync(dir, { recursive: true });
+        }
+        return dir;
+      }
+      loadCachedOHLCV(token, timeframe) {
+        const filePath = path.join(this.getCacheDir(), `${token}-${timeframe}.json`);
+        if (!fs.existsSync(filePath)) return null;
+        try {
+          const raw = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+          return raw;
+        } catch {
+          return null;
+        }
+      }
+      saveCachedOHLCV(token, timeframe, pool, candles) {
+        const filePath = path.join(this.getCacheDir(), `${token}-${timeframe}.json`);
+        const data = {
+          pool,
+          token,
+          timeframe,
+          fetchedAt: Date.now(),
+          candles
+        };
+        fs.writeFileSync(filePath, JSON.stringify(data));
+      }
+      isCacheValid(cached, startTime, endTime) {
+        if (!cached.candles.length) return false;
+        const firstCandleMs = cached.candles[0].timestamp * 1e3;
+        const lastCandleMs = cached.candles[cached.candles.length - 1].timestamp * 1e3;
+        const tolerance = 864e5;
+        return firstCandleMs <= startTime + tolerance && lastCandleMs >= endTime - tolerance;
+      }
+      loadPoolMappings() {
+        const filePath = path.join(this.getCacheDir(), "pool-mappings.json");
+        if (!fs.existsSync(filePath)) return;
+        try {
+          const raw = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+          for (const mapping of raw) {
+            this.poolMappings.set(mapping.token.toLowerCase(), mapping.pool);
+          }
+        } catch {
+        }
+      }
+      savePoolMappings() {
+        const filePath = path.join(this.getCacheDir(), "pool-mappings.json");
+        const mappings = [];
+        for (const [token, pool] of this.poolMappings) {
+          mappings.push({ token, pool, fetchedAt: Date.now() });
+        }
+        fs.writeFileSync(filePath, JSON.stringify(mappings, null, 2));
+      }
+    };
+  }
+});
+
+// src/backtest/llm-cache.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as crypto from "crypto";
+var COST_PER_MILLION_INPUT, LLMCacheAdapter;
+var init_llm_cache = __esm({
+  "src/backtest/llm-cache.ts"() {
+    "use strict";
+    COST_PER_MILLION_INPUT = {
+      "gpt-4": 30,
+      "gpt-4o": 2.5,
+      "gpt-4o-mini": 0.15,
+      "gpt-3.5": 0.5,
+      "claude-3-opus": 15,
+      "claude-3.5-sonnet": 3,
+      "claude-3-haiku": 0.25,
+      "deepseek-chat": 0.14,
+      "deepseek-reasoner": 0.55,
+      "gemini-pro": 0.5,
+      "gemini-flash": 0.075,
+      "llama": 0,
+      // local
+      "mistral": 0.25,
+      "mixtral": 0.6,
+      "groq": 0.05,
+      "together": 0.2,
+      "default": 1
+    };
+    LLMCacheAdapter = class {
+      inner;
+      cacheDir;
+      noCache;
+      stats;
+      constructor(inner, options) {
+        this.inner = inner;
+        this.cacheDir = options.cacheDir;
+        this.noCache = options.noCache ?? false;
+        this.stats = {
+          hits: 0,
+          misses: 0,
+          totalPromptTokens: 0,
+          totalCompletionTokens: 0,
+          estimatedCostUSD: 0
+        };
+        if (!this.noCache && !fs2.existsSync(this.cacheDir)) {
+          fs2.mkdirSync(this.cacheDir, { recursive: true });
+        }
+      }
+      async chat(messages) {
+        const metadata = this.inner.getMetadata();
+        const cacheKey = this.buildCacheKey(metadata.model, messages);
+        if (!this.noCache) {
+          const cached = this.readCache(cacheKey);
+          if (cached) {
+            this.stats.hits++;
+            this.trackUsage(cached.response);
+            return cached.response;
+          }
+        }
+        this.stats.misses++;
+        const response = await this.inner.chat(messages);
+        this.trackUsage(response);
+        if (!this.noCache) {
+          this.writeCache(cacheKey, {
+            response,
+            cachedAt: Date.now(),
+            modelId: metadata.model
+          });
+        }
+        return response;
+      }
+      getMetadata() {
+        return this.inner.getMetadata();
+      }
+      /**
+       * Get cache statistics for cost reporting.
+       */
+      getStats() {
+        return { ...this.stats };
+      }
+      /**
+       * Clear the entire cache directory.
+       */
+      clearCache() {
+        if (fs2.existsSync(this.cacheDir)) {
+          fs2.rmSync(this.cacheDir, { recursive: true, force: true });
+          fs2.mkdirSync(this.cacheDir, { recursive: true });
+        }
+      }
+      // --- Private ---
+      /**
+       * Build a deterministic cache key from model + messages.
+       * SHA256 of: "model:{modelId}\n" + each "role:content\n"
+       */
+      buildCacheKey(model, messages) {
+        const parts = [`model:${model}`];
+        for (const msg of messages) {
+          parts.push(`${msg.role}:${msg.content}`);
+        }
+        return crypto.createHash("sha256").update(parts.join("\n")).digest("hex");
+      }
+      /**
+       * Read a cached response from disk.
+       * Returns null on cache miss or corrupt file.
+       */
+      readCache(key) {
+        const filePath = this.getCachePath(key);
+        if (!fs2.existsSync(filePath)) return null;
+        try {
+          const raw = fs2.readFileSync(filePath, "utf-8");
+          return JSON.parse(raw);
+        } catch {
+          try {
+            fs2.unlinkSync(filePath);
+          } catch {
+          }
+          console.warn(`  [BACKTEST] Corrupt cache file deleted: ${key.slice(0, 8)}`);
+          return null;
+        }
+      }
+      /**
+       * Write a response to disk cache.
+       */
+      writeCache(key, data) {
+        const filePath = this.getCachePath(key);
+        const dir = path2.dirname(filePath);
+        if (!fs2.existsSync(dir)) {
+          fs2.mkdirSync(dir, { recursive: true });
+        }
+        try {
+          fs2.writeFileSync(filePath, JSON.stringify(data));
+        } catch (err) {
+          console.warn(`  [BACKTEST] Failed to write cache: ${err instanceof Error ? err.message : err}`);
+        }
+      }
+      /**
+       * Get the file path for a cache key.
+       * Uses first 8 chars as subdirectory for filesystem friendliness.
+       */
+      getCachePath(key) {
+        const prefix = key.slice(0, 8);
+        return path2.join(this.cacheDir, prefix, `${key}.json`);
+      }
+      /**
+       * Track token usage and estimate costs.
+       */
+      trackUsage(response) {
+        if (response.usage) {
+          this.stats.totalPromptTokens += response.usage.promptTokens;
+          this.stats.totalCompletionTokens += response.usage.completionTokens;
+        }
+        const model = this.inner.getMetadata().model.toLowerCase();
+        let costPerMillion = COST_PER_MILLION_INPUT["default"];
+        for (const [pattern, cost] of Object.entries(COST_PER_MILLION_INPUT)) {
+          if (model.includes(pattern)) {
+            costPerMillion = cost;
+            break;
+          }
+        }
+        if (response.usage) {
+          const inputCost = response.usage.promptTokens / 1e6 * costPerMillion;
+          const outputCost = response.usage.completionTokens / 1e6 * costPerMillion * 3;
+          this.stats.estimatedCostUSD += inputCost + outputCost;
+        }
+      }
+    };
+  }
+});
+
+// src/backtest/runner.ts
+var runner_exports = {};
+__export(runner_exports, {
+  BacktestRunner: () => BacktestRunner
+});
+import * as path3 from "path";
+var RISK_UNIVERSE_MAP, BacktestRunner;
+var init_runner = __esm({
+  "src/backtest/runner.ts"() {
+    "use strict";
+    init_store();
+    init_adapter();
+    init_risk();
+    init_loader();
+    init_executor();
+    init_portfolio();
+    init_results();
+    init_data_loader();
+    init_llm_cache();
+    RISK_UNIVERSE_MAP = {
+      core: 0,
+      established: 1,
+      derivatives: 2,
+      emerging: 3,
+      frontier: 4
+    };
+    BacktestRunner = class {
+      config;
+      constructor(config) {
+        this.config = config;
+      }
+      /**
+       * Run the backtest.
+       *
+       * Steps through historical timestamps, builds synthetic MarketData
+       * from cached OHLCV candles, calls the strategy, filters through
+       * risk manager, simulates trades, and records results.
+       */
+      async run(onProgress) {
+        const {
+          agentConfig,
+          startTime,
+          endTime,
+          interval,
+          initialBalances,
+          tokenAddresses,
+          noLLMCache,
+          freshStart
+        } = this.config;
+        const baseDataDir = this.config.dataDir || path3.join(process.cwd(), "data", "backtest");
+        const startDate = new Date(startTime).toISOString().split("T")[0];
+        const endDate = new Date(endTime).toISOString().split("T")[0];
+        const backtestId = `backtest-${startDate}-${endDate}-${Date.now()}`;
+        const backtestDir = path3.join(baseDataDir, backtestId);
+        const store = new FileStore(path3.join(backtestDir, "store"));
+        const innerLLM = await createLLMAdapter(agentConfig.llm);
+        const llmMetadata = innerLLM.getMetadata();
+        const llmCacheDir = path3.join(backtestDir, "llm-cache");
+        const cachedLLM = new LLMCacheAdapter(innerLLM, {
+          cacheDir: llmCacheDir,
+          noCache: noLLMCache
+        });
+        const priceCache = path3.join(baseDataDir, "price-cache");
+        const dataLoader = new HistoricalDataLoader({ cacheDir: priceCache });
+        if (freshStart) {
+          dataLoader.clearCache();
+          cachedLLM.clearCache();
+        }
+        console.log("");
+        console.log("  Fetching historical price data...");
+        await dataLoader.prefetch(
+          tokenAddresses,
+          startTime,
+          endTime,
+          interval,
+          (progress) => {
+            const status = progress.status === "cached" ? "(cached)" : progress.status === "stablecoin" ? "($1)" : progress.status === "failed" ? "(FAILED)" : "";
+            process.stdout.write(`\r  [${progress.current}/${progress.total}] ${progress.token.slice(0, 10)}... ${status}    `);
+          }
+        );
+        process.stdout.write("\r" + " ".repeat(80) + "\r");
+        console.log("  Price data ready.");
+        console.log("");
+        const riskUniverse = RISK_UNIVERSE_MAP[agentConfig.riskUniverse] ?? 1;
+        const riskManager = new RiskManager(agentConfig.trading, riskUniverse);
+        const dummyConfig = {
+          ...agentConfig,
+          privateKey: "0x" + "0".repeat(64)
+        };
+        const executor = new PaperExecutor(dummyConfig);
+        const portfolio = new SimulatedPortfolio(
+          initialBalances,
+          path3.join(backtestDir, "portfolio"),
+          { startedAt: startTime }
+        );
+        const strategy = await loadStrategy();
+        const agentId = typeof agentConfig.agentId === "string" ? parseInt(agentConfig.agentId, 10) || 0 : agentConfig.agentId;
+        const context = {
+          store,
+          agentId,
+          walletAddress: "0x0000000000000000000000000000000000000000",
+          positions: [],
+          tradeHistory: []
+        };
+        const timestamps = dataLoader.getTimestamps().filter((ts) => ts >= startTime && ts <= endTime);
+        if (timestamps.length === 0) {
+          throw new Error("No timestamps found in the specified range. Check your date range and price data.");
+        }
+        let totalTrades = 0;
+        for (let i = 0; i < timestamps.length; i++) {
+          const ts = timestamps[i];
+          const marketData = dataLoader.buildMarketData(
+            ts,
+            portfolio.getBalances(),
+            tokenAddresses
+          );
+          let tradesThisStep = 0;
+          try {
+            const signals = await strategy(marketData, cachedLLM, agentConfig, context);
+            const filtered = riskManager.filterSignals(signals, marketData);
+            executor.updatePrices(marketData.prices);
+            const results = await executor.executeAll(filtered);
+            for (const result of results) {
+              if (result.success && result.paperFill) {
+                const fill = {
+                  ...result.paperFill,
+                  timestamp: ts
+                };
+                portfolio.applyFill(fill);
+                tradesThisStep++;
+                totalTrades++;
+                const pnl = fill.valueOutUSD - fill.valueInUSD;
+                riskManager.updatePnL(pnl);
+                riskManager.updateFees(fill.feeUSD);
+                const tradeRecord = {
+                  timestamp: ts,
+                  action: fill.signal.action,
+                  tokenIn: fill.signal.tokenIn,
+                  tokenOut: fill.signal.tokenOut,
+                  amountIn: fill.signal.amountIn.toString(),
+                  priceUSD: fill.valueInUSD,
+                  txHash: `backtest-${i}-${totalTrades}`,
+                  reasoning: fill.signal.reasoning,
+                  success: true
+                };
+                context.tradeHistory = [tradeRecord, ...(context.tradeHistory || []).slice(0, 49)];
+              }
+            }
+          } catch (err) {
+            console.warn(`  [BACKTEST] Strategy error at ${new Date(ts).toISOString()}: ${err instanceof Error ? err.message : err}`);
+          }
+          portfolio.recordEquityPoint(marketData.prices, ts);
+          context.positions = this.buildPositionsFromPortfolio(portfolio, marketData.prices);
+          onProgress?.({
+            step: i,
+            total: timestamps.length,
+            timestamp: ts,
+            date: new Date(ts).toISOString().split("T")[0],
+            portfolioValue: marketData.portfolioValue,
+            tradesThisStep,
+            totalTrades
+          });
+        }
+        const summary = portfolio.getSummary(
+          dataLoader.buildMarketData(endTime, portfolio.getBalances(), tokenAddresses).prices
+        );
+        const sessionResult = saveSessionResult(
+          path3.join(baseDataDir, "sessions-backtest"),
+          agentConfig.name,
+          { provider: llmMetadata.provider, model: llmMetadata.model },
+          summary,
+          portfolio.getEquityCurve(),
+          portfolio.getTrades(),
+          startTime,
+          { endedAt: endTime, idPrefix: "backtest" }
+        );
+        console.log(formatSessionReport(sessionResult));
+        const llmStats = cachedLLM.getStats();
+        console.log("  LLM CACHE STATS");
+        console.log("  " + "\u2500".repeat(56));
+        console.log(`  Cache hits:       ${llmStats.hits}`);
+        console.log(`  Cache misses:     ${llmStats.misses} (real LLM calls)`);
+        console.log(`  Total tokens:     ${(llmStats.totalPromptTokens + llmStats.totalCompletionTokens).toLocaleString()}`);
+        console.log(`  Estimated cost:   $${llmStats.estimatedCostUSD.toFixed(4)}`);
+        console.log("");
+        return sessionResult;
+      }
+      /**
+       * Build a simplified TrackedPosition array from portfolio balances.
+       * This isn't as detailed as the real PositionTracker, but gives
+       * the strategy enough context to make decisions.
+       */
+      buildPositionsFromPortfolio(portfolio, prices) {
+        const positions = [];
+        const balances = portfolio.getBalances();
+        const NATIVE_ETH2 = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+        const WETH = "0x4200000000000000000000000000000000000006";
+        const USDC = "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913";
+        const baseTokens = /* @__PURE__ */ new Set([NATIVE_ETH2, WETH, USDC]);
+        for (const [token, balance] of Object.entries(balances)) {
+          if (balance <= BigInt(0)) continue;
+          if (baseTokens.has(token.toLowerCase())) continue;
+          const price = prices[token.toLowerCase()] || 0;
+          if (price <= 0) continue;
+          positions.push({
+            token: token.toLowerCase(),
+            entryPrice: price,
+            averageEntryPrice: price,
+            totalCostBasis: 0,
+            totalAmountAcquired: 0,
+            currentAmount: Number(balance),
+            entryTimestamp: Date.now(),
+            lastUpdateTimestamp: Date.now(),
+            txHashes: []
+          });
+        }
+        return positions;
+      }
+    };
+  }
+});
 
 // src/cli.ts
 import { Command } from "commander";
 import { config as loadEnvFile } from "dotenv";
 import * as readline from "readline";
-import * as fs from "fs";
-import * as path from "path";
+import * as fs3 from "fs";
+import * as path4 from "path";
 import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
 loadEnvFile();
 var program = new Command();
@@ -59,13 +863,13 @@ function prompt(question, hidden = false) {
   });
 }
 async function checkFirstRunSetup(configPath) {
-  const envPath = path.join(path.dirname(configPath), ".env");
+  const envPath = path4.join(path4.dirname(configPath), ".env");
   const encPath = envPath + ".enc";
-  if (fs.existsSync(encPath)) {
+  if (fs3.existsSync(encPath)) {
     return;
   }
-  if (fs.existsSync(envPath)) {
-    const envContent2 = fs.readFileSync(envPath, "utf-8");
+  if (fs3.existsSync(envPath)) {
+    const envContent2 = fs3.readFileSync(envPath, "utf-8");
     const hasPrivateKey = envContent2.includes("EXAGENT_PRIVATE_KEY=") && !envContent2.includes("EXAGENT_PRIVATE_KEY=\n") && !envContent2.includes("EXAGENT_PRIVATE_KEY=$");
     if (hasPrivateKey) {
       return;
@@ -248,7 +1052,7 @@ ${rpcEnvVar}
 # LLM (${llmProvider})
 ${llmEnvVar}EXAGENT_LLM_MODEL=${config.llm?.model || ""}
 `;
-  fs.writeFileSync(envPath, envContent, { mode: 384 });
+  fs3.writeFileSync(envPath, envContent, { mode: 384 });
   console.log("");
   console.log("=".repeat(60));
   console.log("  ENCRYPT YOUR SECRETS");
@@ -306,12 +1110,12 @@ ${llmEnvVar}EXAGENT_LLM_MODEL=${config.llm?.model || ""}
 program.command("run").description("Start the trading agent").option("-c, --config <path>", "Path to agent-config.json", "agent-config.json").option("-p, --passphrase <passphrase>", "Passphrase to decrypt .env.enc").action(async (options) => {
   try {
     await checkFirstRunSetup(options.config);
-    const configDir = path.dirname(
-      options.config.startsWith("/") ? options.config : path.join(process.cwd(), options.config)
+    const configDir = path4.dirname(
+      options.config.startsWith("/") ? options.config : path4.join(process.cwd(), options.config)
     );
     let passphrase = options.passphrase || process.env.EXAGENT_PASSPHRASE;
-    const encPath = path.join(configDir, ".env.enc");
-    if (fs.existsSync(encPath) && !passphrase) {
+    const encPath = path4.join(configDir, ".env.enc");
+    if (fs3.existsSync(encPath) && !passphrase) {
       console.log("");
       console.log("  Encrypted config found (.env.enc)");
       console.log("");
@@ -355,6 +1159,139 @@ program.command("run").description("Start the trading agent").option("-c, --conf
     process.exit(1);
   }
 });
+program.command("paper").description("Start paper trading (simulated execution, no on-chain trades)").option("-c, --config <path>", "Path to agent-config.json", "agent-config.json").option("-p, --passphrase <passphrase>", "Passphrase to decrypt .env.enc").option("--initial-eth <amount>", "Override initial ETH balance (e.g., 0.5)").option("--initial-usdc <amount>", "Override initial USDC balance (e.g., 1000)").option("--fresh", "Discard any saved paper session and start fresh").action(async (options) => {
+  try {
+    await checkFirstRunSetup(options.config);
+    const configDir = path4.dirname(
+      options.config.startsWith("/") ? options.config : path4.join(process.cwd(), options.config)
+    );
+    let passphrase = options.passphrase || process.env.EXAGENT_PASSPHRASE;
+    const encPath = path4.join(configDir, ".env.enc");
+    if (fs3.existsSync(encPath) && !passphrase) {
+      console.log("");
+      console.log("  Encrypted config found (.env.enc)");
+      console.log("");
+      passphrase = await prompt("  Enter passphrase: ", true);
+      console.log("");
+    }
+    const usedEncrypted = loadSecureEnv(configDir, passphrase);
+    if (usedEncrypted) {
+      console.log("Loaded encrypted environment (.env.enc)");
+    }
+    console.log("Loading configuration...");
+    const config = loadConfig(options.config);
+    validateConfig(config);
+    console.log("");
+    console.log("=".repeat(50));
+    console.log("  EXAGENT PAPER TRADING");
+    console.log("  Simulated execution \u2014 no on-chain trades");
+    console.log("=".repeat(50));
+    console.log("");
+    console.log(`  Agent:    ${config.name} (ID: ${config.agentId})`);
+    console.log(`  Network:  ${config.network}`);
+    console.log(`  LLM:      ${config.llm.provider} (${config.llm.model || "default"})`);
+    console.log(`  Universe: ${config.riskUniverse}`);
+    console.log("");
+    console.log("  NOTE: This will make real LLM API calls using your");
+    console.log("  configured provider. Each cycle costs ~$0.01-0.10.");
+    console.log("");
+    console.log("  Paper trading results do not guarantee future");
+    console.log("  performance. Real trading may differ due to");
+    console.log("  slippage, liquidity, and execution timing.");
+    console.log("");
+    console.log("=".repeat(50));
+    console.log("");
+    let paperBalances;
+    if (options.initialEth || options.initialUsdc) {
+      paperBalances = {};
+      const NATIVE_ETH2 = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+      const USDC_BASE = "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913";
+      if (options.initialEth) {
+        const ethAmount = parseFloat(options.initialEth);
+        paperBalances[NATIVE_ETH2] = BigInt(Math.floor(ethAmount * 1e18));
+        console.log(`  Initial ETH: ${ethAmount}`);
+      }
+      if (options.initialUsdc) {
+        const usdcAmount = parseFloat(options.initialUsdc);
+        paperBalances[USDC_BASE] = BigInt(Math.floor(usdcAmount * 1e6));
+        console.log(`  Initial USDC: ${usdcAmount}`);
+      }
+      console.log("");
+    }
+    if (options.fresh) {
+      const { SimulatedPortfolio: SimulatedPortfolio2 } = (init_portfolio(), __toCommonJS(portfolio_exports));
+      SimulatedPortfolio2.clear(path4.join(process.cwd(), "data", "paper"));
+      console.log("  Cleared previous paper session");
+      console.log("");
+    }
+    const agent = new AgentRuntime(config, {
+      paperMode: true,
+      paperBalances
+    });
+    await agent.initialize();
+    process.on("SIGINT", () => {
+      console.log("\nReceived SIGINT, shutting down paper trading...");
+      agent.stop();
+      process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+      console.log("\nReceived SIGTERM, shutting down paper trading...");
+      agent.stop();
+      process.exit(0);
+    });
+    await agent.run();
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("paper-results").description("View paper trading session results").option("--session <id>", "Show detailed results for a specific session").option("--json", "Output as JSON").action(async (options) => {
+  const { loadSessionResults, loadSessionResult, formatSessionReport: formatSessionReport2, formatSessionLine } = (init_results(), __toCommonJS(results_exports));
+  const dataDir = path4.join(process.cwd(), "data", "paper");
+  if (options.session) {
+    const result = loadSessionResult(dataDir, options.session);
+    if (!result) {
+      console.error(`Session not found: ${options.session}`);
+      process.exit(1);
+    }
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(formatSessionReport2(result));
+    }
+  } else {
+    const results = loadSessionResults(dataDir);
+    if (results.length === 0) {
+      console.log("");
+      console.log("  No paper trading sessions found.");
+      console.log('  Run "npx @exagent/agent paper" to start a paper trading session.');
+      console.log("");
+      return;
+    }
+    if (options.json) {
+      console.log(JSON.stringify(results.map((r) => ({
+        id: r.id,
+        agentName: r.agentName,
+        startedAt: r.startedAt,
+        durationMs: r.durationMs,
+        returnPct: r.metrics.totalReturnPct,
+        trades: r.trades.length,
+        winRate: r.metrics.winRate
+      })), null, 2));
+      return;
+    }
+    console.log("");
+    console.log("  PAPER TRADING SESSIONS");
+    console.log("  " + "\u2500".repeat(56));
+    console.log("");
+    for (const result of results) {
+      console.log(formatSessionLine(result));
+    }
+    console.log("");
+    console.log("  Use --session <id> for detailed results");
+    console.log("");
+  }
+});
 program.command("templates").description("List available strategy templates").action(() => {
   console.log("");
   console.log("Available Strategy Templates:");
@@ -437,14 +1374,14 @@ program.command("api-keys").description("Show how to get API keys for each LLM p
 });
 program.command("encrypt").description("Encrypt .env file to .env.enc for secure storage").option("-d, --dir <path>", "Directory containing .env file", ".").option("--delete", "Delete plaintext .env after encryption", false).action(async (options) => {
   try {
-    const dir = options.dir.startsWith("/") ? options.dir : path.join(process.cwd(), options.dir);
-    const envPath = path.join(dir, ".env");
-    if (!fs.existsSync(envPath)) {
+    const dir = options.dir.startsWith("/") ? options.dir : path4.join(process.cwd(), options.dir);
+    const envPath = path4.join(dir, ".env");
+    if (!fs3.existsSync(envPath)) {
       console.error("No .env file found in", dir);
       process.exit(1);
     }
     const encPath = envPath + ".enc";
-    if (fs.existsSync(encPath)) {
+    if (fs3.existsSync(encPath)) {
       const overwrite = await prompt("  .env.enc already exists. Overwrite? (y/n): ");
       if (overwrite.toLowerCase() !== "y") {
         console.log("Aborted.");
@@ -493,11 +1430,11 @@ program.command("encrypt").description("Encrypt .env file to .env.enc for secure
 });
 program.command("export-key").description("Display your trading wallet private key for backup").option("-d, --dir <path>", "Directory containing .env or .env.enc file", ".").option("-p, --passphrase <passphrase>", "Passphrase to decrypt .env.enc").action(async (options) => {
   try {
-    const dir = options.dir.startsWith("/") ? options.dir : path.join(process.cwd(), options.dir);
+    const dir = options.dir.startsWith("/") ? options.dir : path4.join(process.cwd(), options.dir);
     let passphrase = options.passphrase || process.env.EXAGENT_PASSPHRASE;
-    const encPath = path.join(dir, ".env.enc");
-    const envPath = path.join(dir, ".env");
-    if (fs.existsSync(encPath) && !passphrase) {
+    const encPath = path4.join(dir, ".env.enc");
+    const envPath = path4.join(dir, ".env");
+    if (fs3.existsSync(encPath) && !passphrase) {
       console.log("");
       console.log("  Encrypted config found (.env.enc)");
       console.log("");
@@ -505,7 +1442,7 @@ program.command("export-key").description("Display your trading wallet private k
       console.log("");
     }
     const usedEncrypted = loadSecureEnv(dir, passphrase);
-    if (!usedEncrypted && fs.existsSync(envPath)) {
+    if (!usedEncrypted && fs3.existsSync(envPath)) {
       const { config: loadDotenv } = await import("dotenv");
       loadDotenv({ path: envPath, override: true });
     }
@@ -543,4 +1480,132 @@ program.command("export-key").description("Display your trading wallet private k
     process.exit(1);
   }
 });
+program.command("backtest").description("Run a historical backtest of your strategy against past market data").option("-c, --config <path>", "Path to agent-config.json", "agent-config.json").option("-p, --passphrase <passphrase>", "Passphrase to decrypt .env.enc").option("--start <date>", "Start date (YYYY-MM-DD), default: 6 months ago").option("--end <date>", "End date (YYYY-MM-DD), default: today").option("--interval <interval>", "Candle interval: daily or hourly", "daily").option("--initial-eth <amount>", "Initial ETH balance", "0.5").option("--initial-usdc <amount>", "Initial USDC balance", "0").option("--tokens <addresses>", "Comma-separated token addresses to track").option("--fresh", "Clear price + LLM caches before starting").option("--no-cache", "Skip LLM caching (always make real calls)").action(async (options) => {
+  try {
+    const configDir = path4.dirname(
+      options.config.startsWith("/") ? options.config : path4.join(process.cwd(), options.config)
+    );
+    let passphrase = options.passphrase || process.env.EXAGENT_PASSPHRASE;
+    const encPath = path4.join(configDir, ".env.enc");
+    if (fs3.existsSync(encPath) && !passphrase) {
+      console.log("");
+      console.log("  Encrypted config found (.env.enc)");
+      console.log("");
+      passphrase = await prompt("  Enter passphrase: ", true);
+      console.log("");
+    }
+    const usedEncrypted = loadSecureEnv(configDir, passphrase);
+    if (usedEncrypted) {
+      console.log("Loaded encrypted environment (.env.enc)");
+    }
+    const config = loadConfig(options.config);
+    const now = Date.now();
+    const sixMonthsAgo = now - 180 * 24 * 60 * 60 * 1e3;
+    const startTime = options.start ? (/* @__PURE__ */ new Date(options.start + "T00:00:00Z")).getTime() : sixMonthsAgo;
+    const endTime = options.end ? (/* @__PURE__ */ new Date(options.end + "T23:59:59Z")).getTime() : now;
+    if (isNaN(startTime) || isNaN(endTime)) {
+      console.error("  ERROR: Invalid date format. Use YYYY-MM-DD.");
+      process.exit(1);
+    }
+    if (startTime >= endTime) {
+      console.error("  ERROR: Start date must be before end date.");
+      process.exit(1);
+    }
+    const interval = options.interval === "hourly" ? "hourly" : "daily";
+    const NATIVE_ETH2 = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+    const USDC_BASE = "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913";
+    const WETH_BASE2 = "0x4200000000000000000000000000000000000006";
+    const initialBalances = {};
+    const ethAmount = parseFloat(options.initialEth || "0.5");
+    if (ethAmount > 0) {
+      initialBalances[NATIVE_ETH2] = BigInt(Math.floor(ethAmount * 1e18));
+    }
+    const usdcAmount = parseFloat(options.initialUsdc || "0");
+    if (usdcAmount > 0) {
+      initialBalances[USDC_BASE] = BigInt(Math.floor(usdcAmount * 1e6));
+    }
+    let tokenAddresses = [];
+    if (options.tokens) {
+      tokenAddresses = options.tokens.split(",").map((t) => t.trim().toLowerCase());
+    } else if (config.allowedTokens && config.allowedTokens.length > 0) {
+      tokenAddresses = config.allowedTokens.map((t) => t.toLowerCase());
+    }
+    const baseTokens = [NATIVE_ETH2, USDC_BASE, WETH_BASE2];
+    for (const t of baseTokens) {
+      if (!tokenAddresses.includes(t.toLowerCase())) {
+        tokenAddresses.push(t.toLowerCase());
+      }
+    }
+    const durationDays = Math.ceil((endTime - startTime) / (24 * 60 * 60 * 1e3));
+    const estimatedCycles = interval === "daily" ? durationDays : durationDays * 24;
+    const estimatedCostLow = estimatedCycles * 0.01;
+    const estimatedCostHigh = estimatedCycles * 0.1;
+    console.log("");
+    console.log("=".repeat(60));
+    console.log("  EXAGENT HISTORICAL BACKTEST");
+    console.log("  Strategy refinement tool");
+    console.log("=".repeat(60));
+    console.log("");
+    console.log(`  Agent:      ${config.name} (ID: ${config.agentId})`);
+    console.log(`  LLM:        ${config.llm.provider} (${config.llm.model || "default"})`);
+    console.log(`  Universe:   ${config.riskUniverse}`);
+    console.log(`  Period:     ${new Date(startTime).toISOString().split("T")[0]} \u2192 ${new Date(endTime).toISOString().split("T")[0]} (${durationDays} days)`);
+    console.log(`  Interval:   ${interval} (~${estimatedCycles} cycles)`);
+    console.log(`  Tokens:     ${tokenAddresses.length}`);
+    if (ethAmount > 0) console.log(`  Initial ETH: ${ethAmount}`);
+    if (usdcAmount > 0) console.log(`  Initial USDC: ${usdcAmount}`);
+    console.log("");
+    console.log("\u2500".repeat(60));
+    console.log("  BACKTESTING NOTICE");
+    console.log("\u2500".repeat(60));
+    console.log("");
+    console.log("  - This backtest will make real LLM API calls using your");
+    console.log("    configured provider (results cached for re-runs).");
+    console.log(`  - Estimated cost: ~$${estimatedCostLow.toFixed(2)}-$${estimatedCostHigh.toFixed(2)} (${estimatedCycles} cycles)`);
+    console.log("  - Historical results do not guarantee future performance.");
+    console.log("  - LLM strategies are non-deterministic \u2014 running the same");
+    console.log("    backtest twice may produce different results.");
+    console.log("  - The LLM may have knowledge of historical market events");
+    console.log("    in its training data. This can bias results optimistically.");
+    console.log("");
+    console.log("  Paper trading (forward test) provides the most honest");
+    console.log("  evaluation of an LLM strategy.");
+    if (!options.cache) {
+      console.log("");
+      console.log("  --no-cache is ON: All LLM calls will be real (no caching).");
+    }
+    console.log("");
+    console.log("=".repeat(60));
+    console.log("");
+    await prompt("  Press Enter to start backtest...");
+    console.log("");
+    const { BacktestRunner: BacktestRunner2 } = (init_runner(), __toCommonJS(runner_exports));
+    const runner = new BacktestRunner2({
+      agentConfig: config,
+      startTime,
+      endTime,
+      interval,
+      initialBalances,
+      tokenAddresses,
+      noLLMCache: !options.cache,
+      freshStart: options.fresh
+    });
+    await runner.run((progress) => {
+      const pct = ((progress.step + 1) / progress.total * 100).toFixed(0);
+      const barLen = 20;
+      const filled = Math.round((progress.step + 1) / progress.total * barLen);
+      const bar = "\u2588".repeat(filled) + "\u2591".repeat(barLen - filled);
+      const tradeStr = progress.tradesThisStep > 0 ? ` ${progress.tradesThisStep} trade${progress.tradesThisStep > 1 ? "s" : ""}` : "";
+      process.stdout.write(
+        `\r  [${progress.step + 1}/${progress.total}] ${progress.date} $${progress.portfolioValue.toFixed(0)} ${bar} ${pct}%${tradeStr}    `
+      );
+    });
+    process.stdout.write("\r" + " ".repeat(80) + "\r");
+    process.exit(0);
+  } catch (error) {
+    console.error("");
+    console.error("Error:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
 program.parse();