@exagent/agent 0.1.37 → 0.1.39

package/dist/index.js

@@ -1635,7 +1635,7 @@ async function loadStrategy(strategyPath) {
   console.log("No custom strategy found, using default (hold) strategy");
   return defaultStrategy;
 }
-async function loadTypeScriptModule(path2) {
+async function loadTypeScriptModule(path4) {
   try {
     const tsxPath = require.resolve("tsx");
     const { pathToFileURL } = await import("url");
@@ -1646,7 +1646,7 @@ async function loadTypeScriptModule(path2) {
           "--import",
           "tsx/esm",
           "-e",
-          `import('${pathToFileURL(path2).href}').then(m => console.log(JSON.stringify({ exports: Object.keys(m) }))).catch(e => console.error('ERROR:', e.message))`
+          `import('${pathToFileURL(path4).href}').then(m => console.log(JSON.stringify({ exports: Object.keys(m) }))).catch(e => console.error('ERROR:', e.message))`
         ],
         {
           cwd: process.cwd(),
@@ -1669,7 +1669,7 @@ async function loadTypeScriptModule(path2) {
     const tsx = await import("tsx/esm/api");
     const unregister = tsx.register();
     try {
-      const module2 = await import(path2);
+      const module2 = await import(path4);
       return module2;
     } finally {
       unregister();
@@ -2248,6 +2248,24 @@ function classifyTradeError(message) {
       userMessage: "DEX aggregator not whitelisted on the router. Contact support."
     };
   }
+  if (lower.includes("token approval reverted")) {
+    return {
+      category: "approval_failed",
+      userMessage: "Token approval failed \u2014 this token may have non-standard approval behavior or be blocked. Skipping."
+    };
+  }
+  if (lower.includes("exceeds allowance") || lower.includes("allowance")) {
+    return {
+      category: "allowance",
+      userMessage: "Token allowance insufficient \u2014 approval may not have propagated. Will retry next cycle."
+    };
+  }
+  if (lower.includes("swapfailed")) {
+    return {
+      category: "swap_failed",
+      userMessage: "DEX swap failed \u2014 likely insufficient liquidity for this token. Will retry next cycle."
+    };
+  }
   if (lower.includes("reverted") || lower.includes("execution reverted")) {
     return {
       category: "reverted",
@@ -2274,8 +2292,11 @@ var RiskManager = class {
   lastResetDate = "";
   /** Minimum trade value in USD — trades below this are rejected as dust */
   minTradeValueUSD;
-  constructor(config) {
+  /** Risk universe (0-4). Frontier (4) bypasses buy-only guardrails. */
+  riskUniverse;
+  constructor(config, riskUniverse = 0) {
     this.config = config;
+    this.riskUniverse = riskUniverse;
     this.minTradeValueUSD = config.minTradeValueUSD ?? 1;
   }
   /**
@@ -2311,6 +2332,9 @@ var RiskManager = class {
     if (signal.action === "sell") {
       return true;
     }
+    if (this.riskUniverse === 4) {
+      return true;
+    }
     const signalValue = this.estimateSignalValue(signal, marketData);
     const maxPositionValue = marketData.portfolioValue * this.config.maxPositionSizeBps / 1e4;
     if (signalValue > maxPositionValue) {
@@ -2692,7 +2716,7 @@ var VaultManager = class {
         canCreateVault: false,
         cannotCreateReason: "Vault operations disabled (contract address not set)",
         requirementsMet: false,
-        requirements: { veXARequired: BigInt(0), isBypassed: false }
+        requirements: { isBypassed: false }
       };
     }
     const vaultAddress = await this.getVaultAddress();
@@ -2729,16 +2753,10 @@ var VaultManager = class {
   }
   /**
    * Get vault creation requirements
-   * Note: No burnFee on mainnet — vault creation requires USDC seed instead
+   * Note: StakingStub always returns hasVaultAccess=true — no gate.
    */
   async getRequirements() {
-    const veXARequired = await this.publicClient.readContract({
-      address: this.addresses.vaultFactory,
-      abi: VAULT_FACTORY_ABI,
-      functionName: "minimumVeEXARequired"
-    });
-    const isBypassed = veXARequired === BigInt(0);
-    return { veXARequired, isBypassed };
+    return { isBypassed: true };
   }
   /**
    * Get the agent's vault address (cached)
@@ -3126,6 +3144,609 @@ function openBrowser(url) {
   }
 }
 
+// src/paper/executor.ts
+var PaperExecutor = class {
+  config;
+  allowedTokens;
+  prices;
+  slippageBps;
+  feeRateBps;
+  estimatedGasUSD;
+  /** Running totals for the paper session */
+  totalFeesPaid = 0;
+  totalGasPaid = 0;
+  tradeCount = 0;
+  constructor(config, options) {
+    this.config = config;
+    this.slippageBps = options?.slippageBps ?? 50;
+    this.feeRateBps = options?.feeRateBps ?? 20;
+    this.estimatedGasUSD = options?.estimatedGasUSD ?? 0.01;
+    this.prices = {};
+    this.allowedTokens = new Set(
+      (config.allowedTokens || []).map((t) => t.toLowerCase())
+    );
+  }
+  /**
+   * Update live prices before executing trades.
+   * Called by the runtime before each cycle with current market data.
+   */
+  updatePrices(prices) {
+    this.prices = prices;
+  }
+  /**
+   * Simulate a single trade.
+   * Returns the same shape as TradeExecutor.execute() for drop-in compatibility.
+   */
+  async execute(signal) {
+    if (signal.action === "hold") {
+      return { success: true };
+    }
+    if (!this.validateSignal(signal)) {
+      return { success: false, error: "Signal failed validation" };
+    }
+    const tokenInPrice = this.prices[signal.tokenIn.toLowerCase()];
+    const tokenOutPrice = this.prices[signal.tokenOut.toLowerCase()];
+    if (!tokenInPrice || !tokenOutPrice) {
+      return {
+        success: false,
+        error: `Missing price data: ${!tokenInPrice ? signal.tokenIn : signal.tokenOut}`
+      };
+    }
+    const fill = this.simulateFill(signal, tokenInPrice, tokenOutPrice);
+    this.tradeCount++;
+    this.totalFeesPaid += fill.feeUSD;
+    this.totalGasPaid += this.estimatedGasUSD;
+    console.log(
+      `  [PAPER] ${signal.action.toUpperCase()}: ${signal.tokenIn.slice(0, 10)}... \u2192 ${signal.tokenOut.slice(0, 10)}...`
+    );
+    console.log(
+      `  [PAPER] Fill: $${fill.valueInUSD.toFixed(2)} \u2192 $${fill.valueOutUSD.toFixed(2)} (slippage: ${fill.appliedSlippageBps}bps, fee: $${fill.feeUSD.toFixed(4)})`
+    );
+    return {
+      success: true,
+      txHash: `paper-${Date.now()}-${this.tradeCount}`,
+      paperFill: fill
+    };
+  }
+  /**
+   * Simulate multiple trades (same interface as TradeExecutor.executeAll).
+   */
+  async executeAll(signals) {
+    const results = [];
+    for (const signal of signals) {
+      const result = await this.execute(signal);
+      results.push({ signal, ...result });
+    }
+    return results;
+  }
+  /**
+   * Get session totals for reporting.
+   */
+  getSessionStats() {
+    return {
+      tradeCount: this.tradeCount,
+      totalFeesPaid: this.totalFeesPaid,
+      totalGasPaid: this.totalGasPaid,
+      slippageBps: this.slippageBps,
+      feeRateBps: this.feeRateBps
+    };
+  }
+  /**
+   * Reset session stats (e.g., when starting a new paper session).
+   */
+  resetStats() {
+    this.tradeCount = 0;
+    this.totalFeesPaid = 0;
+    this.totalGasPaid = 0;
+  }
+  // --- Private methods ---
+  simulateFill(signal, tokenInPrice, tokenOutPrice) {
+    const decimalsIn = getTokenDecimals(signal.tokenIn);
+    const valueInUSD = Number(signal.amountIn) / Math.pow(10, decimalsIn) * tokenInPrice;
+    const afterFeeUSD = valueInUSD * (1 - this.feeRateBps / 1e4);
+    const feeUSD = valueInUSD - afterFeeUSD;
+    const afterSlippageUSD = afterFeeUSD * (1 - this.slippageBps / 1e4);
+    const decimalsOut = getTokenDecimals(signal.tokenOut);
+    const amountOut = BigInt(Math.floor(afterSlippageUSD / tokenOutPrice * Math.pow(10, decimalsOut)));
+    return {
+      signal,
+      timestamp: Date.now(),
+      valueInUSD,
+      valueOutUSD: afterSlippageUSD,
+      feeUSD,
+      gasUSD: this.estimatedGasUSD,
+      amountOut,
+      fillPriceUSD: tokenOutPrice * (1 + this.slippageBps / 1e4),
+      // worse price due to slippage
+      appliedSlippageBps: this.slippageBps
+    };
+  }
+  validateSignal(signal) {
+    if (signal.confidence < 0.5) {
+      console.warn(`  [PAPER] Signal confidence ${signal.confidence} below threshold (0.5)`);
+      return false;
+    }
+    if (this.allowedTokens.size > 0) {
+      const tokenInAllowed = this.allowedTokens.has(signal.tokenIn.toLowerCase());
+      const tokenOutAllowed = this.allowedTokens.has(signal.tokenOut.toLowerCase());
+      if (!tokenInAllowed || !tokenOutAllowed) {
+        console.warn(`  [PAPER] Token not in allowed list \u2014 skipping`);
+        return false;
+      }
+    }
+    return true;
+  }
+};
+
+// src/paper/portfolio.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var SimulatedPortfolio = class _SimulatedPortfolio {
+  balances;
+  initialBalances;
+  equityCurve;
+  trades;
+  startedAt;
+  dataDir;
+  constructor(initialBalances, dataDir, options) {
+    this.balances = {};
+    this.initialBalances = {};
+    for (const [addr, amount] of Object.entries(initialBalances)) {
+      const key = addr.toLowerCase();
+      this.balances[key] = amount;
+      this.initialBalances[key] = amount;
+    }
+    this.equityCurve = [];
+    this.trades = [];
+    this.startedAt = options?.startedAt ?? Date.now();
+    this.dataDir = dataDir;
+    if (!fs.existsSync(dataDir)) {
+      fs.mkdirSync(dataDir, { recursive: true });
+    }
+  }
+  /**
+   * Get the session start timestamp.
+   */
+  getStartedAt() {
+    return this.startedAt;
+  }
+  /**
+   * Get current balances in the same format as MarketData.balances.
+   * Used by the runtime to build MarketData for strategy calls.
+   */
+  getBalances() {
+    return { ...this.balances };
+  }
+  /**
+   * Apply a paper trade fill to the portfolio.
+   * Deducts tokenIn, adds tokenOut.
+   */
+  applyFill(fill) {
+    const tokenIn = fill.signal.tokenIn.toLowerCase();
+    const tokenOut = fill.signal.tokenOut.toLowerCase();
+    const currentIn = this.balances[tokenIn] || BigInt(0);
+    const newIn = currentIn - fill.signal.amountIn;
+    if (newIn < BigInt(0)) {
+      console.warn(`  [PAPER] Warning: balance went negative for ${tokenIn} \u2014 clamping to 0`);
+      this.balances[tokenIn] = BigInt(0);
+    } else {
+      this.balances[tokenIn] = newIn;
+    }
+    const currentOut = this.balances[tokenOut] || BigInt(0);
+    this.balances[tokenOut] = currentOut + fill.amountOut;
+    this.trades.push({
+      timestamp: fill.timestamp,
+      action: fill.signal.action,
+      tokenIn,
+      tokenOut,
+      amountIn: fill.signal.amountIn.toString(),
+      amountOut: fill.amountOut.toString(),
+      valueInUSD: fill.valueInUSD,
+      valueOutUSD: fill.valueOutUSD,
+      feeUSD: fill.feeUSD,
+      gasUSD: fill.gasUSD,
+      reasoning: fill.signal.reasoning
+    });
+  }
+  /**
+   * Record a portfolio value snapshot (called after each cycle).
+   * @param prices - Current token prices
+   * @param timestamp - Optional timestamp override (for backtesting with historical timestamps)
+   */
+  recordEquityPoint(prices, timestamp) {
+    const value = this.calculateValue(prices);
+    this.equityCurve.push({
+      timestamp: timestamp ?? Date.now(),
+      value
+    });
+  }
+  /**
+   * Calculate current portfolio value in USD.
+   */
+  calculateValue(prices) {
+    let total = 0;
+    for (const [token, balance] of Object.entries(this.balances)) {
+      if (balance <= BigInt(0)) continue;
+      const price = prices[token.toLowerCase()] || 0;
+      const decimals = getTokenDecimals(token);
+      total += Number(balance) / Math.pow(10, decimals) * price;
+    }
+    return total;
+  }
+  /**
+   * Calculate initial portfolio value for return comparison.
+   */
+  calculateInitialValue(prices) {
+    let total = 0;
+    for (const [token, balance] of Object.entries(this.initialBalances)) {
+      if (balance <= BigInt(0)) continue;
+      const price = prices[token.toLowerCase()] || 0;
+      const decimals = getTokenDecimals(token);
+      total += Number(balance) / Math.pow(10, decimals) * price;
+    }
+    return total;
+  }
+  /**
+   * Get equity curve data.
+   */
+  getEquityCurve() {
+    return [...this.equityCurve];
+  }
+  /**
+   * Get all paper trades.
+   */
+  getTrades() {
+    return [...this.trades];
+  }
+  /**
+   * Get summary for display.
+   */
+  getSummary(prices) {
+    const currentValue = this.calculateValue(prices);
+    const initialValue = this.calculateInitialValue(prices);
+    const totalReturn = initialValue > 0 ? (currentValue - initialValue) / initialValue * 100 : 0;
+    const totalFees = this.trades.reduce((sum, t) => sum + t.feeUSD, 0);
+    const totalGas = this.trades.reduce((sum, t) => sum + t.gasUSD, 0);
+    return {
+      startedAt: this.startedAt,
+      currentValue,
+      initialValue,
+      totalReturnPct: totalReturn,
+      totalReturnUSD: currentValue - initialValue,
+      tradeCount: this.trades.length,
+      totalFees,
+      totalGas,
+      positions: this.getPositionBreakdown(prices)
+    };
+  }
+  /**
+   * Persist portfolio state to disk.
+   */
+  save() {
+    const filePath = path.join(this.dataDir, "paper-portfolio.json");
+    const data = {
+      startedAt: this.startedAt,
+      balances: Object.fromEntries(
+        Object.entries(this.balances).map(([k, v]) => [k, v.toString()])
+      ),
+      initialBalances: Object.fromEntries(
+        Object.entries(this.initialBalances).map(([k, v]) => [k, v.toString()])
+      ),
+      equityCurve: this.equityCurve,
+      trades: this.trades
+    };
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+  }
+  /**
+   * Load portfolio state from disk (for resuming a paper session).
+   * Returns null if no saved state exists.
+   */
+  static load(dataDir) {
+    const filePath = path.join(dataDir, "paper-portfolio.json");
+    if (!fs.existsSync(filePath)) return null;
+    try {
+      const raw = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+      const initialBalances = {};
+      for (const [k, v] of Object.entries(raw.initialBalances)) {
+        initialBalances[k] = BigInt(v);
+      }
+      const portfolio = new _SimulatedPortfolio(initialBalances, dataDir);
+      portfolio.startedAt = raw.startedAt;
+      portfolio.equityCurve = raw.equityCurve || [];
+      portfolio.trades = raw.trades || [];
+      portfolio.balances = {};
+      for (const [k, v] of Object.entries(raw.balances)) {
+        portfolio.balances[k] = BigInt(v);
+      }
+      return portfolio;
+    } catch {
+      console.warn("  [PAPER] Failed to load saved portfolio state \u2014 starting fresh");
+      return null;
+    }
+  }
+  /**
+   * Delete saved state (for starting a new paper session).
+   */
+  static clear(dataDir) {
+    const filePath = path.join(dataDir, "paper-portfolio.json");
+    if (fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath);
+    }
+  }
+  // --- Private ---
+  getPositionBreakdown(prices) {
+    const positions = [];
+    for (const [token, balance] of Object.entries(this.balances)) {
+      if (balance <= BigInt(0)) continue;
+      const price = prices[token.toLowerCase()] || 0;
+      const decimals = getTokenDecimals(token);
+      const valueUSD = Number(balance) / Math.pow(10, decimals) * price;
+      if (valueUSD >= 0.01) {
+        positions.push({
+          token,
+          balance: (Number(balance) / Math.pow(10, decimals)).toFixed(6),
+          valueUSD
+        });
+      }
+    }
+    return positions.sort((a, b) => b.valueUSD - a.valueUSD);
+  }
+};
+
+// src/paper/results.ts
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+
+// src/paper/metrics.ts
+function calculateMetrics(trades, equityCurve, initialValue, currentValue, startedAt, endedAt) {
+  const durationMs = (endedAt ?? Date.now()) - startedAt;
+  const durationDays = durationMs / (1e3 * 60 * 60 * 24);
+  const totalReturnUSD = currentValue - initialValue;
+  const totalReturnPct = initialValue > 0 ? totalReturnUSD / initialValue * 100 : 0;
+  const actionTrades = trades.filter((t) => t.action !== "hold");
+  let wins = 0;
+  let losses = 0;
+  let grossProfit = 0;
+  let grossLoss = 0;
+  for (const trade of actionTrades) {
+    const pnl = trade.valueOutUSD - trade.valueInUSD;
+    if (pnl >= 0) {
+      wins++;
+      grossProfit += pnl;
+    } else {
+      losses++;
+      grossLoss += Math.abs(pnl);
+    }
+  }
+  const winRate = actionTrades.length > 0 ? wins / actionTrades.length : 0;
+  const profitFactor = grossLoss > 0 ? grossProfit / grossLoss : null;
+  const { maxDrawdownPct, maxDrawdownUSD } = calculateMaxDrawdown(equityCurve);
+  const { sharpe, sortino } = calculateRiskMetrics(equityCurve);
+  const totalFees = trades.reduce((s, t) => s + t.feeUSD, 0);
+  const totalGas = trades.reduce((s, t) => s + t.gasUSD, 0);
+  const avgTradeValueUSD = actionTrades.length > 0 ? actionTrades.reduce((s, t) => s + t.valueInUSD, 0) / actionTrades.length : 0;
+  const tradesPerDay = durationDays > 0 ? actionTrades.length / durationDays : 0;
+  return {
+    totalReturnPct,
+    totalReturnUSD,
+    winRate,
+    wins,
+    losses,
+    maxDrawdownPct,
+    maxDrawdownUSD,
+    sharpeRatio: sharpe,
+    sortinoRatio: sortino,
+    profitFactor,
+    avgTradeValueUSD,
+    totalFees,
+    totalGas,
+    durationMs,
+    tradesPerDay
+  };
+}
+function calculateMaxDrawdown(curve) {
+  if (curve.length < 2) return { maxDrawdownPct: 0, maxDrawdownUSD: 0 };
+  let peak = curve[0].value;
+  let maxDrawdownPct = 0;
+  let maxDrawdownUSD = 0;
+  for (const point of curve) {
+    if (point.value > peak) {
+      peak = point.value;
+    }
+    if (peak > 0) {
+      const drawdownPct = (point.value - peak) / peak * 100;
+      const drawdownUSD = point.value - peak;
+      if (drawdownPct < maxDrawdownPct) {
+        maxDrawdownPct = drawdownPct;
+        maxDrawdownUSD = drawdownUSD;
+      }
+    }
+  }
+  return { maxDrawdownPct, maxDrawdownUSD };
+}
+function calculateRiskMetrics(curve) {
+  if (curve.length < 3) return { sharpe: null, sortino: null };
+  const returns = [];
+  for (let i = 1; i < curve.length; i++) {
+    if (curve[i - 1].value > 0) {
+      returns.push((curve[i].value - curve[i - 1].value) / curve[i - 1].value);
+    }
+  }
+  if (returns.length < 2) return { sharpe: null, sortino: null };
+  const meanReturn = returns.reduce((s, r) => s + r, 0) / returns.length;
+  const variance = returns.reduce((s, r) => s + (r - meanReturn) ** 2, 0) / (returns.length - 1);
+  const stdDev = Math.sqrt(variance);
+  const downsideVariance = returns.reduce((s, r) => {
+    const downside = Math.min(0, r);
+    return s + downside ** 2;
+  }, 0) / (returns.length - 1);
+  const downsideDev = Math.sqrt(downsideVariance);
+  const totalTimeMs = curve[curve.length - 1].timestamp - curve[0].timestamp;
+  const avgPeriodMs = totalTimeMs / (curve.length - 1);
+  const periodsPerYear = avgPeriodMs > 0 ? 365 * 24 * 60 * 60 * 1e3 / avgPeriodMs : 365;
+  const sharpe = stdDev > 0 ? meanReturn / stdDev * Math.sqrt(periodsPerYear) : null;
+  const sortino = downsideDev > 0 ? meanReturn / downsideDev * Math.sqrt(periodsPerYear) : null;
+  return { sharpe, sortino };
+}
+
+// src/paper/results.ts
+function saveSessionResult(dataDir, agentName, llm, portfolio, equityCurve, trades, startedAt, options) {
+  const endedAt = options?.endedAt ?? Date.now();
+  const durationMs = endedAt - startedAt;
+  const prefix = options?.idPrefix ?? "paper";
+  const id = `${prefix}-${startedAt}`;
+  const metrics = calculateMetrics(
+    trades,
+    equityCurve,
+    portfolio.initialValue,
+    portfolio.currentValue,
+    startedAt,
+    endedAt
+  );
+  const result = {
+    id,
+    agentName,
+    startedAt,
+    endedAt,
+    durationMs,
+    llm,
+    initialValue: portfolio.initialValue,
+    finalValue: portfolio.currentValue,
+    metrics,
+    portfolio,
+    equityCurve,
+    trades
+  };
+  const sessionsDir = path2.join(dataDir, "sessions");
+  if (!fs2.existsSync(sessionsDir)) {
+    fs2.mkdirSync(sessionsDir, { recursive: true });
+  }
+  const filePath = path2.join(sessionsDir, `${id}.json`);
+  fs2.writeFileSync(filePath, JSON.stringify(result, null, 2));
+  console.log(`  [PAPER] Session saved: ${filePath}`);
+  return result;
+}
+function formatSessionReport(result) {
+  const m = result.metrics;
+  const lines = [];
+  const divider = "\u2550".repeat(56);
+  const thinDivider = "\u2500".repeat(56);
+  lines.push("");
+  lines.push(`  ${divider}`);
+  lines.push(`  PAPER TRADING RESULTS \u2014 ${result.agentName}`);
+  lines.push(`  ${divider}`);
+  lines.push("");
+  lines.push(`  Session:     ${result.id}`);
+  lines.push(`  Started:     ${new Date(result.startedAt).toLocaleString()}`);
+  lines.push(`  Ended:       ${new Date(result.endedAt).toLocaleString()}`);
+  lines.push(`  Duration:    ${formatDuration(result.durationMs)}`);
+  lines.push(`  LLM:         ${result.llm.provider}/${result.llm.model}`);
+  lines.push("");
+  lines.push(`  ${thinDivider}`);
+  lines.push("  PERFORMANCE");
+  lines.push(`  ${thinDivider}`);
+  lines.push("");
+  const returnSign = m.totalReturnPct >= 0 ? "+" : "";
+  lines.push(`  Total Return:     ${returnSign}${m.totalReturnPct.toFixed(2)}% ($${m.totalReturnUSD.toFixed(2)})`);
+  lines.push(`  Initial Value:    $${result.initialValue.toFixed(2)}`);
+  lines.push(`  Final Value:      $${result.finalValue.toFixed(2)}`);
+  lines.push("");
+  lines.push(`  Max Drawdown:     ${m.maxDrawdownPct.toFixed(2)}% ($${m.maxDrawdownUSD.toFixed(2)})`);
+  lines.push(`  Sharpe Ratio:     ${m.sharpeRatio !== null ? m.sharpeRatio.toFixed(2) : "N/A"}`);
+  lines.push(`  Sortino Ratio:    ${m.sortinoRatio !== null ? m.sortinoRatio.toFixed(2) : "N/A"}`);
+  lines.push("");
+  lines.push(`  ${thinDivider}`);
+  lines.push("  TRADES");
+  lines.push(`  ${thinDivider}`);
+  lines.push("");
+  lines.push(`  Total Trades:     ${result.trades.length}`);
+  lines.push(`  Win Rate:         ${(m.winRate * 100).toFixed(1)}% (${m.wins}W / ${m.losses}L)`);
+  lines.push(`  Profit Factor:    ${m.profitFactor !== null ? m.profitFactor.toFixed(2) : "N/A"}`);
+  lines.push(`  Avg Trade Size:   $${m.avgTradeValueUSD.toFixed(2)}`);
+  lines.push(`  Trades/Day:       ${m.tradesPerDay.toFixed(1)}`);
+  lines.push("");
+  lines.push(`  ${thinDivider}`);
+  lines.push("  COSTS (SIMULATED)");
+  lines.push(`  ${thinDivider}`);
+  lines.push("");
+  lines.push(`  Total Fees:       $${m.totalFees.toFixed(4)}`);
+  lines.push(`  Total Gas:        $${m.totalGas.toFixed(4)}`);
+  lines.push(`  Total Costs:      $${(m.totalFees + m.totalGas).toFixed(4)}`);
+  lines.push("");
+  if (result.portfolio.positions.length > 0) {
+    lines.push(`  ${thinDivider}`);
+    lines.push("  FINAL POSITIONS");
+    lines.push(`  ${thinDivider}`);
+    lines.push("");
+    for (const pos of result.portfolio.positions) {
+      const tokenShort = pos.token.slice(0, 10) + "...";
+      lines.push(`  ${tokenShort}  ${pos.balance}  $${pos.valueUSD.toFixed(2)}`);
+    }
+    lines.push("");
+  }
+  if (result.equityCurve.length >= 3) {
+    lines.push(`  ${thinDivider}`);
+    lines.push("  EQUITY CURVE");
+    lines.push(`  ${thinDivider}`);
+    lines.push("");
+    lines.push(renderAsciiChart(result.equityCurve));
+    lines.push("");
+  }
+  lines.push(`  ${divider}`);
+  lines.push("  DISCLAIMER: Simulated results do not represent actual");
+  lines.push("  trading. Past performance does not guarantee future");
+  lines.push("  results. LLM strategies are non-deterministic. Real");
+  lines.push("  trading may differ due to slippage, liquidity, MEV,");
+  lines.push("  and execution timing.");
+  lines.push(`  ${divider}`);
+  lines.push("");
+  return lines.join("\n");
+}
+function formatDuration(ms) {
+  const seconds = Math.floor(ms / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  const mins = minutes % 60;
+  if (hours < 24) return `${hours}h ${mins}m`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ${hours % 24}h`;
+}
+function renderAsciiChart(curve) {
+  const width = 48;
+  const height = 8;
+  const step = Math.max(1, Math.floor(curve.length / width));
+  const sampled = curve.filter((_, i) => i % step === 0).slice(0, width);
+  const values = sampled.map((p) => p.value);
+  const min = Math.min(...values);
+  const max = Math.max(...values);
+  const range = max - min || 1;
+  const lines = [];
+  for (let row = height - 1; row >= 0; row--) {
+    const threshold = min + range * row / (height - 1);
+    let line = "  \u2502";
+    for (const val of values) {
+      const normalized = (val - min) / range * (height - 1);
+      if (Math.round(normalized) === row) {
+        line += "\u2588";
+      } else if (Math.round(normalized) > row) {
+        line += "\u2591";
+      } else {
+        line += " ";
+      }
+    }
+    if (row === height - 1) {
+      line += `  $${max.toFixed(0)}`;
+    } else if (row === 0) {
+      line += `  $${min.toFixed(0)}`;
+    }
+    lines.push(line);
+  }
+  lines.push("  \u2514" + "\u2500".repeat(values.length));
+  return lines.join("\n");
+}
+
 // src/perp/client.ts
 var HyperliquidClient = class {
   apiUrl;
@@ -4395,6 +5016,11 @@ var AgentRuntime = class {
   allowedTokens = /* @__PURE__ */ new Set();
   strategyContext;
   positionTracker;
+  // Paper trading components (null when not in paper mode)
+  paperExecutor = null;
+  paperPortfolio = null;
+  /** Whether agent was started directly in paper mode via CLI */
+  startInPaperMode = false;
   // Perp trading components (null if perp not enabled)
   perpClient = null;
   perpSigner = null;
@@ -4417,9 +5043,13 @@ var AgentRuntime = class {
   cachedPerpMarginUsed = 0;
   cachedPerpLeverage = 0;
   cachedPerpOpenPositions = 0;
-  constructor(config) {
+  constructor(config, options) {
     this.config = config;
+    this.startInPaperMode = options?.paperMode ?? false;
+    this._paperInitialBalances = options?.paperBalances;
   }
+  /** Initial balances override for paper mode (from CLI --initial-eth/--initial-usdc) */
+  _paperInitialBalances;
   /**
    * Initialize the agent runtime
    */
@@ -4451,7 +5081,7 @@ var AgentRuntime = class {
     };
     this.positionTracker = new PositionTracker(store, { maxTradeHistory: 50 });
     this.executor = new TradeExecutor(this.client, this.config, () => this.getConfigHash());
-    this.riskManager = new RiskManager(this.config.trading);
+    this.riskManager = new RiskManager(this.config.trading, this.riskUniverse);
     this.marketData = new MarketDataService(this.getRpcUrl(), store);
     setGlobalResolver(this.marketData.getResolver());
     const savedRisk = this.positionTracker.getRiskState();
@@ -4872,16 +5502,20 @@ var AgentRuntime = class {
       } catch (error) {
         console.warn("Initial balance sync failed (non-fatal):", error instanceof Error ? error.message : error);
       }
+      if (this.startInPaperMode) {
+        await this.startPaperTrading(this._paperInitialBalances);
+      }
       this.sendRelayStatus();
       this.relay.sendMessage(
         "system",
         "success",
         "Agent Connected",
-        `${this.config.name} is online and waiting for commands.`,
+        `${this.config.name} is online${this.mode === "paper" ? " in PAPER TRADING mode" : " and waiting for commands"}.`,
         { wallet: this.client.address }
       );
       while (this.processAlive) {
-        if (this.mode === "trading" && this.isRunning) {
+        const currentMode = this.mode;
+        if ((currentMode === "trading" || currentMode === "paper") && this.isRunning) {
           try {
             await this.runCycle();
           } catch (error) {
@@ -4905,8 +5539,13 @@ var AgentRuntime = class {
         throw new Error("Agent is already running");
       }
       this.isRunning = true;
-      this.mode = "trading";
-      console.log("Starting trading loop...");
+      if (this.startInPaperMode) {
+        await this.startPaperTrading(this._paperInitialBalances);
+        console.log("Starting paper trading loop...");
+      } else {
+        this.mode = "trading";
+        console.log("Starting trading loop...");
+      }
       console.log(`Interval: ${this.config.trading.tradingIntervalMs}ms`);
       while (this.isRunning) {
         try {
@@ -4981,7 +5620,7 @@ var AgentRuntime = class {
             updated = true;
           }
           if (updated) {
-            this.riskManager = new RiskManager(this.config.trading);
+            this.riskManager = new RiskManager(this.config.trading, this.riskUniverse);
             const savedRiskState = this.positionTracker.getRiskState();
             if (savedRiskState.lastResetDate) {
               this.riskManager.restoreState(savedRiskState);
@@ -5153,6 +5792,41 @@ var AgentRuntime = class {
           }
           break;
         }
+        case "start_paper_trading":
+          if (this.mode === "paper") {
+            this.relay?.sendCommandResult(cmd.id, true, "Already paper trading");
+            return;
+          }
+          try {
+            await this.startPaperTrading();
+            this.relay?.sendCommandResult(cmd.id, true, "Paper trading started");
+            this.relay?.sendMessage(
+              "system",
+              "success",
+              "Paper Trading Started",
+              "Agent is now paper trading with simulated execution. No on-chain transactions will be made. Results are estimates \u2014 real trading may differ due to slippage, liquidity, and execution timing."
+            );
+          } catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.relay?.sendCommandResult(cmd.id, false, `Failed to start paper trading: ${msg}`);
+          }
+          this.sendRelayStatus();
+          break;
+        case "stop_paper_trading":
+          if (this.mode !== "paper") {
+            this.relay?.sendCommandResult(cmd.id, true, "Not paper trading");
+            return;
+          }
+          this.stopPaperTrading();
+          this.relay?.sendCommandResult(cmd.id, true, "Paper trading stopped");
+          this.relay?.sendMessage(
+            "system",
+            "info",
+            "Paper Trading Stopped",
+            `Paper session ended. ${this.paperPortfolio ? `Trades: ${this.paperPortfolio.getTrades().length}` : ""}`
+          );
+          this.sendRelayStatus();
+          break;
         case "refresh_status":
           this.sendRelayStatus();
           this.relay?.sendCommandResult(cmd.id, true, "Status refreshed");
@@ -5179,6 +5853,63 @@ var AgentRuntime = class {
       this.relay?.sendCommandResult(cmd.id, false, message);
     }
   }
+  // --- Paper Trading ---
+  /**
+   * Initialize and enter paper trading mode.
+   * Snapshots current on-chain balances (or uses provided overrides) as starting state.
+   */
+  async startPaperTrading(initialBalances) {
+    console.log("");
+    console.log("  \u250C\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\u2510");
+    console.log("  \u2502  PAPER TRADING MODE                         \u2502");
+    console.log("  \u2502  Simulated execution \u2014 no on-chain trades   \u2502");
+    console.log("  \u2502  Results are estimates only.                 \u2502");
+    console.log("  \u2514\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\u2518");
+    console.log("");
+    const paperDataDir = require("path").join(process.cwd(), "data", "paper");
+    if (initialBalances) {
+      this.paperPortfolio = new SimulatedPortfolio(initialBalances, paperDataDir);
+      console.log("  [PAPER] Using custom initial balances");
+    } else {
+      const existing = SimulatedPortfolio.load(paperDataDir);
+      if (existing) {
+        this.paperPortfolio = existing;
+        console.log("  [PAPER] Resumed existing paper session");
+      } else {
+        const tokens = this.getTokensToTrack();
+        const realData = await this.marketData.fetchMarketData(this.client.address, tokens);
+        this.paperPortfolio = new SimulatedPortfolio(realData.balances, paperDataDir);
+        console.log(`  [PAPER] Snapshotted on-chain balances ($${realData.portfolioValue.toFixed(2)})`);
+      }
+    }
+    this.paperExecutor = new PaperExecutor(this.config);
+    this.mode = "paper";
+    this.isRunning = true;
+  }
+  /**
+   * Exit paper trading mode and return to idle.
+   * Saves the paper portfolio state to disk.
+   */
+  stopPaperTrading() {
+    if (this.paperPortfolio) {
+      this.paperPortfolio.save();
+      const summary = this.paperPortfolio.getSummary(this.lastPrices);
+      const dataDir = require("path").join(process.cwd(), "data", "paper");
+      const result = saveSessionResult(
+        dataDir,
+        this.config.name,
+        { provider: this.config.llm.provider, model: this.config.llm.model || "default" },
+        summary,
+        this.paperPortfolio.getEquityCurve(),
+        this.paperPortfolio.getTrades(),
+        summary.startedAt
+      );
+      console.log(formatSessionReport(result));
+    }
+    this.mode = "idle";
+    this.isRunning = false;
+    this.paperExecutor = null;
+  }
   /**
    * Periodically check if the owner has approved the pending config hash.
    * Called from sendRelayStatus at most every 2.5 minutes (timestamp-throttled).
@@ -5249,6 +5980,29 @@ var AgentRuntime = class {
         pendingRecords: this.perpRecorder?.pendingRetries ?? 0
       } : void 0,
       positions: this.positionTracker ? this.positionTracker.getPositionSummary(this.lastPrices) : void 0,
+      paper: this.mode === "paper" && this.paperPortfolio ? (() => {
+        const summary = this.paperPortfolio.getSummary(this.lastPrices);
+        const trades = this.paperPortfolio.getTrades();
+        let wins = 0, losses = 0;
+        for (const t of trades) {
+          if (t.action === "hold") continue;
+          if (t.valueOutUSD >= t.valueInUSD) wins++;
+          else losses++;
+        }
+        const curve = this.paperPortfolio.getEquityCurve();
+        const equityCurve = curve.length > 50 ? curve.slice(-50) : curve;
+        return {
+          active: true,
+          startedAt: summary.startedAt,
+          simulatedValue: summary.currentValue,
+          simulatedPnLPct: summary.totalReturnPct,
+          tradeCount: summary.tradeCount,
+          totalFees: summary.totalFees,
+          wins,
+          losses,
+          equityCurve
+        };
+      })() : void 0,
       configHash: this.configHash || void 0,
       pendingConfigHash: this.pendingConfigHash
       // null preserved by JSON.stringify for clearing
@@ -5272,23 +6026,33 @@ var AgentRuntime = class {
    * Run a single trading cycle
    */
   async runCycle() {
+    const isPaper = this.mode === "paper";
+    const modeTag = isPaper ? "[PAPER] " : "";
     console.log(`
---- Trading Cycle: ${(/* @__PURE__ */ new Date()).toISOString()} ---`);
+--- ${modeTag}Trading Cycle: ${(/* @__PURE__ */ new Date()).toISOString()} ---`);
     this.cycleCount++;
     this.lastCycleAt = Date.now();
     const tokens = this.getTokensToTrack();
     const marketData = await this.marketData.fetchMarketData(this.client.address, tokens);
-    console.log(`Portfolio value: $${marketData.portfolioValue.toFixed(2)}`);
+    if (isPaper && this.paperPortfolio) {
+      const simBalances = this.paperPortfolio.getBalances();
+      marketData.balances = simBalances;
+      marketData.portfolioValue = this.paperPortfolio.calculateValue(marketData.prices);
+      this.paperExecutor?.updatePrices(marketData.prices);
+    }
+    console.log(`${modeTag}Portfolio value: $${marketData.portfolioValue.toFixed(2)}`);
     this.lastPortfolioValue = marketData.portfolioValue;
     this.lastPrices = marketData.prices;
     const nativeEthBal = marketData.balances[NATIVE_ETH.toLowerCase()] || BigInt(0);
     this.lastEthBalance = (Number(nativeEthBal) / 1e18).toFixed(6);
     this.positionTracker.syncBalances(marketData.balances, marketData.prices);
-    const fundsOk = this.checkFundsLow(marketData);
-    if (!fundsOk) {
-      console.warn("Skipping trading cycle \u2014 ETH balance critically low");
-      this.sendRelayStatus();
-      return;
+    if (!isPaper) {
+      const fundsOk = this.checkFundsLow(marketData);
+      if (!fundsOk) {
+        console.warn("Skipping trading cycle \u2014 ETH balance critically low");
+        this.sendRelayStatus();
+        return;
+      }
     }
     this.strategyContext.positions = this.positionTracker.getPositions();
     this.strategyContext.tradeHistory = this.positionTracker.getTradeHistory(20);
@@ -5319,74 +6083,133 @@ var AgentRuntime = class {
       );
     }
     if (filteredSignals.length > 0) {
-      const vaultStatus = await this.vaultManager?.getVaultStatus();
-      if (vaultStatus?.hasVault && this.vaultManager?.preferVaultTrading) {
-        console.log(`Trading through vault: ${vaultStatus.vaultAddress}`);
-      }
       const preTradePortfolioValue = marketData.portfolioValue;
-      const results = await this.executor.executeAll(filteredSignals);
-      let totalFeesUSD = 0;
-      for (const result of results) {
-        if (result.success) {
-          console.log(`Trade executed: ${result.signal.action} - ${result.txHash}`);
-          const feeCostBps = 20;
-          const signalPrice = marketData.prices[result.signal.tokenIn.toLowerCase()] || 0;
-          const amountUSD = Number(result.signal.amountIn) / Math.pow(10, getTokenDecimals(result.signal.tokenIn)) * signalPrice;
-          const feeCostUSD = amountUSD * feeCostBps / 1e4;
-          totalFeesUSD += feeCostUSD;
-          this.riskManager.updateFees(feeCostUSD);
-          this.relay?.sendMessage(
-            "trade_executed",
-            "success",
-            "Trade Executed",
-            `${result.signal.action.toUpperCase()}: ${result.signal.reasoning || "No reason provided"}`,
-            {
-              action: result.signal.action,
-              txHash: result.txHash,
-              tokenIn: result.signal.tokenIn,
-              tokenOut: result.signal.tokenOut
-            }
-          );
-        } else {
-          console.warn(`Trade failed: ${result.error}`);
-          this.relay?.sendMessage(
-            "trade_failed",
-            "error",
-            "Trade Failed",
-            result.error || "Unknown error",
-            { action: result.signal.action }
-          );
+      if (isPaper && this.paperExecutor && this.paperPortfolio) {
+        const results = await this.paperExecutor.executeAll(filteredSignals);
+        let totalFeesUSD = 0;
+        for (const result of results) {
+          if (result.success && result.paperFill) {
+            this.paperPortfolio.applyFill(result.paperFill);
+            totalFeesUSD += result.paperFill.feeUSD;
+            this.riskManager.updateFees(result.paperFill.feeUSD);
+            this.relay?.sendMessage(
+              "paper_trade_executed",
+              "success",
+              "[PAPER] Trade Executed",
+              `${result.signal.action.toUpperCase()}: ${result.signal.reasoning || "No reason provided"}`,
+              {
+                action: result.signal.action,
+                txHash: result.txHash,
+                tokenIn: result.signal.tokenIn,
+                tokenOut: result.signal.tokenOut,
+                paper: true,
+                valueInUSD: result.paperFill.valueInUSD,
+                valueOutUSD: result.paperFill.valueOutUSD
+              }
+            );
+          } else {
+            this.relay?.sendMessage(
+              "paper_trade_failed",
+              "error",
+              "[PAPER] Trade Failed",
+              result.error || "Unknown error",
+              { action: result.signal.action, paper: true }
+            );
+          }
+          const tokenIn = result.signal.tokenIn.toLowerCase();
+          const tokenOut = result.signal.tokenOut.toLowerCase();
+          this.positionTracker.recordTrade({
+            action: result.signal.action,
+            tokenIn,
+            tokenOut,
+            amountIn: result.signal.amountIn,
+            priceIn: marketData.prices[tokenIn] || 0,
+            priceOut: marketData.prices[tokenOut] || 0,
+            txHash: result.txHash,
+            reasoning: result.signal.reasoning,
+            success: result.success
+          });
         }
+        const postValue = this.paperPortfolio.calculateValue(marketData.prices);
+        const marketPnL = postValue - preTradePortfolioValue + totalFeesUSD;
+        this.riskManager.updatePnL(marketPnL);
+        this.positionTracker.saveRiskState(this.riskManager.exportState());
+        if (marketPnL !== 0) {
+          console.log(`  [PAPER] Cycle PnL: $${marketPnL.toFixed(2)} (market), -$${totalFeesUSD.toFixed(2)} (fees)`);
+        }
+        this.paperPortfolio.recordEquityPoint(marketData.prices);
+        this.positionTracker.syncBalances(this.paperPortfolio.getBalances(), marketData.prices);
+        this.lastPortfolioValue = postValue;
+        this.paperPortfolio.save();
+      } else {
+        const vaultStatus = await this.vaultManager?.getVaultStatus();
+        if (vaultStatus?.hasVault && this.vaultManager?.preferVaultTrading) {
+          console.log(`Trading through vault: ${vaultStatus.vaultAddress}`);
+        }
+        const results = await this.executor.executeAll(filteredSignals);
+        let totalFeesUSD = 0;
+        for (const result of results) {
+          if (result.success) {
+            console.log(`Trade executed: ${result.signal.action} - ${result.txHash}`);
+            const feeCostBps = 20;
+            const signalPrice = marketData.prices[result.signal.tokenIn.toLowerCase()] || 0;
+            const amountUSD = Number(result.signal.amountIn) / Math.pow(10, getTokenDecimals(result.signal.tokenIn)) * signalPrice;
+            const feeCostUSD = amountUSD * feeCostBps / 1e4;
+            totalFeesUSD += feeCostUSD;
+            this.riskManager.updateFees(feeCostUSD);
+            this.relay?.sendMessage(
+              "trade_executed",
+              "success",
+              "Trade Executed",
+              `${result.signal.action.toUpperCase()}: ${result.signal.reasoning || "No reason provided"}`,
+              {
+                action: result.signal.action,
+                txHash: result.txHash,
+                tokenIn: result.signal.tokenIn,
+                tokenOut: result.signal.tokenOut
+              }
+            );
+          } else {
+            console.warn(`Trade failed: ${result.error}`);
+            this.relay?.sendMessage(
+              "trade_failed",
+              "error",
+              "Trade Failed",
+              result.error || "Unknown error",
+              { action: result.signal.action }
+            );
+          }
+        }
+        for (const result of results) {
+          const tokenIn = result.signal.tokenIn.toLowerCase();
+          const tokenOut = result.signal.tokenOut.toLowerCase();
+          this.positionTracker.recordTrade({
+            action: result.signal.action,
+            tokenIn,
+            tokenOut,
+            amountIn: result.signal.amountIn,
+            priceIn: marketData.prices[tokenIn] || 0,
+            priceOut: marketData.prices[tokenOut] || 0,
+            txHash: result.txHash,
+            reasoning: result.signal.reasoning,
+            success: result.success
+          });
+        }
+        const postTokens = this.getTokensToTrack();
+        const postTradeData = await this.marketData.fetchMarketData(this.client.address, postTokens);
+        const marketPnL = postTradeData.portfolioValue - preTradePortfolioValue + totalFeesUSD;
+        this.riskManager.updatePnL(marketPnL);
+        this.positionTracker.saveRiskState(this.riskManager.exportState());
+        if (marketPnL !== 0) {
+          console.log(`Cycle PnL: $${marketPnL.toFixed(2)} (market), -$${totalFeesUSD.toFixed(2)} (fees)`);
+        }
+        this.positionTracker.syncBalances(postTradeData.balances, postTradeData.prices);
+        this.lastPortfolioValue = postTradeData.portfolioValue;
+        const postNativeEthBal = postTradeData.balances[NATIVE_ETH.toLowerCase()] || BigInt(0);
+        this.lastEthBalance = (Number(postNativeEthBal) / 1e18).toFixed(6);
       }
-      for (const result of results) {
-        const tokenIn = result.signal.tokenIn.toLowerCase();
-        const tokenOut = result.signal.tokenOut.toLowerCase();
-        this.positionTracker.recordTrade({
-          action: result.signal.action,
-          tokenIn,
-          tokenOut,
-          amountIn: result.signal.amountIn,
-          priceIn: marketData.prices[tokenIn] || 0,
-          priceOut: marketData.prices[tokenOut] || 0,
-          txHash: result.txHash,
-          reasoning: result.signal.reasoning,
-          success: result.success
-        });
-      }
-      const postTokens = this.getTokensToTrack();
-      const postTradeData = await this.marketData.fetchMarketData(this.client.address, postTokens);
-      const marketPnL = postTradeData.portfolioValue - preTradePortfolioValue + totalFeesUSD;
-      this.riskManager.updatePnL(marketPnL);
-      this.positionTracker.saveRiskState(this.riskManager.exportState());
-      if (marketPnL !== 0) {
-        console.log(`Cycle PnL: $${marketPnL.toFixed(2)} (market), -$${totalFeesUSD.toFixed(2)} (fees)`);
-      }
-      this.positionTracker.syncBalances(postTradeData.balances, postTradeData.prices);
-      this.lastPortfolioValue = postTradeData.portfolioValue;
-      const postNativeEthBal = postTradeData.balances[NATIVE_ETH.toLowerCase()] || BigInt(0);
-      this.lastEthBalance = (Number(postNativeEthBal) / 1e18).toFixed(6);
     }
-    if (this.perpConnected && this.perpTradingActive) {
+    if (!isPaper && this.perpConnected && this.perpTradingActive) {
       try {
         await this.runPerpCycle();
       } catch (error) {
@@ -5701,8 +6524,8 @@ var AgentRuntime = class {
 
 // src/secure-env.ts
 var crypto = __toESM(require("crypto"));
-var fs = __toESM(require("fs"));
-var path = __toESM(require("path"));
+var fs3 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
 var ALGORITHM = "aes-256-gcm";
 var PBKDF2_ITERATIONS = 1e5;
 var SALT_LENGTH = 32;
@@ -5769,10 +6592,10 @@ function parseEnvFile(content) {
   return entries;
 }
 function encryptEnvFile(envPath, passphrase, deleteOriginal = false) {
-  if (!fs.existsSync(envPath)) {
+  if (!fs3.existsSync(envPath)) {
     throw new Error(`File not found: ${envPath}`);
   }
-  const content = fs.readFileSync(envPath, "utf-8");
+  const content = fs3.readFileSync(envPath, "utf-8");
   const entries = parseEnvFile(content);
   if (entries.length === 0) {
     throw new Error("No environment variables found in file");
@@ -5802,9 +6625,9 @@ function encryptEnvFile(envPath, passphrase, deleteOriginal = false) {
     entries: encryptedEntries
   };
   const encPath = envPath + ".enc";
-  fs.writeFileSync(encPath, JSON.stringify(encryptedEnv, null, 2), { mode: 384 });
+  fs3.writeFileSync(encPath, JSON.stringify(encryptedEnv, null, 2), { mode: 384 });
   if (deleteOriginal) {
-    fs.unlinkSync(envPath);
+    fs3.unlinkSync(envPath);
   }
   const sensitiveCount = encryptedEntries.filter((e) => e.encrypted).length;
   const plainCount = encryptedEntries.filter((e) => !e.encrypted).length;
@@ -5814,10 +6637,10 @@ function encryptEnvFile(envPath, passphrase, deleteOriginal = false) {
   return encPath;
 }
 function decryptEnvFile(encPath, passphrase) {
-  if (!fs.existsSync(encPath)) {
+  if (!fs3.existsSync(encPath)) {
     throw new Error(`Encrypted env file not found: ${encPath}`);
   }
-  const content = JSON.parse(fs.readFileSync(encPath, "utf-8"));
+  const content = JSON.parse(fs3.readFileSync(encPath, "utf-8"));
   if (content.version !== 1) {
     throw new Error(`Unsupported encrypted env version: ${content.version}`);
   }
@@ -5843,9 +6666,9 @@ function decryptEnvFile(encPath, passphrase) {
   return result;
 }
 function loadSecureEnv(basePath, passphrase) {
-  const encPath = path.join(basePath, ".env.enc");
-  const envPath = path.join(basePath, ".env");
-  if (fs.existsSync(encPath)) {
+  const encPath = path3.join(basePath, ".env.enc");
+  const envPath = path3.join(basePath, ".env");
+  if (fs3.existsSync(encPath)) {
     if (!passphrase) {
       passphrase = process.env.EXAGENT_PASSPHRASE;
     }
@@ -5864,8 +6687,8 @@ function loadSecureEnv(basePath, passphrase) {
       return true;
     }
   }
-  if (fs.existsSync(envPath)) {
-    const content = fs.readFileSync(envPath, "utf-8");
+  if (fs3.existsSync(envPath)) {
+    const content = fs3.readFileSync(envPath, "utf-8");
     const entries = parseEnvFile(content);
     const sensitiveKeys = entries.filter(({ key }) => isSensitiveKey(key)).map(({ key }) => key);
     if (sensitiveKeys.length > 0) {
@@ -5884,7 +6707,7 @@ function loadSecureEnv(basePath, passphrase) {
 }
 
 // src/index.ts
-var AGENT_VERSION = "0.1.37";
+var AGENT_VERSION = "0.1.39";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AGENT_VERSION,