@exagent/agent 0.1.38 → 0.1.40

package/dist/index.js

@@ -45,6 +45,8 @@ __export(index_exports, {
   HyperliquidWebSocket: () => HyperliquidWebSocket,
   LLMConfigSchema: () => LLMConfigSchema,
   LLMProviderSchema: () => LLMProviderSchema,
+  MARKET_CATEGORIES: () => MARKET_CATEGORIES,
+  MarketBrowser: () => MarketBrowser,
   MarketDataService: () => MarketDataService,
   MistralAdapter: () => MistralAdapter,
   OllamaAdapter: () => OllamaAdapter,
@@ -53,8 +55,14 @@ __export(index_exports, {
   PerpConfigSchema: () => PerpConfigSchema,
   PerpOnboarding: () => PerpOnboarding,
   PerpTradeRecorder: () => PerpTradeRecorder,
+  PolymarketClient: () => PolymarketClient,
   PositionManager: () => PositionManager,
   PositionTracker: () => PositionTracker,
+  PredictionConfigSchema: () => PredictionConfigSchema,
+  PredictionFunding: () => PredictionFunding,
+  PredictionOrderManager: () => PredictionOrderManager,
+  PredictionPositionManager: () => PredictionPositionManager,
+  PredictionTradeRecorder: () => PredictionTradeRecorder,
   RelayClient: () => RelayClient,
   RelayConfigSchema: () => RelayConfigSchema,
   RiskManager: () => RiskManager,
@@ -66,9 +74,12 @@ __export(index_exports, {
   VaultConfigSchema: () => VaultConfigSchema,
   VaultManager: () => VaultManager,
   VaultPolicySchema: () => VaultPolicySchema,
+  calculatePredictionFee: () => calculatePredictionFee,
   createLLMAdapter: () => createLLMAdapter,
   createSampleConfig: () => createSampleConfig,
+  decodePredictionInstrument: () => decodePredictionInstrument,
   decryptEnvFile: () => decryptEnvFile,
+  encodePredictionInstrument: () => encodePredictionInstrument,
   encryptEnvFile: () => encryptEnvFile,
   fillHashToBytes32: () => fillHashToBytes32,
   fillOidToBytes32: () => fillOidToBytes32,
@@ -78,6 +89,8 @@ __export(index_exports, {
   loadConfig: () => loadConfig,
   loadSecureEnv: () => loadSecureEnv,
   loadStrategy: () => loadStrategy,
+  orderIdToBytes32: () => orderIdToBytes32,
+  tradeIdToBytes32: () => tradeIdToBytes32,
   validateConfig: () => validateConfig,
   validateStrategy: () => validateStrategy
 });
@@ -85,9 +98,9 @@ module.exports = __toCommonJS(index_exports);
 
 // src/runtime.ts
 var import_sdk = require("@exagent/sdk");
-var import_viem7 = require("viem");
-var import_chains5 = require("viem/chains");
-var import_accounts5 = require("viem/accounts");
+var import_viem11 = require("viem");
+var import_chains8 = require("viem/chains");
+var import_accounts8 = require("viem/accounts");
 
 // src/trading/market.ts
 var import_viem2 = require("viem");
@@ -1635,7 +1648,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 +1659,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 +1682,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();
@@ -2001,6 +2014,49 @@ var PerpConfigSchema = import_zod.z.object({
   /** Allowed perp instruments (e.g. ["ETH", "BTC", "SOL"]). If empty, all instruments allowed. */
   allowedInstruments: import_zod.z.array(import_zod.z.string()).optional()
 }).optional();
+var PredictionConfigSchema = import_zod.z.object({
+  /** Enable prediction market trading */
+  enabled: import_zod.z.boolean().default(false),
+  /** Polymarket CLOB API URL */
+  clobApiUrl: import_zod.z.string().url().default("https://clob.polymarket.com"),
+  /** Gamma API URL for market discovery */
+  gammaApiUrl: import_zod.z.string().url().default("https://gamma-api.polymarket.com"),
+  /** Polygon RPC URL */
+  polygonRpcUrl: import_zod.z.string().url().optional(),
+  /** CLOB API key (L2 auth) — derived from wallet signature if not provided */
+  clobApiKey: import_zod.z.string().optional(),
+  /** CLOB API secret (L2 auth) */
+  clobApiSecret: import_zod.z.string().optional(),
+  /** CLOB API passphrase (L2 auth) */
+  clobApiPassphrase: import_zod.z.string().optional(),
+  /** Private key for the prediction relayer (calls recordPerpTrade on Base). Falls back to agent wallet. */
+  predictionRelayerKey: import_zod.z.string().optional(),
+  /** Maximum notional per trade in USD (default: 500) */
+  maxNotionalUSD: import_zod.z.number().min(1).default(500),
+  /** Maximum total exposure across all markets in USD (default: 5000) */
+  maxTotalExposureUSD: import_zod.z.number().min(1).default(5e3),
+  /** Target USDC allocation on Polygon in USD (default: 100) */
+  polygonAllocationUSD: import_zod.z.number().min(1).default(100),
+  /** Allowed market categories (empty = all categories) */
+  allowedCategories: import_zod.z.array(import_zod.z.string()).optional(),
+  /** Fee bridge threshold in USD — accumulated fees are bridged to Base when exceeded (default: 10) */
+  feeBridgeThresholdUSD: import_zod.z.number().min(1).default(10),
+  /** Prediction vault configuration (ERC-4626 + ERC-1271 on Polygon) */
+  vault: import_zod.z.object({
+    /** Enable vault mode for prediction trading */
+    enabled: import_zod.z.boolean().default(false),
+    /** PredictionVaultFactory address on Polygon */
+    factoryAddress: import_zod.z.string(),
+    /** PredictionFeeCollector address on Polygon */
+    feeCollectorAddress: import_zod.z.string().optional(),
+    /** Existing vault address (if already created) */
+    vaultAddress: import_zod.z.string().optional(),
+    /** Agent's fee recipient address */
+    feeRecipient: import_zod.z.string().optional(),
+    /** Whether agent is verified (higher deposit cap) */
+    isVerified: import_zod.z.boolean().default(false)
+  }).optional()
+}).optional();
 var AgentConfigSchema = import_zod.z.object({
   // Identity (from on-chain registration)
   agentId: import_zod.z.union([import_zod.z.number().positive(), import_zod.z.string()]),
@@ -2020,6 +2076,8 @@ var AgentConfigSchema = import_zod.z.object({
   relay: RelayConfigSchema,
   // Perp trading configuration (Hyperliquid)
   perp: PerpConfigSchema,
+  // Prediction market configuration (Polymarket)
+  prediction: PredictionConfigSchema,
   // Allowed tokens (addresses)
   allowedTokens: import_zod.z.array(import_zod.z.string()).optional()
 });
@@ -3144,6 +3202,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;
@@ -4384,91 +5045,1955 @@ var CORE_DEPOSIT_WALLET_ABI = (0, import_viem6.parseAbi)([
   "function deposit(uint256 amount, uint32 destinationDex) external"
 ]);
 
-// src/runtime.ts
-var FUNDS_LOW_THRESHOLD = 5e-3;
-var FUNDS_CRITICAL_THRESHOLD = 1e-3;
-var AgentRuntime = class {
+// src/prediction/types.ts
+var DEFAULT_PREDICTION_CONFIG = {
+  clobApiUrl: "https://clob.polymarket.com",
+  gammaApiUrl: "https://gamma-api.polymarket.com",
+  polygonRpcUrl: "https://polygon-rpc.com",
+  maxNotionalUSD: 1e3,
+  maxTotalExposureUSD: 5e3,
+  polygonAllocationUSD: 100,
+  feeBridgeThresholdUSD: 10
+};
+var POLYGON_CHAIN_ID = 137;
+var POLYMARKET_SIGNATURE_TYPE_EOA = 0;
+var POLYMARKET_SIGNATURE_TYPE_GNOSIS_SAFE = 1;
+var POLYGON_USDC_ADDRESS = "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359";
+var POLYGON_TOKEN_MESSENGER_V2 = "0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d";
+var POLYGON_MESSAGE_TRANSMITTER_V2 = "0x81D40F21F12A8F0E3252Bccb954D722d4c464B64";
+var CCTP_DOMAIN_BASE = 6;
+var CCTP_DOMAIN_POLYGON = 7;
+var PREDICTION_INSTRUMENT_PREFIX = "POLY:";
+
+// src/prediction/client.ts
+var import_clob_client = require("@polymarket/clob-client");
+var import_ethers = require("ethers");
+var PolymarketClient = class {
   config;
-  client;
-  llm;
-  strategy;
-  executor;
-  riskManager;
-  marketData;
-  vaultManager;
-  relay = null;
-  isRunning = false;
-  mode = "idle";
-  configHash;
-  pendingConfigHash = null;
-  lastConfigCheckAt = 0;
-  // Timestamp of last pending config RPC check
-  cycleCount = 0;
-  lastCycleAt = 0;
-  lastPortfolioValue = 0;
-  lastEthBalance = "0";
-  lastPrices = {};
-  processAlive = true;
-  riskUniverse = 0;
-  allowedTokens = /* @__PURE__ */ new Set();
-  strategyContext;
-  positionTracker;
-  // Perp trading components (null if perp not enabled)
-  perpClient = null;
-  perpSigner = null;
-  perpOrders = null;
-  perpPositions = null;
-  perpWebSocket = null;
-  perpRecorder = null;
-  perpOnboarding = null;
-  perpStrategy = null;
-  // Two-layer perp control:
-  //   perpConnected = Hyperliquid infrastructure is initialized (WS, signer, recorder ready)
-  //   perpTradingActive = Dedicated perp trading cycle is mandated to run
-  // When perpConnected && !perpTradingActive: agent's strategy can optionally return perp signals
-  // When perpConnected && perpTradingActive: dedicated runPerpCycle() runs every interval
-  perpConnected = false;
-  perpTradingActive = false;
-  // Cached perp account data for synchronous heartbeat inclusion (refreshed async)
-  cachedPerpEquity = 0;
-  cachedPerpUnrealizedPnl = 0;
-  cachedPerpMarginUsed = 0;
-  cachedPerpLeverage = 0;
-  cachedPerpOpenPositions = 0;
-  constructor(config) {
-    this.config = config;
+  clobClient = null;
+  apiCreds = null;
+  signer;
+  walletAddress;
+  /** Vault mode: when true, orders use maker=vaultAddress with POLY_GNOSIS_SAFE signature type */
+  vaultMode;
+  /** Vault contract address (only set in vault mode) */
+  vaultAddress;
+  /** Cache for Gamma API market data (conditionId -> market) */
+  marketCache = /* @__PURE__ */ new Map();
+  CACHE_TTL_MS = 6e4;
+  // 60 seconds
+  constructor(privateKey, config, vaultOpts) {
+    this.config = { ...DEFAULT_PREDICTION_CONFIG, ...config };
+    this.signer = new import_ethers.Wallet(privateKey);
+    this.walletAddress = this.signer.address;
+    this.vaultMode = vaultOpts?.vaultMode ?? false;
+    this.vaultAddress = vaultOpts?.vaultAddress;
   }
+  // ============================================================
+  // INITIALIZATION
+  // ============================================================
   /**
-   * Initialize the agent runtime
+   * Initialize the CLOB client with L2 API credentials.
+   * Must be called once before placing orders.
    */
   async initialize() {
-    console.log(`Initializing agent: ${this.config.name} (ID: ${this.config.agentId})`);
-    this.client = new import_sdk.ExagentClient({
-      privateKey: this.config.privateKey,
-      network: this.config.network
-    });
-    console.log(`Wallet: ${this.client.address}`);
-    const agent = await this.client.registry.getAgent(BigInt(this.config.agentId));
-    if (!agent) {
-      throw new Error(`Agent ID ${this.config.agentId} not found on-chain. Please register first.`);
+    const initClient = new import_clob_client.ClobClient(
+      this.config.clobApiUrl,
+      POLYGON_CHAIN_ID,
+      this.signer
+    );
+    this.apiCreds = await initClient.createOrDeriveApiKey();
+    const signatureType = this.vaultMode ? POLYMARKET_SIGNATURE_TYPE_GNOSIS_SAFE : POLYMARKET_SIGNATURE_TYPE_EOA;
+    this.clobClient = new import_clob_client.ClobClient(
+      this.config.clobApiUrl,
+      POLYGON_CHAIN_ID,
+      this.signer,
+      this.apiCreds,
+      signatureType
+    );
+    if (this.vaultMode) {
+      console.log(`Polymarket CLOB initialized in VAULT MODE \u2014 maker: ${this.vaultAddress}, signer: ${this.walletAddress}`);
+    } else {
+      console.log(`Polymarket CLOB initialized for ${this.walletAddress}`);
     }
-    console.log(`Agent verified: ${agent.name}`);
-    await this.ensureWalletLinked();
-    await this.loadTradingRestrictions();
-    console.log(`Initializing LLM: ${this.config.llm.provider}`);
-    this.llm = await createLLMAdapter(this.config.llm);
-    const llmMeta = this.llm.getMetadata();
-    console.log(`LLM ready: ${llmMeta.provider} (${llmMeta.model})`);
-    await this.syncConfigHash();
-    this.strategy = await loadStrategy();
-    const store = new FileStore();
-    this.strategyContext = {
-      store,
-      agentId: Number(this.config.agentId),
-      walletAddress: this.client.address
+  }
+  /**
+   * Check if the client is initialized with CLOB credentials.
+   */
+  get isInitialized() {
+    return this.clobClient !== null && this.apiCreds !== null;
+  }
+  // ============================================================
+  // CLOB API — ORDER BOOK & PRICES
+  // ============================================================
+  /**
+   * Get the order book for a specific outcome token.
+   */
+  async getOrderBook(tokenId) {
+    this.ensureInitialized();
+    const book = await this.clobClient.getOrderBook(tokenId);
+    return {
+      bids: (book.bids || []).map((b) => ({ price: parseFloat(b.price), size: parseFloat(b.size) })),
+      asks: (book.asks || []).map((a) => ({ price: parseFloat(a.price), size: parseFloat(a.size) }))
     };
-    this.positionTracker = new PositionTracker(store, { maxTradeHistory: 50 });
-    this.executor = new TradeExecutor(this.client, this.config, () => this.getConfigHash());
+  }
+  /**
+   * Get the midpoint price for an outcome token.
+   */
+  async getMidpointPrice(tokenId) {
+    const book = await this.getOrderBook(tokenId);
+    if (book.bids.length === 0 || book.asks.length === 0) return 0;
+    return (book.bids[0].price + book.asks[0].price) / 2;
+  }
+  /**
+   * Get the last trade price for an outcome token.
+   */
+  async getLastTradePrice(tokenId) {
+    this.ensureInitialized();
+    const resp = await this.clobClient.getLastTradePrice(tokenId);
+    return parseFloat(resp?.price || "0");
+  }
+  // ============================================================
+  // CLOB API — ORDERS
+  // ============================================================
+  /**
+   * Place a limit order on the CLOB.
+   */
+  async placeLimitOrder(params) {
+    this.ensureInitialized();
+    const order = await this.clobClient.createAndPostOrder({
+      tokenID: params.tokenId,
+      price: params.price,
+      side: params.side,
+      size: params.size
+    });
+    return {
+      orderId: order?.orderID || "",
+      success: !!order?.orderID
+    };
+  }
+  /**
+   * Place a market order (aggressive limit at best available price).
+   */
+  async placeMarketOrder(params) {
+    this.ensureInitialized();
+    const order = await this.clobClient.createMarketOrder({
+      tokenID: params.tokenId,
+      amount: params.amount,
+      side: params.side
+    });
+    const result = await this.clobClient.postOrder(order);
+    return {
+      orderId: result?.orderID || "",
+      success: !!result?.orderID
+    };
+  }
+  /**
+   * Cancel an open order by ID.
+   */
+  async cancelOrder(orderId) {
+    this.ensureInitialized();
+    try {
+      await this.clobClient.cancelOrder({ orderID: orderId });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Cancel all open orders.
+   */
+  async cancelAllOrders() {
+    this.ensureInitialized();
+    try {
+      await this.clobClient.cancelAll();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get open orders for the agent's wallet.
+   */
+  async getOpenOrders() {
+    this.ensureInitialized();
+    return this.clobClient.getOpenOrders();
+  }
+  /**
+   * Get trade history (fills) for the agent's wallet.
+   */
+  async getTradeHistory() {
+    this.ensureInitialized();
+    const trades = await this.clobClient.getTrades();
+    return (trades || []).map((t) => this.parseRawFill(t));
+  }
+  // ============================================================
+  // GAMMA API — MARKET DISCOVERY (public, no auth)
+  // ============================================================
+  /**
+   * Get active prediction markets from Gamma API.
+   */
+  async getMarkets(params) {
+    const query = new URLSearchParams();
+    if (params?.limit) query.set("limit", String(params.limit));
+    if (params?.offset) query.set("offset", String(params.offset));
+    if (params?.active !== void 0) query.set("active", String(params.active));
+    if (params?.category) query.set("tag", params.category);
+    const url = `${this.config.gammaApiUrl}/markets?${query.toString()}`;
+    const resp = await fetch(url);
+    if (!resp.ok) throw new Error(`Gamma API error: ${resp.status} ${await resp.text()}`);
+    const raw = await resp.json();
+    return (raw || []).map((m) => this.parseGammaMarket(m));
+  }
+  /**
+   * Get a single market by condition ID.
+   */
+  async getMarketByConditionId(conditionId) {
+    const cached = this.marketCache.get(conditionId);
+    if (cached && Date.now() - cached.cachedAt < this.CACHE_TTL_MS) {
+      return cached.market;
+    }
+    const url = `${this.config.gammaApiUrl}/markets?condition_id=${conditionId}`;
+    const resp = await fetch(url);
+    if (!resp.ok) return null;
+    const raw = await resp.json();
+    if (!raw || raw.length === 0) return null;
+    const market = this.parseGammaMarket(raw[0]);
+    this.marketCache.set(conditionId, { market, cachedAt: Date.now() });
+    return market;
+  }
+  /**
+   * Search markets by query string.
+   */
+  async searchMarkets(query, limit = 20) {
+    const url = `${this.config.gammaApiUrl}/markets?_q=${encodeURIComponent(query)}&limit=${limit}&active=true`;
+    const resp = await fetch(url);
+    if (!resp.ok) return [];
+    const raw = await resp.json();
+    return (raw || []).map((m) => this.parseGammaMarket(m));
+  }
+  /**
+   * Get trending markets sorted by volume.
+   */
+  async getTrendingMarkets(limit = 10) {
+    const url = `${this.config.gammaApiUrl}/markets?active=true&limit=${limit}&order=volume24hr&ascending=false`;
+    const resp = await fetch(url);
+    if (!resp.ok) return [];
+    const raw = await resp.json();
+    return (raw || []).map((m) => this.parseGammaMarket(m));
+  }
+  // ============================================================
+  // WALLET ADDRESS
+  // ============================================================
+  getWalletAddress() {
+    return this.walletAddress;
+  }
+  /**
+   * Get the effective maker address for CLOB orders.
+   * In vault mode, this is the vault contract address.
+   * In normal mode, this is the agent's EOA address.
+   */
+  getMakerAddress() {
+    return this.vaultMode && this.vaultAddress ? this.vaultAddress : this.walletAddress;
+  }
+  /**
+   * Whether the client is operating in vault mode.
+   */
+  get isVaultMode() {
+    return this.vaultMode;
+  }
+  /**
+   * Get the vault address (null if not in vault mode).
+   */
+  getVaultAddress() {
+    return this.vaultAddress;
+  }
+  // ============================================================
+  // PRIVATE HELPERS
+  // ============================================================
+  ensureInitialized() {
+    if (!this.clobClient) {
+      throw new Error("PolymarketClient not initialized. Call initialize() first.");
+    }
+  }
+  parseGammaMarket(raw) {
+    const outcomes = raw.outcomes ? JSON.parse(raw.outcomes) : ["Yes", "No"];
+    const outcomePrices = raw.outcomePrices ? JSON.parse(raw.outcomePrices) : [0, 0];
+    const outcomeTokenIds = raw.clobTokenIds ? JSON.parse(raw.clobTokenIds) : [];
+    return {
+      conditionId: raw.conditionId || raw.condition_id || "",
+      question: raw.question || "",
+      description: raw.description || "",
+      category: raw.groupItemTitle || raw.category || "Other",
+      outcomes,
+      outcomeTokenIds,
+      outcomePrices: outcomePrices.map((p) => parseFloat(p) || 0),
+      volume24h: parseFloat(raw.volume24hr || raw.volume24h || "0"),
+      liquidity: parseFloat(raw.liquidity || "0"),
+      endDate: raw.endDate ? new Date(raw.endDate).getTime() / 1e3 : 0,
+      active: raw.active !== false && raw.closed !== true,
+      resolved: raw.resolved === true,
+      winningOutcome: raw.winningOutcome,
+      resolutionSource: raw.resolutionSource || void 0,
+      uniqueTraders: raw.uniqueTraders || void 0
+    };
+  }
+  parseRawFill(raw) {
+    const tokenId = raw.asset_id || void 0;
+    const marketConditionId = raw.market || raw.asset_id || "";
+    return {
+      orderId: raw.orderId || raw.order_id || "",
+      tradeId: raw.id || raw.tradeId || "",
+      marketConditionId,
+      outcomeIndex: raw.outcome_index ?? (raw.side === "BUY" ? 0 : 1),
+      side: raw.side === "BUY" || raw.side === "buy" ? "BUY" : "SELL",
+      price: String(raw.price || "0"),
+      size: String(raw.size || "0"),
+      fee: String(raw.fee || "0"),
+      timestamp: raw.timestamp || raw.created_at ? new Date(raw.created_at).getTime() : Date.now(),
+      isMaker: raw.maker_order || raw.is_maker || false,
+      tokenId
+    };
+  }
+};
+
+// src/prediction/signer.ts
+var import_viem7 = require("viem");
+function tradeIdToBytes32(tradeId) {
+  if (tradeId.startsWith("0x") && tradeId.length === 66) {
+    return tradeId;
+  }
+  return (0, import_viem7.keccak256)((0, import_viem7.encodePacked)(["string"], [tradeId]));
+}
+function orderIdToBytes32(orderId) {
+  return (0, import_viem7.keccak256)((0, import_viem7.encodePacked)(["string"], [`poly-order:${orderId}`]));
+}
+function encodePredictionInstrument(conditionId, outcomeIndex) {
+  return `${PREDICTION_INSTRUMENT_PREFIX}${conditionId}:${outcomeIndex}`;
+}
+function decodePredictionInstrument(instrument) {
+  if (!instrument.startsWith(PREDICTION_INSTRUMENT_PREFIX)) return null;
+  const payload = instrument.slice(PREDICTION_INSTRUMENT_PREFIX.length);
+  const lastColon = payload.lastIndexOf(":");
+  if (lastColon === -1) return null;
+  const conditionId = payload.slice(0, lastColon);
+  const outcomeIndex = parseInt(payload.slice(lastColon + 1), 10);
+  if (isNaN(outcomeIndex)) return null;
+  return { conditionId, outcomeIndex };
+}
+function calculatePredictionFee(notionalUSD) {
+  return notionalUSD * 20n / 10000n;
+}
+
+// src/prediction/order-manager.ts
+var PredictionOrderManager = class {
+  client;
+  config;
+  /** Recent fills tracked for recording */
+  recentFills = [];
+  MAX_RECENT_FILLS = 100;
+  constructor(client, config) {
+    this.client = client;
+    this.config = config;
+  }
+  // ============================================================
+  // ORDER PLACEMENT
+  // ============================================================
+  /**
+   * Execute a prediction trade signal.
+   * Routes to limit or market order based on signal.orderType.
+   */
+  async executeSignal(signal) {
+    try {
+      const violation = this.checkRiskLimits(signal);
+      if (violation) {
+        return { success: false, status: "error", error: violation };
+      }
+      const market = await this.client.getMarketByConditionId(signal.marketConditionId);
+      if (!market) {
+        return { success: false, status: "error", error: `Market not found: ${signal.marketConditionId}` };
+      }
+      if (!market.active) {
+        return { success: false, status: "error", error: `Market is closed: ${signal.marketQuestion}` };
+      }
+      const tokenId = market.outcomeTokenIds[signal.outcomeIndex];
+      if (!tokenId) {
+        return { success: false, status: "error", error: `Invalid outcome index ${signal.outcomeIndex} for market` };
+      }
+      const isBuy = signal.action === "buy_yes" || signal.action === "buy_no";
+      const side = isBuy ? "BUY" : "SELL";
+      let result;
+      if (signal.orderType === "market") {
+        result = await this.client.placeMarketOrder({
+          tokenId,
+          amount: signal.amount,
+          side
+        });
+      } else {
+        result = await this.client.placeLimitOrder({
+          tokenId,
+          price: signal.limitPrice,
+          size: signal.amount,
+          side
+        });
+      }
+      if (result.success) {
+        console.log(
+          `Prediction order placed: ${signal.action} ${signal.amount} @ $${signal.limitPrice} \u2014 "${signal.marketQuestion}" \u2014 order: ${result.orderId}`
+        );
+        return {
+          success: true,
+          orderId: result.orderId,
+          status: signal.orderType === "market" ? "filled" : "resting"
+        };
+      }
+      return { success: false, status: "error", error: "Order placement failed" };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`Prediction order failed for "${signal.marketQuestion}":`, message);
+      return { success: false, status: "error", error: message };
+    }
+  }
+  /**
+   * Cancel an open order by ID.
+   */
+  async cancelOrder(orderId) {
+    return this.client.cancelOrder(orderId);
+  }
+  /**
+   * Cancel all open orders.
+   */
+  async cancelAllOrders() {
+    return this.client.cancelAllOrders();
+  }
+  // ============================================================
+  // FILL TRACKING
+  // ============================================================
+  /**
+   * Poll for new fills since last check.
+   * Returns fills that haven't been seen before.
+   */
+  async pollNewFills() {
+    try {
+      const allFills = await this.client.getTradeHistory();
+      const seenIds = new Set(this.recentFills.map((f) => f.tradeId));
+      const newFills = allFills.filter((f) => !seenIds.has(f.tradeId));
+      for (const fill of newFills) {
+        this.recentFills.push(fill);
+        if (this.recentFills.length > this.MAX_RECENT_FILLS) {
+          this.recentFills.shift();
+        }
+      }
+      return newFills;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error("Failed to poll prediction fills:", message);
+      return [];
+    }
+  }
+  /**
+   * Get recent fills (from local cache).
+   */
+  getRecentFills() {
+    return [...this.recentFills];
+  }
+  // ============================================================
+  // RISK CHECKS
+  // ============================================================
+  /**
+   * Check if a signal violates risk limits.
+   * Returns error string if violated, null if OK.
+   */
+  checkRiskLimits(signal) {
+    if (signal.amount > this.config.maxNotionalUSD) {
+      return `Trade amount $${signal.amount} exceeds max notional $${this.config.maxNotionalUSD}`;
+    }
+    if (signal.limitPrice <= 0 || signal.limitPrice >= 1) {
+      return `Limit price ${signal.limitPrice} out of bounds (must be 0.01-0.99)`;
+    }
+    if (signal.confidence < 0.3) {
+      return `Confidence ${signal.confidence} below minimum threshold (0.3)`;
+    }
+    if (this.config.allowedCategories && this.config.allowedCategories.length > 0) {
+    }
+    return null;
+  }
+};
+
+// src/prediction/position-manager.ts
+var PredictionPositionManager = class {
+  client;
+  config;
+  /** Local position tracking (conditionId:outcomeIndex -> position data) */
+  positions = /* @__PURE__ */ new Map();
+  /** Cache TTL */
+  lastPriceRefresh = 0;
+  PRICE_REFRESH_MS = 1e4;
+  // 10 seconds
+  constructor(client, config) {
+    this.client = client;
+    this.config = config;
+  }
+  // ============================================================
+  // POSITION QUERIES
+  // ============================================================
+  /**
+   * Get all open prediction positions with current prices.
+   */
+  async getPositions(forceRefresh = false) {
+    if (forceRefresh || Date.now() - this.lastPriceRefresh > this.PRICE_REFRESH_MS) {
+      await this.refreshPrices();
+    }
+    return Array.from(this.positions.values()).filter((p) => p.balance > 0).map((p) => this.toExternalPosition(p));
+  }
+  /**
+   * Get a specific position.
+   */
+  async getPosition(conditionId, outcomeIndex) {
+    const key = `${conditionId}:${outcomeIndex}`;
+    const pos = this.positions.get(key);
+    if (!pos || pos.balance <= 0) return null;
+    return this.toExternalPosition(pos);
+  }
+  /**
+   * Get account summary (balances, exposure, PnL).
+   */
+  async getAccountSummary() {
+    const positions = await this.getPositions();
+    const totalExposure = positions.reduce((sum, p) => sum + p.costBasis, 0);
+    const totalUnrealizedPnl = positions.reduce((sum, p) => sum + p.unrealizedPnl, 0);
+    const openMarkets = new Set(positions.map((p) => p.marketConditionId));
+    return {
+      polygonUSDC: 0,
+      // Filled in by runtime from on-chain balance
+      baseUSDC: 0,
+      // Filled in by runtime from on-chain balance
+      totalExposure,
+      totalUnrealizedPnl,
+      openMarketCount: openMarkets.size,
+      openPositionCount: positions.length,
+      pendingFees: 0
+      // Filled in by recorder
+    };
+  }
+  /**
+   * Get total exposure across all positions.
+   */
+  getTotalExposure() {
+    let total = 0;
+    for (const pos of this.positions.values()) {
+      if (pos.balance > 0) total += pos.totalCostBasis;
+    }
+    return total;
+  }
+  /**
+   * Get total unrealized PnL.
+   */
+  getTotalUnrealizedPnl() {
+    let total = 0;
+    for (const pos of this.positions.values()) {
+      if (pos.balance > 0) {
+        total += (pos.currentPrice - pos.averageEntryPrice) * pos.balance;
+      }
+    }
+    return total;
+  }
+  // ============================================================
+  // FILL PROCESSING
+  // ============================================================
+  /**
+   * Process a fill and update position tracking.
+   * Called when a new fill is detected by the order manager.
+   */
+  processFill(fill) {
+    const key = `${fill.marketConditionId}:${fill.outcomeIndex}`;
+    let pos = this.positions.get(key);
+    const price = parseFloat(fill.price);
+    const size = parseFloat(fill.size);
+    if (!pos) {
+      pos = {
+        marketConditionId: fill.marketConditionId,
+        outcomeIndex: fill.outcomeIndex,
+        marketQuestion: fill.marketQuestion || "",
+        tokenId: fill.tokenId || "",
+        balance: 0,
+        totalBought: 0,
+        totalSold: 0,
+        totalCostBasis: 0,
+        totalProceeds: 0,
+        averageEntryPrice: 0,
+        currentPrice: price,
+        category: void 0,
+        endDate: void 0
+      };
+      this.positions.set(key, pos);
+    } else if (!pos.tokenId && fill.tokenId) {
+      pos.tokenId = fill.tokenId;
+    }
+    if (fill.side === "BUY") {
+      const oldCost = pos.averageEntryPrice * pos.balance;
+      const newCost = price * size;
+      pos.balance += size;
+      pos.totalBought += size;
+      pos.totalCostBasis += newCost;
+      pos.averageEntryPrice = pos.balance > 0 ? (oldCost + newCost) / pos.balance : 0;
+    } else {
+      pos.balance -= size;
+      pos.totalSold += size;
+      pos.totalProceeds += price * size;
+      if (pos.balance < 0) pos.balance = 0;
+    }
+  }
+  /**
+   * Process multiple fills (batch update).
+   */
+  processFills(fills) {
+    for (const fill of fills) {
+      this.processFill(fill);
+    }
+  }
+  // ============================================================
+  // MARKET RESOLUTION
+  // ============================================================
+  /**
+   * Mark a market as resolved. Positions settle at $0 or $1.
+   */
+  resolveMarket(conditionId, winningOutcome) {
+    for (const [key, pos] of this.positions.entries()) {
+      if (pos.marketConditionId === conditionId) {
+        const isWinner = pos.outcomeIndex === winningOutcome;
+        pos.currentPrice = isWinner ? 1 : 0;
+        if (pos.balance > 0) {
+          pos.totalProceeds += pos.currentPrice * pos.balance;
+          pos.totalSold += pos.balance;
+          pos.balance = 0;
+        }
+      }
+    }
+  }
+  // ============================================================
+  // PERSISTENCE
+  // ============================================================
+  /**
+   * Export position state for persistence across restarts.
+   */
+  exportState() {
+    return Array.from(this.positions.values());
+  }
+  /**
+   * Import position state from previous session.
+   */
+  importState(state) {
+    this.positions.clear();
+    for (const pos of state) {
+      const key = `${pos.marketConditionId}:${pos.outcomeIndex}`;
+      this.positions.set(key, pos);
+    }
+  }
+  // ============================================================
+  // PRIVATE
+  // ============================================================
+  /**
+   * Refresh current prices for all open positions from CLOB.
+   */
+  async refreshPrices() {
+    const openPositions = Array.from(this.positions.values()).filter((p) => p.balance > 0);
+    await Promise.all(
+      openPositions.map(async (pos) => {
+        try {
+          if (!pos.tokenId) {
+            const market = await this.client.getMarketByConditionId(pos.marketConditionId);
+            if (market && market.outcomeTokenIds[pos.outcomeIndex]) {
+              pos.tokenId = market.outcomeTokenIds[pos.outcomeIndex];
+            }
+          }
+          if (pos.tokenId) {
+            const price = await this.client.getMidpointPrice(pos.tokenId);
+            if (price > 0) pos.currentPrice = price;
+          }
+        } catch {
+        }
+      })
+    );
+    this.lastPriceRefresh = Date.now();
+  }
+  toExternalPosition(pos) {
+    const unrealizedPnl = pos.balance > 0 ? (pos.currentPrice - pos.averageEntryPrice) * pos.balance : 0;
+    return {
+      marketConditionId: pos.marketConditionId,
+      marketQuestion: pos.marketQuestion,
+      outcomeIndex: pos.outcomeIndex,
+      outcomeLabel: pos.outcomeIndex === 0 ? "Yes" : "No",
+      tokenId: pos.tokenId,
+      balance: pos.balance,
+      averageEntryPrice: pos.averageEntryPrice,
+      currentPrice: pos.currentPrice,
+      unrealizedPnl,
+      costBasis: pos.totalCostBasis - pos.totalProceeds,
+      endDate: pos.endDate,
+      category: pos.category
+    };
+  }
+};
+
+// src/prediction/recorder.ts
+var import_viem8 = require("viem");
+var import_chains5 = require("viem/chains");
+var import_accounts5 = require("viem/accounts");
+var ROUTER_ADDRESS2 = "0x1BCFa13f677fDCf697D8b7d5120f544817F1de1A";
+var ROUTER_ABI2 = [
+  {
+    type: "function",
+    name: "recordPerpTrade",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "configHash", type: "bytes32" },
+      { name: "instrument", type: "string" },
+      { name: "isLong", type: "bool" },
+      { name: "notionalUSD", type: "uint256" },
+      { name: "feeUSD", type: "uint256" },
+      { name: "fillId", type: "bytes32" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  }
+];
+var MAX_RETRIES2 = 3;
+var RETRY_DELAY_MS2 = 5e3;
+var PredictionTradeRecorder = class {
+  publicClient;
+  walletClient;
+  account;
+  agentId;
+  configHash;
+  /** Retry queue for failed recordings */
+  retryQueue = [];
+  /** Set of fill IDs already recorded (or in-progress) to prevent local dups */
+  recordedFills = /* @__PURE__ */ new Set();
+  /** Timer for processing retry queue */
+  retryTimer = null;
+  /** Accumulated fees pending bridge to Base treasury (in USD, 6-decimal) */
+  accumulatedFees = 0n;
+  constructor(opts) {
+    this.agentId = opts.agentId;
+    this.configHash = opts.configHash;
+    this.account = (0, import_accounts5.privateKeyToAccount)(opts.privateKey);
+    const rpcUrl = opts.rpcUrl || "https://mainnet.base.org";
+    const transport = (0, import_viem8.http)(rpcUrl, { timeout: 6e4 });
+    this.publicClient = (0, import_viem8.createPublicClient)({
+      chain: import_chains5.base,
+      transport
+    });
+    this.walletClient = (0, import_viem8.createWalletClient)({
+      chain: import_chains5.base,
+      transport,
+      account: this.account
+    });
+    this.retryTimer = setInterval(() => this.processRetryQueue(), RETRY_DELAY_MS2);
+  }
+  // ============================================================
+  // PUBLIC API
+  // ============================================================
+  /**
+   * Record a prediction fill on-chain.
+   * Converts the Polymarket fill into recordPerpTrade params with POLY: prefix.
+   */
+  async recordFill(fill) {
+    const fillId = tradeIdToBytes32(fill.tradeId);
+    const fillIdStr = fillId.toLowerCase();
+    if (this.recordedFills.has(fillIdStr)) {
+      return { success: true };
+    }
+    this.recordedFills.add(fillIdStr);
+    const notionalUSD = this.calculateNotionalUSD(fill);
+    const feeUSD = calculatePredictionFee(notionalUSD);
+    const params = {
+      agentId: this.agentId,
+      configHash: this.configHash,
+      instrument: encodePredictionInstrument(fill.marketConditionId, fill.outcomeIndex),
+      isLong: fill.side === "BUY",
+      notionalUSD,
+      feeUSD,
+      fillId
+    };
+    this.accumulatedFees += feeUSD;
+    return this.submitRecord(params);
+  }
+  /**
+   * Update the config hash (when epoch changes).
+   */
+  updateConfigHash(configHash) {
+    this.configHash = configHash;
+  }
+  /**
+   * Get the number of fills pending retry.
+   */
+  get pendingRetries() {
+    return this.retryQueue.length;
+  }
+  /**
+   * Get the number of fills recorded (local dedup set size).
+   */
+  get recordedCount() {
+    return this.recordedFills.size;
+  }
+  /**
+   * Get accumulated fees pending bridge (6-decimal USD).
+   */
+  get pendingFees() {
+    return this.accumulatedFees;
+  }
+  /**
+   * Get accumulated fees as human-readable USD.
+   */
+  get pendingFeesUSD() {
+    return Number(this.accumulatedFees) / 1e6;
+  }
+  /**
+   * Reset accumulated fees (after bridge to treasury).
+   */
+  resetAccumulatedFees() {
+    this.accumulatedFees = 0n;
+  }
+  /**
+   * Stop the recorder (clear retry timer).
+   */
+  stop() {
+    if (this.retryTimer) {
+      clearInterval(this.retryTimer);
+      this.retryTimer = null;
+    }
+  }
+  // ============================================================
+  // PRIVATE
+  // ============================================================
+  /**
+   * Submit a recordPerpTrade transaction on Base.
+   */
+  async submitRecord(params) {
+    try {
+      const { request } = await this.publicClient.simulateContract({
+        address: ROUTER_ADDRESS2,
+        abi: ROUTER_ABI2,
+        functionName: "recordPerpTrade",
+        args: [
+          params.agentId,
+          params.configHash,
+          params.instrument,
+          params.isLong,
+          params.notionalUSD,
+          params.feeUSD,
+          params.fillId
+        ],
+        account: this.account
+      });
+      const txHash = await this.walletClient.writeContract(request);
+      const action = params.isLong ? "BUY" : "SELL";
+      console.log(
+        `Prediction trade recorded: ${action} ${params.instrument} $${Number(params.notionalUSD) / 1e6} \u2014 tx: ${txHash}`
+      );
+      return { success: true, txHash };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("FillAlreadyProcessed") || message.includes("already recorded")) {
+        console.log(`Prediction fill already recorded on-chain: ${params.fillId}`);
+        return { success: true };
+      }
+      console.error(`Failed to record prediction trade: ${message}`);
+      this.retryQueue.push({
+        params,
+        retries: 0,
+        lastAttempt: Date.now()
+      });
+      return { success: false, error: message };
+    }
+  }
+  /**
+   * Process the retry queue — attempt to re-submit failed recordings.
+   */
+  async processRetryQueue() {
+    if (this.retryQueue.length === 0) return;
+    const now = Date.now();
+    const toRetry = this.retryQueue.filter(
+      (item) => now - item.lastAttempt >= RETRY_DELAY_MS2
+    );
+    for (const item of toRetry) {
+      item.retries++;
+      item.lastAttempt = now;
+      if (item.retries > MAX_RETRIES2) {
+        console.error(
+          `Prediction trade recording permanently failed after ${MAX_RETRIES2} retries: ${item.params.instrument} ${item.params.fillId}`
+        );
+        const idx = this.retryQueue.indexOf(item);
+        if (idx >= 0) this.retryQueue.splice(idx, 1);
+        continue;
+      }
+      console.log(
+        `Retrying prediction trade recording (attempt ${item.retries}/${MAX_RETRIES2}): ${item.params.instrument}`
+      );
+      const result = await this.submitRecord(item.params);
+      if (result.success) {
+        const idx = this.retryQueue.indexOf(item);
+        if (idx >= 0) this.retryQueue.splice(idx, 1);
+      }
+    }
+  }
+  // ============================================================
+  // CONVERSION HELPERS
+  // ============================================================
+  /**
+   * Calculate notional USD from a fill (6-decimal).
+   * notionalUSD = price * size * 1e6
+   */
+  calculateNotionalUSD(fill) {
+    const price = parseFloat(fill.price);
+    const size = parseFloat(fill.size);
+    return BigInt(Math.round(price * size * 1e6));
+  }
+};
+
+// src/prediction/market-browser.ts
+var MARKET_CATEGORIES = [
+  "crypto",
+  "politics",
+  "sports",
+  "entertainment",
+  "science",
+  "business",
+  "culture",
+  "weather",
+  "tech"
+];
+var MarketBrowser = class {
+  gammaUrl;
+  allowedCategories;
+  /** Cache for market listings */
+  listCache = /* @__PURE__ */ new Map();
+  CACHE_TTL_MS = 6e4;
+  constructor(config) {
+    const merged = { ...DEFAULT_PREDICTION_CONFIG, ...config };
+    this.gammaUrl = merged.gammaApiUrl;
+    this.allowedCategories = merged.allowedCategories || [];
+  }
+  // ============================================================
+  // PUBLIC API
+  // ============================================================
+  /**
+   * Get active markets, optionally filtered by category.
+   * Results are sorted by volume (highest first).
+   */
+  async getActiveMarkets(params) {
+    const limit = params?.limit || 20;
+    const offset = params?.offset || 0;
+    const cacheKey = `active:${params?.category || "all"}:${limit}:${offset}`;
+    const cached = this.listCache.get(cacheKey);
+    if (cached && Date.now() - cached.cachedAt < this.CACHE_TTL_MS) {
+      return cached.data;
+    }
+    const query = new URLSearchParams({
+      active: "true",
+      closed: "false",
+      limit: String(limit),
+      offset: String(offset),
+      order: "volume24hr",
+      ascending: "false"
+    });
+    if (params?.category) query.set("tag", params.category);
+    const markets = await this.fetchGamma(`/markets?${query.toString()}`);
+    const parsed = markets.map((m) => this.parseMarket(m));
+    const filtered = this.allowedCategories.length > 0 ? parsed.filter(
+      (m) => this.allowedCategories.some((c) => m.category.toLowerCase().includes(c.toLowerCase()))
+    ) : parsed;
+    this.listCache.set(cacheKey, { data: filtered, cachedAt: Date.now() });
+    return filtered;
+  }
+  /**
+   * Search markets by query text.
+   */
+  async searchMarkets(query, limit = 20) {
+    const params = new URLSearchParams({
+      _q: query,
+      limit: String(limit),
+      active: "true"
+    });
+    const markets = await this.fetchGamma(`/markets?${params.toString()}`);
+    return markets.map((m) => this.parseMarket(m));
+  }
+  /**
+   * Get trending markets (highest 24h volume).
+   */
+  async getTrendingMarkets(limit = 10) {
+    return this.getActiveMarkets({ limit });
+  }
+  /**
+   * Get markets expiring soon (within N days).
+   */
+  async getExpiringMarkets(withinDays = 7, limit = 20) {
+    const markets = await this.getActiveMarkets({ limit: 100 });
+    const cutoff = Date.now() / 1e3 + withinDays * 86400;
+    return markets.filter((m) => m.endDate > 0 && m.endDate < cutoff).sort((a, b) => a.endDate - b.endDate).slice(0, limit);
+  }
+  /**
+   * Get recently resolved markets (for PnL tracking).
+   */
+  async getRecentlyResolved(limit = 20) {
+    const params = new URLSearchParams({
+      closed: "true",
+      limit: String(limit),
+      order: "endDate",
+      ascending: "false"
+    });
+    const markets = await this.fetchGamma(`/markets?${params.toString()}`);
+    return markets.map((m) => this.parseMarket(m)).filter((m) => m.resolved);
+  }
+  /**
+   * Get a single market's details by condition ID.
+   */
+  async getMarketDetail(conditionId) {
+    const markets = await this.fetchGamma(`/markets?condition_id=${conditionId}`);
+    if (!markets || markets.length === 0) return null;
+    return this.parseMarket(markets[0]);
+  }
+  /**
+   * Build a concise market summary string for LLM context.
+   * Keeps the prompt token count manageable.
+   */
+  formatMarketsForLLM(markets, maxMarkets = 15) {
+    const subset = markets.slice(0, maxMarkets);
+    const lines = subset.map((m, i) => {
+      const prices = m.outcomePrices.map((p, j) => `${m.outcomes[j]}: ${(p * 100).toFixed(1)}%`).join(", ");
+      const vol = m.volume24h >= 1e3 ? `$${(m.volume24h / 1e3).toFixed(1)}K` : `$${m.volume24h.toFixed(0)}`;
+      const endStr = m.endDate > 0 ? new Date(m.endDate * 1e3).toISOString().split("T")[0] : "TBD";
+      return `${i + 1}. [${m.category}] "${m.question}" \u2014 ${prices} | Vol: ${vol} | Ends: ${endStr} | ID: ${m.conditionId}`;
+    });
+    return lines.join("\n");
+  }
+  // ============================================================
+  // PRIVATE
+  // ============================================================
+  async fetchGamma(path4) {
+    const url = `${this.gammaUrl}${path4}`;
+    const resp = await fetch(url);
+    if (!resp.ok) {
+      console.error(`Gamma API error: ${resp.status} for ${url}`);
+      return [];
+    }
+    const data = await resp.json();
+    return Array.isArray(data) ? data : [];
+  }
+  parseMarket(raw) {
+    const outcomes = raw.outcomes ? JSON.parse(raw.outcomes) : ["Yes", "No"];
+    const outcomePrices = raw.outcomePrices ? JSON.parse(raw.outcomePrices) : [0, 0];
+    const outcomeTokenIds = raw.clobTokenIds ? JSON.parse(raw.clobTokenIds) : [];
+    return {
+      conditionId: raw.conditionId || raw.condition_id || "",
+      question: raw.question || "",
+      description: raw.description || "",
+      category: raw.groupItemTitle || raw.category || "Other",
+      outcomes,
+      outcomeTokenIds,
+      outcomePrices: outcomePrices.map((p) => parseFloat(p) || 0),
+      volume24h: parseFloat(raw.volume24hr || raw.volume24h || "0"),
+      liquidity: parseFloat(raw.liquidity || "0"),
+      endDate: raw.endDate ? new Date(raw.endDate).getTime() / 1e3 : 0,
+      active: raw.active !== false && raw.closed !== true,
+      resolved: raw.resolved === true,
+      winningOutcome: raw.winningOutcome,
+      resolutionSource: raw.resolutionSource || void 0,
+      uniqueTraders: raw.uniqueTraders || void 0
+    };
+  }
+};
+
+// src/prediction/funding.ts
+var import_viem9 = require("viem");
+var import_chains6 = require("viem/chains");
+var import_accounts6 = require("viem/accounts");
+var CONTRACTS = {
+  // Base
+  BASE_USDC: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+  BASE_TOKEN_MESSENGER_V2: "0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d",
+  BASE_MESSAGE_TRANSMITTER_V2: "0x81D40F21F12A8F0E3252Bccb954D722d4c464B64",
+  // Polygon
+  POLYGON_USDC: POLYGON_USDC_ADDRESS,
+  POLYGON_TOKEN_MESSENGER_V2,
+  POLYGON_MESSAGE_TRANSMITTER_V2
+};
+var IRIS_API_URL = "https://iris-api.circle.com/v1/attestations";
+var MIN_BRIDGE_AMOUNT = 1000000n;
+var ERC20_ABI2 = (0, import_viem9.parseAbi)([
+  "function approve(address spender, uint256 amount) external returns (bool)",
+  "function balanceOf(address account) external view returns (uint256)",
+  "function allowance(address owner, address spender) external view returns (uint256)"
+]);
+var TOKEN_MESSENGER_V2_ABI2 = (0, import_viem9.parseAbi)([
+  "function depositForBurn(uint256 amount, uint32 destinationDomain, bytes32 mintRecipient, address burnToken) external returns (uint64 nonce)",
+  "event DepositForBurn(uint64 indexed nonce, address indexed burnToken, uint256 amount, address indexed depositor, bytes32 mintRecipient, uint32 destinationDomain, bytes32 destinationTokenMessenger, bytes32 destinationCaller)"
+]);
+var MESSAGE_TRANSMITTER_V2_ABI2 = (0, import_viem9.parseAbi)([
+  "function receiveMessage(bytes message, bytes attestation) external returns (bool success)",
+  "event MessageSent(bytes message)"
+]);
+var PredictionFunding = class {
+  basePublic;
+  baseWallet;
+  polygonPublic;
+  polygonWallet;
+  account;
+  /** Override recipient for deposits to Polygon (vault address in vault mode) */
+  polygonRecipient;
+  constructor(config) {
+    this.account = (0, import_accounts6.privateKeyToAccount)(config.privateKey);
+    this.polygonRecipient = config.polygonRecipient;
+    const baseTransport = (0, import_viem9.http)(config.baseRpcUrl || "https://mainnet.base.org", { timeout: 6e4 });
+    const polygonTransport = (0, import_viem9.http)(config.polygonRpcUrl || "https://polygon-rpc.com", { timeout: 6e4 });
+    this.basePublic = (0, import_viem9.createPublicClient)({ chain: import_chains6.base, transport: baseTransport });
+    this.baseWallet = (0, import_viem9.createWalletClient)({ chain: import_chains6.base, transport: baseTransport, account: this.account });
+    this.polygonPublic = (0, import_viem9.createPublicClient)({ chain: import_chains6.polygon, transport: polygonTransport });
+    this.polygonWallet = (0, import_viem9.createWalletClient)({ chain: import_chains6.polygon, transport: polygonTransport, account: this.account });
+  }
+  // ============================================================
+  // BALANCE QUERIES
+  // ============================================================
+  /** Get USDC balance on Base (6-decimal) */
+  async getBaseUSDCBalance() {
+    return this.basePublic.readContract({
+      address: CONTRACTS.BASE_USDC,
+      abi: ERC20_ABI2,
+      functionName: "balanceOf",
+      args: [this.account.address]
+    });
+  }
+  /** Get USDC balance on Polygon (6-decimal) */
+  async getPolygonUSDCBalance() {
+    return this.polygonPublic.readContract({
+      address: CONTRACTS.POLYGON_USDC,
+      abi: ERC20_ABI2,
+      functionName: "balanceOf",
+      args: [this.account.address]
+    });
+  }
+  /** Get MATIC balance on Polygon for gas (wei) */
+  async getPolygonGasBalance() {
+    return this.polygonPublic.getBalance({ address: this.account.address });
+  }
+  // ============================================================
+  // DEPOSIT: Base → Polygon
+  // ============================================================
+  /**
+   * Bridge USDC from Base to Polygon via CCTP V2.
+   *
+   * Steps:
+   * 1. Approve USDC on Base for TokenMessengerV2
+   * 2. Call depositForBurn (Base → Polygon)
+   * 3. Wait for Circle attestation (~1-5 minutes)
+   * 4. Call receiveMessage on Polygon
+   */
+  async depositToPolygon(amount, onStep) {
+    const startTime = Date.now();
+    if (amount < MIN_BRIDGE_AMOUNT) {
+      return { success: false, amount, error: "Amount below minimum (1 USDC)" };
+    }
+    try {
+      onStep?.("approve_usdc");
+      await this.approveIfNeeded(
+        this.basePublic,
+        this.baseWallet,
+        CONTRACTS.BASE_USDC,
+        CONTRACTS.BASE_TOKEN_MESSENGER_V2,
+        amount
+      );
+      onStep?.("cctp_burn");
+      const recipient = this.polygonRecipient ?? this.account.address;
+      const mintRecipient = this.addressToBytes32(recipient);
+      const burnHash = await this.baseWallet.writeContract({
+        address: CONTRACTS.BASE_TOKEN_MESSENGER_V2,
+        abi: TOKEN_MESSENGER_V2_ABI2,
+        functionName: "depositForBurn",
+        args: [amount, CCTP_DOMAIN_POLYGON, mintRecipient, CONTRACTS.BASE_USDC]
+      });
+      const burnReceipt = await this.basePublic.waitForTransactionReceipt({ hash: burnHash });
+      const messageBytes = this.extractMessageFromReceipt(burnReceipt);
+      if (!messageBytes) {
+        return { success: false, amount, burnTxHash: burnHash, error: "Failed to extract CCTP message from burn tx" };
+      }
+      onStep?.("wait_attestation");
+      const attestation = await this.waitForAttestation(messageBytes);
+      if (!attestation) {
+        return { success: false, amount, burnTxHash: burnHash, error: "Attestation timeout (15 min)" };
+      }
+      onStep?.("cctp_receive");
+      const receiveHash = await this.polygonWallet.writeContract({
+        address: CONTRACTS.POLYGON_MESSAGE_TRANSMITTER_V2,
+        abi: MESSAGE_TRANSMITTER_V2_ABI2,
+        functionName: "receiveMessage",
+        args: [messageBytes, attestation]
+      });
+      await this.polygonPublic.waitForTransactionReceipt({ hash: receiveHash });
+      console.log(`CCTP deposit complete: ${Number(amount) / 1e6} USDC Base \u2192 Polygon in ${((Date.now() - startTime) / 1e3).toFixed(0)}s`);
+      return {
+        success: true,
+        amount,
+        burnTxHash: burnHash,
+        receiveTxHash: receiveHash,
+        duration: Date.now() - startTime
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error("CCTP deposit to Polygon failed:", message);
+      return { success: false, amount, error: message, duration: Date.now() - startTime };
+    }
+  }
+  // ============================================================
+  // WITHDRAW: Polygon → Base
+  // ============================================================
+  /**
+   * Bridge USDC from Polygon back to Base via CCTP V2.
+   * Used for fee collection (bridge accumulated fees to Base treasury).
+   */
+  async withdrawToBase(amount, onStep) {
+    const startTime = Date.now();
+    if (amount < MIN_BRIDGE_AMOUNT) {
+      return { success: false, amount, error: "Amount below minimum (1 USDC)" };
+    }
+    try {
+      onStep?.("approve_usdc");
+      await this.approveIfNeeded(
+        this.polygonPublic,
+        this.polygonWallet,
+        CONTRACTS.POLYGON_USDC,
+        CONTRACTS.POLYGON_TOKEN_MESSENGER_V2,
+        amount
+      );
+      onStep?.("cctp_burn");
+      const mintRecipient = this.addressToBytes32(this.account.address);
+      const burnHash = await this.polygonWallet.writeContract({
+        address: CONTRACTS.POLYGON_TOKEN_MESSENGER_V2,
+        abi: TOKEN_MESSENGER_V2_ABI2,
+        functionName: "depositForBurn",
+        args: [amount, CCTP_DOMAIN_BASE, mintRecipient, CONTRACTS.POLYGON_USDC]
+      });
+      const burnReceipt = await this.polygonPublic.waitForTransactionReceipt({ hash: burnHash });
+      const messageBytes = this.extractMessageFromReceipt(burnReceipt);
+      if (!messageBytes) {
+        return { success: false, amount, burnTxHash: burnHash, error: "Failed to extract CCTP message" };
+      }
+      onStep?.("wait_attestation");
+      const attestation = await this.waitForAttestation(messageBytes);
+      if (!attestation) {
+        return { success: false, amount, burnTxHash: burnHash, error: "Attestation timeout" };
+      }
+      onStep?.("cctp_receive");
+      const receiveHash = await this.baseWallet.writeContract({
+        address: CONTRACTS.BASE_MESSAGE_TRANSMITTER_V2,
+        abi: MESSAGE_TRANSMITTER_V2_ABI2,
+        functionName: "receiveMessage",
+        args: [messageBytes, attestation]
+      });
+      await this.basePublic.waitForTransactionReceipt({ hash: receiveHash });
+      console.log(`CCTP withdrawal complete: ${Number(amount) / 1e6} USDC Polygon \u2192 Base in ${((Date.now() - startTime) / 1e3).toFixed(0)}s`);
+      return {
+        success: true,
+        amount,
+        burnTxHash: burnHash,
+        receiveTxHash: receiveHash,
+        duration: Date.now() - startTime
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error("CCTP withdrawal to Base failed:", message);
+      return { success: false, amount, error: message, duration: Date.now() - startTime };
+    }
+  }
+  // ============================================================
+  // PRIVATE HELPERS
+  // ============================================================
+  /** Convert address to bytes32 (left-padded) for CCTP mintRecipient */
+  addressToBytes32(address) {
+    return `0x000000000000000000000000${address.slice(2)}`;
+  }
+  /** Approve USDC spend if needed (maxUint256 pattern) */
+  async approveIfNeeded(publicClient, walletClient, token, spender, amount) {
+    const allowance = await publicClient.readContract({
+      address: token,
+      abi: ERC20_ABI2,
+      functionName: "allowance",
+      args: [this.account.address, spender]
+    });
+    if (allowance < amount) {
+      const maxUint256 = 2n ** 256n - 1n;
+      const hash = await walletClient.writeContract({
+        address: token,
+        abi: ERC20_ABI2,
+        functionName: "approve",
+        args: [spender, maxUint256]
+      });
+      await publicClient.waitForTransactionReceipt({ hash });
+    }
+  }
+  /** Extract MessageSent bytes from a CCTP burn transaction receipt */
+  extractMessageFromReceipt(receipt) {
+    for (const log of receipt.logs || []) {
+      try {
+        if (log.topics[0] === "0x8c5261668696ce22758910d05bab8f186d6eb247ceac2af2e82c7dc17669b036") {
+          return log.data;
+        }
+      } catch {
+        continue;
+      }
+    }
+    return null;
+  }
+  /** Wait for Circle attestation (polls Iris API) */
+  async waitForAttestation(messageBytes, timeoutMs = 9e5) {
+    const { keccak256: keccak2565 } = await import("viem");
+    const messageHash = keccak2565(messageBytes);
+    const start = Date.now();
+    const pollInterval = 5e3;
+    while (Date.now() - start < timeoutMs) {
+      try {
+        const resp = await fetch(`${IRIS_API_URL}/${messageHash}`);
+        if (resp.ok) {
+          const data = await resp.json();
+          if (data.status === "complete" && data.attestation) {
+            return data.attestation;
+          }
+        }
+      } catch {
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    return null;
+  }
+};
+
+// src/prediction/vault-manager.ts
+var import_viem10 = require("viem");
+var import_chains7 = require("viem/chains");
+var import_accounts7 = require("viem/accounts");
+var ERC20_ABI3 = (0, import_viem10.parseAbi)([
+  "function approve(address spender, uint256 amount) external returns (bool)",
+  "function balanceOf(address account) external view returns (uint256)",
+  "function allowance(address owner, address spender) external view returns (uint256)"
+]);
+var VAULT_FACTORY_ABI2 = (0, import_viem10.parseAbi)([
+  "function createVault(uint256 agentId, address agentWallet, uint256 seedAmount, string name, string symbol, address feeRecipient, bool isVerified, bytes agentSig) external returns (address)",
+  "function vaults(uint256 agentId) external view returns (address)",
+  "function isFactoryVault(address vault) external view returns (bool)",
+  "function MIN_SEED_AMOUNT() external view returns (uint256)"
+]);
+var VAULT_ABI2 = (0, import_viem10.parseAbi)([
+  // ERC-4626
+  "function deposit(uint256 assets, address receiver) external returns (uint256)",
+  "function withdraw(uint256 assets, address receiver, address owner) external returns (uint256)",
+  "function redeem(uint256 shares, address receiver, address owner) external returns (uint256)",
+  "function redeemMax(address receiver, address owner) external returns (uint256)",
+  "function totalAssets() external view returns (uint256)",
+  "function totalSupply() external view returns (uint256)",
+  "function balanceOf(address account) external view returns (uint256)",
+  "function convertToAssets(uint256 shares) external view returns (uint256)",
+  "function convertToShares(uint256 assets) external view returns (uint256)",
+  // Vault-specific views
+  "function sharePrice() external view returns (uint256)",
+  "function availableTradingBalance() external view returns (uint256)",
+  "function currentExposureBps() external view returns (uint256)",
+  "function cachedCtfValue() external view returns (uint256)",
+  "function lastCtfUpdate() external view returns (uint256)",
+  "function depositCap() external view returns (uint256)",
+  "function agentSeedAmount() external view returns (uint256)",
+  "function circuitBreakerActive() external view returns (bool)",
+  "function paused() external view returns (bool)",
+  "function pendingTradingVolume() external view returns (uint256)",
+  "function getTrackedTokenCount() external view returns (uint256)",
+  "function agentWallet() external view returns (address)",
+  "function agentId() external view returns (uint256)",
+  "function isVerified() external view returns (bool)",
+  "function maxExposureBps() external view returns (uint256)",
+  // Keeper functions
+  "function updatePositionValues(uint256[] tokenIds, uint256[] values) external",
+  "function collectTradingFees(uint256 volume) external",
+  // Emergency
+  "function emergencyWithdraw() external returns (uint256)"
+]);
+var PredictionVaultManager = class {
+  config;
+  publicClient;
+  walletClient;
+  account;
+  /** Resolved vault address (discovered or created) */
+  vaultAddress = null;
+  /** NAV update timer */
+  navTimer = null;
+  /** Fee collection timer */
+  feeTimer = null;
+  /** Last known accumulated trading volume (for delta tracking) */
+  lastReportedVolume = 0n;
+  constructor(privateKey, config) {
+    this.config = config;
+    this.account = (0, import_accounts7.privateKeyToAccount)(privateKey);
+    const transport = (0, import_viem10.http)(config.polygonRpcUrl, { timeout: 6e4 });
+    this.publicClient = (0, import_viem10.createPublicClient)({ chain: import_chains7.polygon, transport });
+    this.walletClient = (0, import_viem10.createWalletClient)({
+      chain: import_chains7.polygon,
+      transport,
+      account: this.account
+    });
+    if (config.vaultAddress) {
+      this.vaultAddress = config.vaultAddress;
+    }
+  }
+  // ============================================================
+  // INITIALIZATION
+  // ============================================================
+  /**
+   * Initialize the vault manager — discover existing vault or prepare for creation.
+   */
+  async initialize() {
+    if (!this.vaultAddress) {
+      try {
+        const vaultAddr = await this.publicClient.readContract({
+          address: this.config.factoryAddress,
+          abi: VAULT_FACTORY_ABI2,
+          functionName: "vaults",
+          args: [this.config.agentId]
+        });
+        if (vaultAddr && vaultAddr !== "0x0000000000000000000000000000000000000000") {
+          this.vaultAddress = vaultAddr;
+          console.log(`Discovered existing prediction vault: ${this.vaultAddress}`);
+        }
+      } catch {
+        console.log("No existing prediction vault found \u2014 create one via createVault()");
+      }
+    }
+    if (this.vaultAddress) {
+      console.log(`Prediction vault manager initialized for vault: ${this.vaultAddress}`);
+    }
+  }
+  /**
+   * Get the vault address (null if no vault exists).
+   */
+  getVaultAddress() {
+    return this.vaultAddress;
+  }
+  /**
+   * Whether a vault has been created/discovered.
+   */
+  get hasVault() {
+    return this.vaultAddress !== null;
+  }
+  // ============================================================
+  // VAULT CREATION
+  // ============================================================
+  /**
+   * Create a new prediction vault via PredictionVaultFactory.
+   *
+   * Deploys PredictionVault on Polygon with:
+   * - Agent's EOA as the authorized signer for ERC-1271
+   * - Seed USDC transferred from agent wallet to vault
+   * - Deposit cap = seed × multiplier (10x unverified, 100x verified)
+   */
+  async createVault(seedAmount, name, symbol) {
+    if (this.vaultAddress) {
+      return { success: false, error: `Vault already exists: ${this.vaultAddress}` };
+    }
+    try {
+      const message = (0, import_viem10.keccak256)(
+        (0, import_viem10.encodePacked)(
+          ["uint256", "address", "address"],
+          [this.config.agentId, this.account.address, this.config.factoryAddress]
+        )
+      );
+      const agentSig = await this.account.signMessage({ message: { raw: message } });
+      await this.approveIfNeeded(
+        POLYGON_USDC_ADDRESS,
+        this.config.factoryAddress,
+        seedAmount
+      );
+      const hash = await this.walletClient.writeContract({
+        address: this.config.factoryAddress,
+        abi: VAULT_FACTORY_ABI2,
+        functionName: "createVault",
+        args: [
+          this.config.agentId,
+          this.account.address,
+          seedAmount,
+          name,
+          symbol,
+          this.config.feeRecipient,
+          this.config.isVerified ?? false,
+          agentSig
+        ]
+      });
+      const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+      const vaultAddr = await this.publicClient.readContract({
+        address: this.config.factoryAddress,
+        abi: VAULT_FACTORY_ABI2,
+        functionName: "vaults",
+        args: [this.config.agentId]
+      });
+      this.vaultAddress = vaultAddr;
+      console.log(`Prediction vault created: ${this.vaultAddress} (seed: ${(0, import_viem10.formatUnits)(seedAmount, 6)} USDC)`);
+      return {
+        success: true,
+        vaultAddress: this.vaultAddress,
+        txHash: hash
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error("Failed to create prediction vault:", message);
+      return { success: false, error: message };
+    }
+  }
+  // ============================================================
+  // DEPOSITS & WITHDRAWALS
+  // ============================================================
+  /**
+   * Deposit USDC into the prediction vault.
+   * Returns the number of shares received.
+   */
+  async deposit(amount) {
+    if (!this.vaultAddress) {
+      return { success: false, error: "No vault exists" };
+    }
+    try {
+      await this.approveIfNeeded(
+        POLYGON_USDC_ADDRESS,
+        this.vaultAddress,
+        amount
+      );
+      const hash = await this.walletClient.writeContract({
+        address: this.vaultAddress,
+        abi: VAULT_ABI2,
+        functionName: "deposit",
+        args: [amount, this.account.address]
+      });
+      const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+      const shares = await this.publicClient.readContract({
+        address: this.vaultAddress,
+        abi: VAULT_ABI2,
+        functionName: "balanceOf",
+        args: [this.account.address]
+      });
+      console.log(`Deposited ${(0, import_viem10.formatUnits)(amount, 6)} USDC into prediction vault`);
+      return { success: true, shares, txHash: hash };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error("Vault deposit failed:", message);
+      return { success: false, error: message };
+    }
+  }
+  /**
+   * Withdraw USDC from the prediction vault.
+   * Redeems all shares and returns the USDC received (net of fees).
+   */
+  async withdrawAll() {
+    if (!this.vaultAddress) {
+      return { success: false, error: "No vault exists" };
+    }
+    try {
+      const hash = await this.walletClient.writeContract({
+        address: this.vaultAddress,
+        abi: VAULT_ABI2,
+        functionName: "redeemMax",
+        args: [this.account.address, this.account.address]
+      });
+      const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+      const balance = await this.publicClient.readContract({
+        address: POLYGON_USDC_ADDRESS,
+        abi: ERC20_ABI3,
+        functionName: "balanceOf",
+        args: [this.account.address]
+      });
+      console.log("Withdrew all shares from prediction vault");
+      return { success: true, assets: balance, txHash: hash };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error("Vault withdrawal failed:", message);
+      return { success: false, error: message };
+    }
+  }
+  /**
+   * Emergency withdraw with penalty.
+   */
+  async emergencyWithdraw() {
+    if (!this.vaultAddress) {
+      return { success: false, error: "No vault exists" };
+    }
+    try {
+      const hash = await this.walletClient.writeContract({
+        address: this.vaultAddress,
+        abi: VAULT_ABI2,
+        functionName: "emergencyWithdraw",
+        args: []
+      });
+      await this.publicClient.waitForTransactionReceipt({ hash });
+      console.log("Emergency withdrew from prediction vault (penalty applied)");
+      return { success: true, txHash: hash };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return { success: false, error: message };
+    }
+  }
+  // ============================================================
+  // VAULT STATUS
+  // ============================================================
+  /**
+   * Get comprehensive vault status.
+   */
+  async getVaultStatus() {
+    if (!this.vaultAddress) {
+      return {
+        vaultAddress: "0x0000000000000000000000000000000000000000",
+        hasVault: false,
+        totalAssets: 0n,
+        totalSupply: 0n,
+        sharePrice: 0,
+        usdcBalance: 0n,
+        cachedCtfValue: 0n,
+        currentExposureBps: 0,
+        depositCap: 0n,
+        seedAmount: 0n,
+        circuitBreakerActive: false,
+        isPaused: false,
+        lastCtfUpdate: 0,
+        pendingTradingVolume: 0n,
+        trackedTokenCount: 0
+      };
+    }
+    try {
+      const [
+        totalAssets,
+        totalSupply,
+        sharePrice,
+        usdcBalance,
+        cachedCtfValue,
+        currentExposureBps,
+        depositCap,
+        seedAmount,
+        circuitBreakerActive,
+        isPaused,
+        lastCtfUpdate,
+        pendingTradingVolume,
+        trackedTokenCount
+      ] = await Promise.all([
+        this.publicClient.readContract({ address: this.vaultAddress, abi: VAULT_ABI2, functionName: "totalAssets" }),
+        this.publicClient.readContract({ address: this.vaultAddress, abi: VAULT_ABI2, functionName: "totalSupply" }),
+        this.publicClient.readContract({ address: this.vaultAddress, abi: VAULT_ABI2, functionName: "sharePrice" }),
+        this.publicClient.readContract({ address: POLYGON_USDC_ADDRESS, abi: ERC20_ABI3, functionName: "balanceOf", args: [this.vaultAddress] }),
+        this.publicClient.readContract({ address: this.vaultAddress, abi: VAULT_ABI2, functionName: "cachedCtfValue" }),
+        this.publicClient.readContract({ address: this.vaultAddress, abi: VAULT_ABI2, functionName: "currentExposureBps" }),
+        this.publicClient.readContract({ address: this.vaultAddress, abi: VAULT_ABI2, functionName: "depositCap" }),
+        this.publicClient.readContract({ address: this.vaultAddress, abi: VAULT_ABI2, functionName: "agentSeedAmount" }),
+        this.publicClient.readContract({ address: this.vaultAddress, abi: VAULT_ABI2, functionName: "circuitBreakerActive" }),
+        this.publicClient.readContract({ address: this.vaultAddress, abi: VAULT_ABI2, functionName: "paused" }),
+        this.publicClient.readContract({ address: this.vaultAddress, abi: VAULT_ABI2, functionName: "lastCtfUpdate" }),
+        this.publicClient.readContract({ address: this.vaultAddress, abi: VAULT_ABI2, functionName: "pendingTradingVolume" }),
+        this.publicClient.readContract({ address: this.vaultAddress, abi: VAULT_ABI2, functionName: "getTrackedTokenCount" })
+      ]);
+      return {
+        vaultAddress: this.vaultAddress,
+        hasVault: true,
+        totalAssets,
+        totalSupply,
+        sharePrice: Number(sharePrice) / 1e6,
+        usdcBalance,
+        cachedCtfValue,
+        currentExposureBps: Number(currentExposureBps),
+        depositCap,
+        seedAmount,
+        circuitBreakerActive,
+        isPaused,
+        lastCtfUpdate: Number(lastCtfUpdate),
+        pendingTradingVolume,
+        trackedTokenCount: Number(trackedTokenCount)
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error("Failed to read vault status:", message);
+      return {
+        vaultAddress: this.vaultAddress,
+        hasVault: true,
+        totalAssets: 0n,
+        totalSupply: 0n,
+        sharePrice: 0,
+        usdcBalance: 0n,
+        cachedCtfValue: 0n,
+        currentExposureBps: 0,
+        depositCap: 0n,
+        seedAmount: 0n,
+        circuitBreakerActive: false,
+        isPaused: false,
+        lastCtfUpdate: 0,
+        pendingTradingVolume: 0n,
+        trackedTokenCount: 0
+      };
+    }
+  }
+  // ============================================================
+  // KEEPER: NAV UPDATES
+  // ============================================================
+  /**
+   * Update cached CTF position values (keeper function).
+   * Fetches CLOB midpoint prices for all tracked tokens and updates the vault.
+   *
+   * @param tokenIds - CTF token IDs
+   * @param values - USD values in 6-decimal (midpoint price × balance for each token)
+   */
+  async updatePositionValues(tokenIds, values) {
+    if (!this.vaultAddress) {
+      return { success: false, error: "No vault exists" };
+    }
+    try {
+      const hash = await this.walletClient.writeContract({
+        address: this.vaultAddress,
+        abi: VAULT_ABI2,
+        functionName: "updatePositionValues",
+        args: [tokenIds, values]
+      });
+      await this.publicClient.waitForTransactionReceipt({ hash });
+      console.log(`Updated ${tokenIds.length} position values in prediction vault`);
+      return { success: true, txHash: hash };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error("Failed to update position values:", message);
+      return { success: false, error: message };
+    }
+  }
+  /**
+   * Collect trading fees based on reported volume (keeper function).
+   * Transfers 0.2% of volume as fees to PredictionFeeCollector.
+   *
+   * @param volume - Trading volume to report (6-decimal USDC)
+   */
+  async collectTradingFees(volume) {
+    if (!this.vaultAddress) {
+      return { success: false, error: "No vault exists" };
+    }
+    try {
+      const hash = await this.walletClient.writeContract({
+        address: this.vaultAddress,
+        abi: VAULT_ABI2,
+        functionName: "collectTradingFees",
+        args: [volume]
+      });
+      await this.publicClient.waitForTransactionReceipt({ hash });
+      const feeAmount = volume * 20n / 10000n;
+      console.log(`Collected trading fees: ${(0, import_viem10.formatUnits)(feeAmount, 6)} USDC from ${(0, import_viem10.formatUnits)(volume, 6)} USDC volume`);
+      return { success: true, txHash: hash };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error("Failed to collect trading fees:", message);
+      return { success: false, error: message };
+    }
+  }
+  // ============================================================
+  // KEEPER LOOPS
+  // ============================================================
+  /**
+   * Start the keeper loops (NAV updates + fee collection).
+   * These run on timers and automatically update vault state.
+   *
+   * @param getPositionValues - Callback that returns current CTF position values
+   *        (token IDs and their midpoint-price USD values)
+   * @param getAccumulatedVolume - Callback that returns accumulated trading volume
+   *        since last fee collection
+   */
+  startKeeperLoops(getPositionValues, getAccumulatedVolume) {
+    if (!this.vaultAddress) {
+      console.log("Cannot start keeper loops \u2014 no vault exists");
+      return;
+    }
+    const navInterval = this.config.navUpdateIntervalMs ?? 15 * 60 * 1e3;
+    this.navTimer = setInterval(async () => {
+      try {
+        const { tokenIds, values } = await getPositionValues();
+        if (tokenIds.length > 0) {
+          await this.updatePositionValues(tokenIds, values);
+        }
+      } catch (error) {
+        console.error("Keeper NAV update failed:", error instanceof Error ? error.message : error);
+      }
+    }, navInterval);
+    const feeInterval = this.config.feeCollectionIntervalMs ?? 24 * 60 * 60 * 1e3;
+    this.feeTimer = setInterval(async () => {
+      try {
+        const currentVolume = getAccumulatedVolume();
+        const volumeDelta = currentVolume - this.lastReportedVolume;
+        if (volumeDelta > 0n) {
+          await this.collectTradingFees(volumeDelta);
+          this.lastReportedVolume = currentVolume;
+        }
+      } catch (error) {
+        console.error("Keeper fee collection failed:", error instanceof Error ? error.message : error);
+      }
+    }, feeInterval);
+    console.log(`Keeper loops started (NAV: every ${navInterval / 6e4}min, fees: every ${feeInterval / 36e5}h)`);
+  }
+  /**
+   * Stop keeper loops.
+   */
+  stopKeeperLoops() {
+    if (this.navTimer) {
+      clearInterval(this.navTimer);
+      this.navTimer = null;
+    }
+    if (this.feeTimer) {
+      clearInterval(this.feeTimer);
+      this.feeTimer = null;
+    }
+    console.log("Keeper loops stopped");
+  }
+  // ============================================================
+  // CLEANUP
+  // ============================================================
+  /**
+   * Stop all timers and clean up.
+   */
+  stop() {
+    this.stopKeeperLoops();
+  }
+  // ============================================================
+  // PRIVATE HELPERS
+  // ============================================================
+  /** Approve USDC spend if needed (maxUint256 pattern) */
+  async approveIfNeeded(token, spender, amount) {
+    const allowance = await this.publicClient.readContract({
+      address: token,
+      abi: ERC20_ABI3,
+      functionName: "allowance",
+      args: [this.account.address, spender]
+    });
+    if (allowance < amount) {
+      const maxUint256 = 2n ** 256n - 1n;
+      const hash = await this.walletClient.writeContract({
+        address: token,
+        abi: ERC20_ABI3,
+        functionName: "approve",
+        args: [spender, maxUint256]
+      });
+      await this.publicClient.waitForTransactionReceipt({ hash });
+    }
+  }
+};
+
+// src/runtime.ts
+var FUNDS_LOW_THRESHOLD = 5e-3;
+var FUNDS_CRITICAL_THRESHOLD = 1e-3;
+var AgentRuntime = class {
+  config;
+  client;
+  llm;
+  strategy;
+  executor;
+  riskManager;
+  marketData;
+  vaultManager;
+  relay = null;
+  isRunning = false;
+  mode = "idle";
+  configHash;
+  pendingConfigHash = null;
+  lastConfigCheckAt = 0;
+  // Timestamp of last pending config RPC check
+  cycleCount = 0;
+  lastCycleAt = 0;
+  lastPortfolioValue = 0;
+  lastEthBalance = "0";
+  lastPrices = {};
+  processAlive = true;
+  riskUniverse = 0;
+  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;
+  perpOrders = null;
+  perpPositions = null;
+  perpWebSocket = null;
+  perpRecorder = null;
+  perpOnboarding = null;
+  perpStrategy = null;
+  // Two-layer perp control:
+  //   perpConnected = Hyperliquid infrastructure is initialized (WS, signer, recorder ready)
+  //   perpTradingActive = Dedicated perp trading cycle is mandated to run
+  // When perpConnected && !perpTradingActive: agent's strategy can optionally return perp signals
+  // When perpConnected && perpTradingActive: dedicated runPerpCycle() runs every interval
+  perpConnected = false;
+  perpTradingActive = false;
+  // Cached perp account data for synchronous heartbeat inclusion (refreshed async)
+  cachedPerpEquity = 0;
+  cachedPerpUnrealizedPnl = 0;
+  cachedPerpMarginUsed = 0;
+  cachedPerpLeverage = 0;
+  cachedPerpOpenPositions = 0;
+  // Prediction market components (null if prediction not enabled)
+  predictionClient = null;
+  predictionOrders = null;
+  predictionPositions = null;
+  predictionRecorder = null;
+  predictionFunding = null;
+  predictionBrowser = null;
+  predictionStrategy = null;
+  // Two-layer prediction control (mirrors perp pattern):
+  //   predictionConnected = Polymarket infrastructure initialized (CLOB client, recorder ready)
+  //   predictionTradingActive = Dedicated prediction trading cycle is mandated to run
+  predictionConnected = false;
+  predictionTradingActive = false;
+  // Cached prediction data for synchronous heartbeat inclusion
+  cachedPredictionPolygonUSDC = 0;
+  cachedPredictionBaseUSDC = 0;
+  cachedPredictionExposure = 0;
+  cachedPredictionOpenMarkets = 0;
+  cachedPredictionOpenPositions = 0;
+  cachedPredictionUnrealizedPnl = 0;
+  // Prediction vault manager (null if vault mode not enabled)
+  predictionVaultManager = null;
+  // Cached vault status for synchronous heartbeat
+  cachedPredictionVaultStatus = void 0;
+  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
+   */
+  async initialize() {
+    console.log(`Initializing agent: ${this.config.name} (ID: ${this.config.agentId})`);
+    this.client = new import_sdk.ExagentClient({
+      privateKey: this.config.privateKey,
+      network: this.config.network
+    });
+    console.log(`Wallet: ${this.client.address}`);
+    const agent = await this.client.registry.getAgent(BigInt(this.config.agentId));
+    if (!agent) {
+      throw new Error(`Agent ID ${this.config.agentId} not found on-chain. Please register first.`);
+    }
+    console.log(`Agent verified: ${agent.name}`);
+    await this.ensureWalletLinked();
+    await this.loadTradingRestrictions();
+    console.log(`Initializing LLM: ${this.config.llm.provider}`);
+    this.llm = await createLLMAdapter(this.config.llm);
+    const llmMeta = this.llm.getMetadata();
+    console.log(`LLM ready: ${llmMeta.provider} (${llmMeta.model})`);
+    await this.syncConfigHash();
+    this.strategy = await loadStrategy();
+    const store = new FileStore();
+    this.strategyContext = {
+      store,
+      agentId: Number(this.config.agentId),
+      walletAddress: this.client.address
+    };
+    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.riskUniverse);
     this.marketData = new MarketDataService(this.getRpcUrl(), store);
     setGlobalResolver(this.marketData.getResolver());
@@ -4478,6 +7003,7 @@ var AgentRuntime = class {
     }
     await this.initializeVaultManager();
     await this.initializePerp();
+    await this.initializePrediction();
     await this.initializeRelay();
     console.log("Agent initialized successfully");
   }
@@ -4567,10 +7093,10 @@ var AgentRuntime = class {
       };
       this.perpClient = new HyperliquidClient(config);
       const perpKey = perpConfig.perpRelayerKey || this.config.privateKey;
-      const account = (0, import_accounts5.privateKeyToAccount)(perpKey);
-      const walletClient = (0, import_viem7.createWalletClient)({
+      const account = (0, import_accounts8.privateKeyToAccount)(perpKey);
+      const walletClient = (0, import_viem11.createWalletClient)({
         chain: { id: 42161, name: "Arbitrum", nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 }, rpcUrls: { default: { http: ["https://arb1.arbitrum.io/rpc"] } } },
-        transport: (0, import_viem7.http)("https://arb1.arbitrum.io/rpc", { timeout: 6e4 }),
+        transport: (0, import_viem11.http)("https://arb1.arbitrum.io/rpc", { timeout: 6e4 }),
         account
       });
       this.perpSigner = new HyperliquidSigner(walletClient);
@@ -4646,6 +7172,101 @@ var AgentRuntime = class {
       console.warn("Perp trading will be disabled for this session");
     }
   }
+  /**
+   * Initialize Polymarket prediction market components.
+   * Only initializes if prediction is enabled in config AND risk universe >= 2.
+   */
+  async initializePrediction() {
+    const predictionConfig = this.config.prediction;
+    if (!predictionConfig?.enabled) {
+      console.log("Prediction markets: Disabled");
+      return;
+    }
+    if (this.riskUniverse < 2) {
+      console.warn(`Prediction markets: Blocked by risk universe ${this.riskUniverse} (need >= 2)`);
+      return;
+    }
+    try {
+      const config = {
+        enabled: true,
+        clobApiUrl: predictionConfig.clobApiUrl || "https://clob.polymarket.com",
+        gammaApiUrl: predictionConfig.gammaApiUrl || "https://gamma-api.polymarket.com",
+        polygonRpcUrl: predictionConfig.polygonRpcUrl || "https://polygon-rpc.com",
+        maxNotionalUSD: predictionConfig.maxNotionalUSD ?? 500,
+        maxTotalExposureUSD: predictionConfig.maxTotalExposureUSD ?? 5e3,
+        polygonAllocationUSD: predictionConfig.polygonAllocationUSD ?? 100,
+        allowedCategories: predictionConfig.allowedCategories,
+        feeBridgeThresholdUSD: predictionConfig.feeBridgeThresholdUSD ?? 10
+      };
+      const vaultConfig = predictionConfig.vault;
+      let vaultOpts;
+      if (vaultConfig?.enabled && vaultConfig.factoryAddress) {
+        this.predictionVaultManager = new PredictionVaultManager(
+          this.config.privateKey,
+          {
+            enabled: true,
+            factoryAddress: vaultConfig.factoryAddress,
+            feeCollectorAddress: vaultConfig.feeCollectorAddress || "0x0000000000000000000000000000000000000000",
+            polygonRpcUrl: predictionConfig.polygonRpcUrl || "https://polygon-rpc.com",
+            vaultAddress: vaultConfig.vaultAddress,
+            agentId: BigInt(this.config.agentId),
+            feeRecipient: vaultConfig.feeRecipient || this.client.address,
+            isVerified: vaultConfig.isVerified ?? false
+          }
+        );
+        await this.predictionVaultManager.initialize();
+        if (this.predictionVaultManager.hasVault) {
+          const vaultAddr = this.predictionVaultManager.getVaultAddress();
+          vaultOpts = { vaultMode: true, vaultAddress: vaultAddr };
+          console.log(`  Vault mode: ENABLED \u2014 vault ${vaultAddr}`);
+        } else {
+          console.log("  Vault mode: configured but no vault exists \u2014 create one via command center");
+        }
+      }
+      this.predictionClient = new PolymarketClient(this.config.privateKey, config, vaultOpts);
+      await this.predictionClient.initialize();
+      this.predictionOrders = new PredictionOrderManager(this.predictionClient, config);
+      this.predictionPositions = new PredictionPositionManager(this.predictionClient, config);
+      this.predictionBrowser = new MarketBrowser(config);
+      const recorderKey = predictionConfig.predictionRelayerKey || this.config.privateKey;
+      this.predictionRecorder = new PredictionTradeRecorder({
+        privateKey: recorderKey,
+        rpcUrl: this.getRpcUrl(),
+        agentId: BigInt(this.config.agentId),
+        configHash: this.configHash
+      });
+      this.predictionFunding = new PredictionFunding({
+        privateKey: this.config.privateKey,
+        baseRpcUrl: this.getRpcUrl(),
+        polygonRpcUrl: predictionConfig.polygonRpcUrl,
+        ...vaultOpts?.vaultMode && vaultOpts?.vaultAddress && {
+          polygonRecipient: vaultOpts.vaultAddress
+        }
+      });
+      this.predictionConnected = true;
+      console.log(`Polymarket: Connected`);
+      console.log(`  CLOB: ${config.clobApiUrl}`);
+      console.log(`  Max notional: $${config.maxNotionalUSD}, Max exposure: $${config.maxTotalExposureUSD}`);
+      if (config.allowedCategories?.length) {
+        console.log(`  Categories: ${config.allowedCategories.join(", ")}`);
+      }
+      try {
+        const polygonBalance = await this.predictionFunding.getPolygonUSDCBalance();
+        const polygonUSDC = Number(polygonBalance) / 1e6;
+        this.cachedPredictionPolygonUSDC = polygonUSDC;
+        console.log(`  Polygon USDC: $${polygonUSDC.toFixed(2)}`);
+        if (polygonUSDC < 1) {
+          console.warn("  No USDC on Polygon \u2014 bridge required before trading");
+        }
+      } catch {
+        console.warn("  Could not check Polygon USDC balance");
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`Prediction initialization failed: ${message}`);
+      console.warn("Prediction market trading will be disabled for this session");
+    }
+  }
   /**
    * Ensure the current wallet is linked to the agent.
    * If the trading wallet differs from the owner, enters a recovery loop
@@ -4810,9 +7431,9 @@ var AgentRuntime = class {
       const message = error instanceof Error ? error.message : String(error);
       if (message.includes("insufficient funds") || message.includes("intrinsic gas too low") || message.includes("exceeds the balance")) {
         const ccUrl = `https://exagent.io/agents/${encodeURIComponent(this.config.name)}/command-center`;
-        const publicClientInstance = (0, import_viem7.createPublicClient)({
-          chain: import_chains5.base,
-          transport: (0, import_viem7.http)(this.getRpcUrl(), { timeout: 6e4 })
+        const publicClientInstance = (0, import_viem11.createPublicClient)({
+          chain: import_chains8.base,
+          transport: (0, import_viem11.http)(this.getRpcUrl(), { timeout: 6e4 })
         });
         console.log("");
         console.log("=== ETH NEEDED FOR GAS ===");
@@ -4890,16 +7511,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) {
@@ -4923,8 +7548,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 {
@@ -5070,107 +7700,360 @@ var AgentRuntime = class {
                 'Hyperliquid infrastructure connected. Agent can now include perp signals in its strategy. Use "Start Perp Trading" to mandate a dedicated perp cycle.'
               );
             } else {
-              this.relay?.sendCommandResult(cmd.id, false, "Failed to connect to Hyperliquid");
+              this.relay?.sendCommandResult(cmd.id, false, "Failed to connect to Hyperliquid");
+            }
+          } catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.relay?.sendCommandResult(cmd.id, false, `Hyperliquid init failed: ${msg}`);
+          }
+          this.sendRelayStatus();
+          break;
+        case "disable_hyperliquid":
+          if (!this.perpConnected) {
+            this.relay?.sendCommandResult(cmd.id, true, "Hyperliquid already disconnected");
+            break;
+          }
+          this.perpTradingActive = false;
+          if (this.perpWebSocket) {
+            this.perpWebSocket.disconnect();
+          }
+          if (this.perpRecorder) {
+            this.perpRecorder.stop();
+          }
+          this.perpConnected = false;
+          console.log("Hyperliquid disabled via command center");
+          this.relay?.sendCommandResult(cmd.id, true, "Hyperliquid disconnected");
+          this.relay?.sendMessage(
+            "system",
+            "info",
+            "Hyperliquid Disabled",
+            "Hyperliquid infrastructure disconnected. Agent will trade spot only."
+          );
+          this.sendRelayStatus();
+          break;
+        case "start_perp_trading":
+          if (!this.perpConnected) {
+            this.relay?.sendCommandResult(cmd.id, false, "Hyperliquid not connected. Enable Hyperliquid first.");
+            break;
+          }
+          if (this.perpTradingActive) {
+            this.relay?.sendCommandResult(cmd.id, true, "Perp trading already active");
+            break;
+          }
+          this.perpTradingActive = true;
+          if (this.mode !== "trading") {
+            this.mode = "trading";
+            this.isRunning = true;
+          }
+          console.log("Perp trading mandated via command center");
+          this.relay?.sendCommandResult(cmd.id, true, "Perp trading cycle active");
+          this.relay?.sendMessage(
+            "system",
+            "success",
+            "Perp Trading Active",
+            "Dedicated perp trading cycle is now running every interval."
+          );
+          this.sendRelayStatus();
+          break;
+        case "stop_perp_trading":
+          if (!this.perpTradingActive) {
+            this.relay?.sendCommandResult(cmd.id, true, "Perp trading already stopped");
+            break;
+          }
+          this.perpTradingActive = false;
+          console.log("Perp trading cycle stopped via command center");
+          this.relay?.sendCommandResult(cmd.id, true, "Perp trading cycle stopped");
+          this.relay?.sendMessage(
+            "system",
+            "info",
+            "Perp Trading Stopped",
+            "Dedicated perp cycle stopped. Hyperliquid remains connected \u2014 strategy can still include perp signals."
+          );
+          this.sendRelayStatus();
+          break;
+        case "update_perp_params": {
+          const perpParams = cmd.params || {};
+          let perpUpdated = false;
+          if (this.config.perp && perpParams.maxLeverage !== void 0) {
+            const val = Number(perpParams.maxLeverage);
+            if (val >= 1 && val <= 50) {
+              this.config.perp.maxLeverage = val;
+              perpUpdated = true;
+            }
+          }
+          if (this.config.perp && perpParams.maxNotionalUSD !== void 0) {
+            const val = Number(perpParams.maxNotionalUSD);
+            if (val >= 100) {
+              this.config.perp.maxNotionalUSD = val;
+              perpUpdated = true;
+            }
+          }
+          if (perpUpdated) {
+            this.relay?.sendCommandResult(cmd.id, true, "Perp parameters updated");
+            this.relay?.sendMessage(
+              "config_updated",
+              "info",
+              "Perp Params Updated",
+              `Max leverage: ${this.config.perp?.maxLeverage}x, Max notional: $${this.config.perp?.maxNotionalUSD?.toLocaleString()}`
+            );
+          } else {
+            this.relay?.sendCommandResult(cmd.id, false, "No valid perp parameters provided");
+          }
+          break;
+        }
+        case "enable_polymarket":
+          if (this.predictionConnected) {
+            this.relay?.sendCommandResult(cmd.id, true, "Polymarket already connected");
+            break;
+          }
+          if (!this.config.prediction?.enabled) {
+            this.relay?.sendCommandResult(cmd.id, false, "Prediction trading not configured in agent config");
+            break;
+          }
+          if (this.riskUniverse < 2) {
+            this.relay?.sendCommandResult(cmd.id, false, `Risk universe ${this.riskUniverse} too low (need >= 2)`);
+            break;
+          }
+          try {
+            await this.initializePrediction();
+            if (this.predictionConnected) {
+              this.relay?.sendCommandResult(cmd.id, true, "Polymarket connected");
+              this.relay?.sendMessage(
+                "system",
+                "success",
+                "Polymarket Enabled",
+                'Polymarket infrastructure connected. Use "Start Prediction Trading" to begin a dedicated prediction cycle.'
+              );
+            } else {
+              this.relay?.sendCommandResult(cmd.id, false, "Failed to connect to Polymarket");
             }
           } catch (error) {
             const msg = error instanceof Error ? error.message : String(error);
-            this.relay?.sendCommandResult(cmd.id, false, `Hyperliquid init failed: ${msg}`);
+            this.relay?.sendCommandResult(cmd.id, false, `Polymarket init failed: ${msg}`);
           }
           this.sendRelayStatus();
           break;
-        case "disable_hyperliquid":
-          if (!this.perpConnected) {
-            this.relay?.sendCommandResult(cmd.id, true, "Hyperliquid already disconnected");
+        case "disable_polymarket":
+          if (!this.predictionConnected) {
+            this.relay?.sendCommandResult(cmd.id, true, "Polymarket already disconnected");
             break;
           }
-          this.perpTradingActive = false;
-          if (this.perpWebSocket) {
-            this.perpWebSocket.disconnect();
-          }
-          if (this.perpRecorder) {
-            this.perpRecorder.stop();
-          }
-          this.perpConnected = false;
-          console.log("Hyperliquid disabled via command center");
-          this.relay?.sendCommandResult(cmd.id, true, "Hyperliquid disconnected");
+          this.predictionTradingActive = false;
+          this.predictionConnected = false;
+          this.predictionClient = null;
+          this.predictionOrders = null;
+          this.predictionPositions = null;
+          this.predictionRecorder = null;
+          this.predictionFunding = null;
+          this.predictionBrowser = null;
+          console.log("Polymarket disabled via command center");
+          this.relay?.sendCommandResult(cmd.id, true, "Polymarket disconnected");
           this.relay?.sendMessage(
             "system",
             "info",
-            "Hyperliquid Disabled",
-            "Hyperliquid infrastructure disconnected. Agent will trade spot only."
+            "Polymarket Disabled",
+            "Polymarket infrastructure disconnected."
           );
           this.sendRelayStatus();
           break;
-        case "start_perp_trading":
-          if (!this.perpConnected) {
-            this.relay?.sendCommandResult(cmd.id, false, "Hyperliquid not connected. Enable Hyperliquid first.");
+        case "start_prediction_trading":
+          if (!this.predictionConnected) {
+            this.relay?.sendCommandResult(cmd.id, false, "Polymarket not connected. Enable Polymarket first.");
             break;
           }
-          if (this.perpTradingActive) {
-            this.relay?.sendCommandResult(cmd.id, true, "Perp trading already active");
+          if (this.predictionTradingActive) {
+            this.relay?.sendCommandResult(cmd.id, true, "Prediction trading already active");
             break;
           }
-          this.perpTradingActive = true;
+          this.predictionTradingActive = true;
           if (this.mode !== "trading") {
             this.mode = "trading";
             this.isRunning = true;
           }
-          console.log("Perp trading mandated via command center");
-          this.relay?.sendCommandResult(cmd.id, true, "Perp trading cycle active");
+          console.log("Prediction trading mandated via command center");
+          this.relay?.sendCommandResult(cmd.id, true, "Prediction trading cycle active");
           this.relay?.sendMessage(
             "system",
             "success",
-            "Perp Trading Active",
-            "Dedicated perp trading cycle is now running every interval."
+            "Prediction Trading Active",
+            "Dedicated prediction trading cycle is now running every interval."
           );
           this.sendRelayStatus();
           break;
-        case "stop_perp_trading":
-          if (!this.perpTradingActive) {
-            this.relay?.sendCommandResult(cmd.id, true, "Perp trading already stopped");
+        case "stop_prediction_trading":
+          if (!this.predictionTradingActive) {
+            this.relay?.sendCommandResult(cmd.id, true, "Prediction trading already stopped");
             break;
           }
-          this.perpTradingActive = false;
-          console.log("Perp trading cycle stopped via command center");
-          this.relay?.sendCommandResult(cmd.id, true, "Perp trading cycle stopped");
+          this.predictionTradingActive = false;
+          console.log("Prediction trading cycle stopped via command center");
+          this.relay?.sendCommandResult(cmd.id, true, "Prediction trading cycle stopped");
           this.relay?.sendMessage(
             "system",
             "info",
-            "Perp Trading Stopped",
-            "Dedicated perp cycle stopped. Hyperliquid remains connected \u2014 strategy can still include perp signals."
+            "Prediction Trading Stopped",
+            "Dedicated prediction cycle stopped. Polymarket remains connected."
           );
           this.sendRelayStatus();
           break;
-        case "update_perp_params": {
-          const perpParams = cmd.params || {};
-          let perpUpdated = false;
-          if (this.config.perp && perpParams.maxLeverage !== void 0) {
-            const val = Number(perpParams.maxLeverage);
-            if (val >= 1 && val <= 50) {
-              this.config.perp.maxLeverage = val;
-              perpUpdated = true;
+        case "update_prediction_params": {
+          const predParams = cmd.params || {};
+          let predUpdated = false;
+          if (this.config.prediction && predParams.maxNotionalUSD !== void 0) {
+            const val = Number(predParams.maxNotionalUSD);
+            if (val >= 1) {
+              this.config.prediction.maxNotionalUSD = val;
+              predUpdated = true;
             }
           }
-          if (this.config.perp && perpParams.maxNotionalUSD !== void 0) {
-            const val = Number(perpParams.maxNotionalUSD);
-            if (val >= 100) {
-              this.config.perp.maxNotionalUSD = val;
-              perpUpdated = true;
+          if (this.config.prediction && predParams.maxTotalExposureUSD !== void 0) {
+            const val = Number(predParams.maxTotalExposureUSD);
+            if (val >= 1) {
+              this.config.prediction.maxTotalExposureUSD = val;
+              predUpdated = true;
             }
           }
-          if (perpUpdated) {
-            this.relay?.sendCommandResult(cmd.id, true, "Perp parameters updated");
+          if (predUpdated) {
+            this.relay?.sendCommandResult(cmd.id, true, "Prediction parameters updated");
             this.relay?.sendMessage(
               "config_updated",
               "info",
-              "Perp Params Updated",
-              `Max leverage: ${this.config.perp?.maxLeverage}x, Max notional: $${this.config.perp?.maxNotionalUSD?.toLocaleString()}`
+              "Prediction Params Updated",
+              `Max notional: $${this.config.prediction?.maxNotionalUSD}, Max exposure: $${this.config.prediction?.maxTotalExposureUSD}`
             );
           } else {
-            this.relay?.sendCommandResult(cmd.id, false, "No valid perp parameters provided");
+            this.relay?.sendCommandResult(cmd.id, false, "No valid prediction parameters provided");
+          }
+          break;
+        }
+        case "create_prediction_vault": {
+          if (!this.predictionVaultManager) {
+            this.relay?.sendCommandResult(cmd.id, false, "Vault mode not configured. Set prediction.vault config.");
+            break;
+          }
+          if (this.predictionVaultManager.hasVault) {
+            const addr = this.predictionVaultManager.getVaultAddress();
+            this.relay?.sendCommandResult(cmd.id, true, `Vault already exists: ${addr}`);
+            break;
+          }
+          try {
+            const vaultParams = cmd.params || {};
+            const seedAmount = BigInt(Number(vaultParams.seedAmount || 100) * 1e6);
+            const name = vaultParams.name || `Prediction Fund ${this.config.agentId}`;
+            const symbol = vaultParams.symbol || `pxAGT${this.config.agentId}`;
+            const result = await this.predictionVaultManager.createVault(seedAmount, name, symbol);
+            if (result.success) {
+              this.relay?.sendCommandResult(cmd.id, true, `Vault created: ${result.vaultAddress}`);
+              this.relay?.sendMessage(
+                "prediction_vault_created",
+                "success",
+                "Prediction Vault Created",
+                `Vault deployed at ${result.vaultAddress} with ${Number(seedAmount) / 1e6} USDC seed`,
+                { vaultAddress: result.vaultAddress, txHash: result.txHash }
+              );
+            } else {
+              this.relay?.sendCommandResult(cmd.id, false, result.error || "Vault creation failed");
+            }
+          } catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.relay?.sendCommandResult(cmd.id, false, `Vault creation failed: ${msg}`);
+          }
+          this.sendRelayStatus();
+          break;
+        }
+        case "deposit_prediction_vault": {
+          if (!this.predictionVaultManager?.hasVault) {
+            this.relay?.sendCommandResult(cmd.id, false, "No prediction vault exists");
+            break;
+          }
+          try {
+            const amount = BigInt(Number(cmd.params?.amount || 0) * 1e6);
+            if (amount <= 0n) {
+              this.relay?.sendCommandResult(cmd.id, false, "Amount must be positive");
+              break;
+            }
+            const result = await this.predictionVaultManager.deposit(amount);
+            if (result.success) {
+              this.relay?.sendCommandResult(cmd.id, true, `Deposited ${Number(amount) / 1e6} USDC`);
+              this.relay?.sendMessage(
+                "prediction_vault_deposit",
+                "success",
+                "Vault Deposit",
+                `${Number(amount) / 1e6} USDC deposited into prediction vault`,
+                { amount: Number(amount) / 1e6, txHash: result.txHash }
+              );
+            } else {
+              this.relay?.sendCommandResult(cmd.id, false, result.error || "Deposit failed");
+            }
+          } catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.relay?.sendCommandResult(cmd.id, false, `Deposit failed: ${msg}`);
+          }
+          this.sendRelayStatus();
+          break;
+        }
+        case "withdraw_prediction_vault": {
+          if (!this.predictionVaultManager?.hasVault) {
+            this.relay?.sendCommandResult(cmd.id, false, "No prediction vault exists");
+            break;
+          }
+          try {
+            const isEmergency = cmd.params?.emergency === true;
+            const result = isEmergency ? await this.predictionVaultManager.emergencyWithdraw() : await this.predictionVaultManager.withdrawAll();
+            if (result.success) {
+              this.relay?.sendCommandResult(cmd.id, true, isEmergency ? "Emergency withdrawn (penalty applied)" : "Withdrawn all shares");
+              this.relay?.sendMessage(
+                "prediction_vault_withdraw",
+                isEmergency ? "warning" : "success",
+                isEmergency ? "Emergency Withdrawal" : "Vault Withdrawal",
+                isEmergency ? "Emergency withdrawn with penalty" : "All shares redeemed from prediction vault",
+                { emergency: isEmergency, txHash: result.txHash }
+              );
+            } else {
+              this.relay?.sendCommandResult(cmd.id, false, result.error || "Withdrawal failed");
+            }
+          } catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.relay?.sendCommandResult(cmd.id, false, `Withdrawal failed: ${msg}`);
           }
+          this.sendRelayStatus();
           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");
@@ -5197,6 +8080,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).
@@ -5206,7 +8146,7 @@ var AgentRuntime = class {
     try {
       const onChain = await this.client.registry.getConfigHash(BigInt(this.config.agentId));
       if (onChain === this.pendingConfigHash) {
-        this.configHash = this.pendingConfigHash;
+        this.updateConfigHashEverywhere(this.pendingConfigHash);
         this.pendingConfigHash = null;
         console.log("Config verified on-chain! Your agent will now appear on the leaderboard.");
         this.relay?.sendMessage(
@@ -5219,6 +8159,34 @@ var AgentRuntime = class {
     } catch {
     }
   }
+  /**
+   * Periodically sync config hash from on-chain to detect external changes.
+   * This catches cases where the config was changed via the website or another
+   * session while this agent is running. Without this, all trades and recordings
+   * fail with ConfigMismatch until the agent is restarted.
+   *
+   * Called from sendRelayStatus at most every 5 minutes (timestamp-throttled).
+   */
+  lastConfigSyncAt = 0;
+  async syncConfigHashFromChain() {
+    try {
+      const onChain = await this.client.registry.getConfigHash(BigInt(this.config.agentId));
+      if (onChain && onChain !== this.configHash && onChain !== "0x0000000000000000000000000000000000000000000000000000000000000000") {
+        console.log(`Config hash changed on-chain (external update detected): ${this.configHash} \u2192 ${onChain}`);
+        this.updateConfigHashEverywhere(onChain);
+      }
+    } catch {
+    }
+  }
+  /**
+   * Propagate a config hash update to runtime + all consumers (recorders).
+   * Ensures executor, perp recorder, and prediction recorder all stay in sync.
+   */
+  updateConfigHashEverywhere(newHash) {
+    this.configHash = newHash;
+    this.perpRecorder?.updateConfigHash(newHash);
+    this.predictionRecorder?.updateConfigHash(newHash);
+  }
   /**
    * Send current status to the relay
    */
@@ -5229,6 +8197,11 @@ var AgentRuntime = class {
       this.lastConfigCheckAt = Date.now();
       this.checkPendingConfigApproval();
     }
+    const CONFIG_SYNC_INTERVAL_MS = 3e5;
+    if (!this.pendingConfigHash && Date.now() - this.lastConfigSyncAt >= CONFIG_SYNC_INTERVAL_MS) {
+      this.lastConfigSyncAt = Date.now();
+      this.syncConfigHashFromChain();
+    }
     const vaultConfig = this.config.vault || { policy: "disabled" };
     const status = {
       mode: this.mode,
@@ -5266,7 +8239,43 @@ var AgentRuntime = class {
         effectiveLeverage: this.cachedPerpLeverage,
         pendingRecords: this.perpRecorder?.pendingRetries ?? 0
       } : void 0,
+      prediction: this.predictionConnected ? {
+        enabled: true,
+        trading: this.predictionTradingActive,
+        polygonUSDC: this.cachedPredictionPolygonUSDC,
+        baseUSDC: this.cachedPredictionBaseUSDC,
+        totalExposure: this.cachedPredictionExposure,
+        openMarkets: this.cachedPredictionOpenMarkets,
+        openPositions: this.cachedPredictionOpenPositions,
+        unrealizedPnl: this.cachedPredictionUnrealizedPnl,
+        pendingFees: this.predictionRecorder?.pendingFeesUSD ?? 0,
+        pendingRecords: this.predictionRecorder?.pendingRetries ?? 0,
+        vault: this.cachedPredictionVaultStatus
+      } : 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
@@ -5285,28 +8294,71 @@ var AgentRuntime = class {
       }).catch(() => {
       });
     }
+    if (this.predictionConnected && this.predictionPositions && this.predictionFunding) {
+      this.predictionPositions.getAccountSummary().then((summary) => {
+        this.cachedPredictionExposure = summary.totalExposure;
+        this.cachedPredictionOpenMarkets = summary.openMarketCount;
+        this.cachedPredictionOpenPositions = summary.openPositionCount;
+        this.cachedPredictionUnrealizedPnl = summary.totalUnrealizedPnl;
+      }).catch(() => {
+      });
+      this.predictionFunding.getPolygonUSDCBalance().then((bal) => {
+        this.cachedPredictionPolygonUSDC = Number(bal) / 1e6;
+      }).catch(() => {
+      });
+      this.predictionFunding.getBaseUSDCBalance().then((bal) => {
+        this.cachedPredictionBaseUSDC = Number(bal) / 1e6;
+      }).catch(() => {
+      });
+      if (this.predictionVaultManager?.hasVault) {
+        this.predictionVaultManager.getVaultStatus().then((vs) => {
+          if (vs.hasVault) {
+            this.cachedPredictionVaultStatus = {
+              address: vs.vaultAddress,
+              totalAssets: Number(vs.totalAssets) / 1e6,
+              sharePrice: vs.sharePrice,
+              cachedCtfValue: Number(vs.cachedCtfValue) / 1e6,
+              currentExposureBps: vs.currentExposureBps,
+              circuitBreakerActive: vs.circuitBreakerActive,
+              isPaused: vs.isPaused
+            };
+          }
+        }).catch(() => {
+        });
+      }
+    }
   }
   /**
    * 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);
@@ -5337,74 +8389,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) {
@@ -5413,6 +8524,15 @@ var AgentRuntime = class {
         this.relay?.sendMessage("system", "error", "Perp Cycle Error", message);
       }
     }
+    if (!isPaper && this.predictionConnected && this.predictionTradingActive) {
+      try {
+        await this.runPredictionCycle();
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error("Error in prediction cycle:", message);
+        this.relay?.sendMessage("system", "error", "Prediction Cycle Error", message);
+      }
+    }
     this.sendRelayStatus();
   }
   /**
@@ -5473,6 +8593,101 @@ var AgentRuntime = class {
       }
     }
   }
+  /**
+   * Run a single prediction market trading cycle.
+   * Fetches active markets, positions, calls prediction strategy, executes signals.
+   * Fills are recorded on Base via Router.recordPerpTrade() with POLY: prefix.
+   */
+  async runPredictionCycle() {
+    if (!this.predictionClient || !this.predictionOrders || !this.predictionPositions || !this.predictionRecorder || !this.predictionBrowser || !this.predictionConnected) return;
+    const predictionConfig = this.config.prediction;
+    if (!predictionConfig?.enabled) return;
+    console.log("  [POLY] Running prediction cycle...");
+    try {
+      const newFills = await this.predictionOrders.pollNewFills();
+      if (newFills.length > 0) {
+        console.log(`  [POLY] ${newFills.length} new fill(s) detected`);
+        for (const fill of newFills) {
+          this.predictionPositions.processFill(fill);
+          const result = await this.predictionRecorder.recordFill(fill);
+          if (result.success) {
+            this.relay?.sendMessage(
+              "prediction_fill",
+              "success",
+              "Prediction Fill",
+              `${fill.side} ${fill.size} @ $${parseFloat(fill.price).toFixed(2)} \u2014 market ${fill.marketConditionId.slice(0, 12)}...`,
+              { tradeId: fill.tradeId, side: fill.side, size: fill.size, price: fill.price, txHash: result.txHash }
+            );
+          }
+        }
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn("  [POLY] Fill polling failed:", message);
+    }
+    const account = await this.predictionPositions.getAccountSummary();
+    const positions = await this.predictionPositions.getPositions();
+    console.log(`  [POLY] Polygon USDC: $${account.polygonUSDC.toFixed(2)}, Positions: ${positions.length}, Exposure: $${account.totalExposure.toFixed(2)}`);
+    if (!this.predictionStrategy) {
+      return;
+    }
+    let markets;
+    try {
+      const category = predictionConfig.allowedCategories?.[0];
+      markets = await this.predictionBrowser.getActiveMarkets({
+        limit: 50,
+        category
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error("  [POLY] Market fetch error:", message);
+      return;
+    }
+    let signals;
+    try {
+      signals = await this.predictionStrategy(
+        markets,
+        positions,
+        account,
+        this.llm,
+        this.config
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error("  [POLY] Strategy error:", message);
+      return;
+    }
+    console.log(`  [POLY] Strategy generated ${signals.length} signals`);
+    for (const signal of signals) {
+      if (signal.action === "hold") continue;
+      const result = await this.predictionOrders.executeSignal(signal);
+      if (result.success) {
+        console.log(`  [POLY] Order placed: ${signal.action} "${signal.marketQuestion.slice(0, 50)}..." \u2014 ${result.status}`);
+      } else {
+        console.warn(`  [POLY] Order failed: ${signal.action} \u2014 ${result.error}`);
+      }
+    }
+    const pendingFees = this.predictionRecorder.pendingFeesUSD;
+    const threshold = predictionConfig.feeBridgeThresholdUSD ?? 10;
+    if (pendingFees >= threshold && this.predictionFunding) {
+      console.log(`  [POLY] Bridging $${pendingFees.toFixed(2)} in accumulated fees to Base...`);
+      const feeAmount = BigInt(Math.floor(pendingFees * 1e6));
+      try {
+        const bridgeResult = await this.predictionFunding.withdrawToBase(feeAmount, (step) => {
+          console.log(`  [POLY] Fee bridge: ${step}`);
+        });
+        if (bridgeResult.success) {
+          this.predictionRecorder.resetAccumulatedFees();
+          console.log(`  [POLY] Fee bridge complete: $${pendingFees.toFixed(2)} \u2192 Base`);
+        } else {
+          console.warn(`  [POLY] Fee bridge failed: ${bridgeResult.error}`);
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`  [POLY] Fee bridge error: ${message}`);
+      }
+    }
+  }
   /**
    * Check if ETH balance is below threshold and notify.
    * Returns true if trading should continue, false if ETH is critically low.
@@ -5524,6 +8739,14 @@ var AgentRuntime = class {
     if (this.perpRecorder) {
       this.perpRecorder.stop();
     }
+    this.predictionConnected = false;
+    this.predictionTradingActive = false;
+    if (this.predictionVaultManager) {
+      this.predictionVaultManager.stop();
+    }
+    if (this.predictionRecorder) {
+      this.predictionRecorder.stop();
+    }
     if (this.relay) {
       this.relay.disconnect();
     }
@@ -5541,8 +8764,8 @@ var AgentRuntime = class {
    * for Frontier agents trading outside the whitelist) stay visible.
    */
   getTokensToTrack() {
-    const base6 = this.config.allowedTokens || this.getDefaultTokens();
-    const baseSet = new Set(base6.map((t) => t.toLowerCase()));
+    const base8 = this.config.allowedTokens || this.getDefaultTokens();
+    const baseSet = new Set(base8.map((t) => t.toLowerCase()));
     const trackedPositions = this.positionTracker.getPositions();
     const extras = [];
     for (const pos of trackedPositions) {
@@ -5565,7 +8788,7 @@ var AgentRuntime = class {
       console.log(`Auto-tracking ${extras.length} additional token(s) from position history`);
     }
     const resolver = this.marketData.getResolver();
-    const allTokens = [...base6, ...extras];
+    const allTokens = [...base8, ...extras];
     const filtered = allTokens.filter((t) => !resolver.isUnresolvable(t.toLowerCase()));
     const dropped = allTokens.length - filtered.length;
     if (dropped > 0) {
@@ -5719,8 +8942,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;
@@ -5787,10 +9010,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");
@@ -5820,9 +9043,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;
@@ -5832,10 +9055,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}`);
   }
@@ -5861,9 +9084,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;
     }
@@ -5882,8 +9105,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) {
@@ -5902,7 +9125,7 @@ function loadSecureEnv(basePath, passphrase) {
 }
 
 // src/index.ts
-var AGENT_VERSION = "0.1.38";
+var AGENT_VERSION = "0.1.40";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AGENT_VERSION,
@@ -5920,6 +9143,8 @@ var AGENT_VERSION = "0.1.38";
   HyperliquidWebSocket,
   LLMConfigSchema,
   LLMProviderSchema,
+  MARKET_CATEGORIES,
+  MarketBrowser,
   MarketDataService,
   MistralAdapter,
   OllamaAdapter,
@@ -5928,8 +9153,14 @@ var AGENT_VERSION = "0.1.38";
   PerpConfigSchema,
   PerpOnboarding,
   PerpTradeRecorder,
+  PolymarketClient,
   PositionManager,
   PositionTracker,
+  PredictionConfigSchema,
+  PredictionFunding,
+  PredictionOrderManager,
+  PredictionPositionManager,
+  PredictionTradeRecorder,
   RelayClient,
   RelayConfigSchema,
   RiskManager,
@@ -5941,9 +9172,12 @@ var AGENT_VERSION = "0.1.38";
   VaultConfigSchema,
   VaultManager,
   VaultPolicySchema,
+  calculatePredictionFee,
   createLLMAdapter,
   createSampleConfig,
+  decodePredictionInstrument,
   decryptEnvFile,
+  encodePredictionInstrument,
   encryptEnvFile,
   fillHashToBytes32,
   fillOidToBytes32,
@@ -5953,6 +9187,8 @@ var AGENT_VERSION = "0.1.38";
   loadConfig,
   loadSecureEnv,
   loadStrategy,
+  orderIdToBytes32,
+  tradeIdToBytes32,
   validateConfig,
   validateStrategy
 });