@exagent/agent 0.3.5 → 0.3.7

package/src/runtime.ts

@@ -1,1755 +0,0 @@
-import type {
-  LLMAdapter,
-  StrategyFunction,
-  AgentMode,
-  AgentStatusPayload,
-  RelayCommand,
-  TradeSignal,
-} from '@exagent/sdk';
-import { createWalletClient, createPublicClient, http, formatUnits } from 'viem';
-import { privateKeyToAccount } from 'viem/accounts';
-import { arbitrum } from 'viem/chains';
-import { getChainConfig, applyRpcOverrides } from './chains.js';
-import { ERC20_ABI } from './spot/types.js';
-import { RelayClient } from './relay.js';
-import { SignalReporter } from './signal.js';
-import { FileStore } from './store.js';
-import { PositionTracker } from './position-tracker.js';
-import { createLLMAdapter } from './llm/index.js';
-import { BaseLLMAdapter } from './llm/base.js';
-import { loadStrategy } from './strategy/index.js';
-import { RiskManager } from './trading/risk.js';
-import { MarketDataService } from './trading/market.js';
-import { PaperExecutor } from './paper/index.js';
-import type { RuntimeConfig } from './config.js';
-import { getLogger, configureLogger } from './logger.js';
-import type { LogLevel } from './logger.js';
-import { DiagnosticsCollector } from './diagnostics.js';
-import type { CycleTimings } from './diagnostics.js';
-import { scrubSecrets } from './scrub-secrets.js';
-
-// Hyperliquid
-import { HyperliquidClient } from './perp/client.js';
-import { HyperliquidSigner } from './perp/signer.js';
-import { HyperliquidOrderManager } from './perp/orders.js';
-import { HyperliquidPositionManager } from './perp/positions.js';
-import { HyperliquidWebSocket } from './perp/websocket.js';
-import type { PerpFill, PerpConfig } from './perp/types.js';
-
-// Polymarket
-import { PolymarketClient } from './prediction/client.js';
-import { PolymarketOrderManager } from './prediction/order-manager.js';
-import { encodePredictionInstrument } from './prediction/types.js';
-import type { PredictionConfig } from './prediction/types.js';
-
-// Spot DEX
-import { SpotSwapManager } from './spot/swap-manager.js';
-import type { SpotConfig } from './spot/types.js';
-
-// Bridge
-import { BridgeManager } from './bridge/bridge-manager.js';
-import type { BridgeConfig } from './bridge/types.js';
-
-import { createRequire } from 'module';
-const _require = createRequire(import.meta.url);
-let SDK_VERSION = '0.3.0';
-try { SDK_VERSION = _require('../package.json').version; } catch {}
-
-/** Number of consecutive cycle failures before switching to idle */
-const MAX_CONSECUTIVE_FAILURES = 3;
-
-function getCycleErrorHint(category: string, msg: string): string | null {
-  const lower = msg.toLowerCase();
-  if (category === 'auth' || lower.includes('401') || lower.includes('unauthorized') || lower.includes('invalid api key') || lower.includes('authentication'))
-    return 'Check your LLM API key — update via npx exagent setup';
-  if (category === 'network' || lower.includes('econnrefused') || lower.includes('enotfound') || lower.includes('fetch failed') || lower.includes('timeout'))
-    return 'Network connectivity issue — check your internet connection';
-  if (category === 'venue' || lower.includes('hyperliquid') || lower.includes('polymarket') || lower.includes('venue'))
-    return 'Venue API error — the venue may be experiencing issues';
-  if (category === 'strategy' || lower.includes('invalid') && lower.includes('signal') || lower.includes('strategy'))
-    return 'Strategy returned invalid output — check your strategy file';
-  if (lower.includes('rate limit') || lower.includes('429'))
-    return 'Rate limited — consider increasing tradingIntervalMs';
-  return null;
-}
-
-export class AgentRuntime {
-  private config: RuntimeConfig;
-  private relay: RelayClient;
-  private signal: SignalReporter;
-  private store: FileStore;
-  private positions: PositionTracker;
-  private llm: LLMAdapter;
-  private strategy: StrategyFunction | null = null;
-  private risk: RiskManager;
-  private market: MarketDataService;
-  private paper: PaperExecutor | null = null;
-
-  // Venue clients
-  private hlClient: HyperliquidClient | null = null;
-  private hlSigner: HyperliquidSigner | null = null;
-  private hlOrders: HyperliquidOrderManager | null = null;
-  private hlPositions: HyperliquidPositionManager | null = null;
-  private hlWs: HyperliquidWebSocket | null = null;
-  private pmClient: PolymarketClient | null = null;
-  private pmOrders: PolymarketOrderManager | null = null;
-  private spotManager: SpotSwapManager | null = null;
-  private bridgeManager: BridgeManager | null = null;
-  private walletAddress: string | null = null;
-
-  private mode: AgentMode = 'idle';
-  private cycleCount = 0;
-  private lastCycleAt = 0;
-  private tradingInterval: ReturnType<typeof setInterval> | null = null;
-  private running = false;
-  private cycleInProgress = false;
-  private consecutiveCycleFailures = 0;
-  /** The mode the agent was in before pausing (for resume) */
-  private modeBeforePause: AgentMode | null = null;
-  private diagnostics: DiagnosticsCollector;
-
-  constructor(config: RuntimeConfig) {
-    this.config = config;
-
-    // Configure structured logger from config
-    if (config.logging) {
-      configureLogger({
-        minLevel: config.logging.level as LogLevel,
-        json: config.logging.json,
-      });
-    }
-
-    // Apply RPC overrides before any chain config usage
-    if (config.rpcOverrides) {
-      applyRpcOverrides(config.rpcOverrides);
-    }
-
-    this.store = new FileStore(`data/${config.agentId}-store.json`);
-    this.positions = new PositionTracker(this.store);
-    this.market = new MarketDataService(30000, config.apiUrl);
-    this.risk = new RiskManager(
-      {
-        maxPositionSizeBps: config.trading.maxPositionSizeBps,
-        maxDailyLossBps: config.trading.maxDailyLossBps,
-        maxConcurrentPositions: config.trading.maxConcurrentPositions,
-        maxSlippageBps: config.trading.maxSlippageBps,
-        minTradeValueUSD: config.trading.minTradeValueUSD,
-      },
-      config.trading.initialCapitalUSD,
-    );
-
-    this.diagnostics = new DiagnosticsCollector();
-    this.llm = createLLMAdapter(config.llm);
-    this.configureLLMAdapter(this.llm);
-
-    this.relay = new RelayClient({
-      url: config.relay.url,
-      agentId: config.agentId,
-      token: config.apiToken,
-      heartbeatIntervalMs: config.relay.heartbeatIntervalMs,
-      reconnectMaxAttempts: config.relay.reconnectMaxAttempts,
-      onCommand: (cmd) => this.handleCommand(cmd),
-      onConnected: () => {
-        getLogger().info('relay', 'Connected to command center');
-        this.sendStatus();
-      },
-      onDisconnected: () => {
-        getLogger().warn('relay', 'Disconnected from command center');
-      },
-      onReconnected: () => {
-        getLogger().info('relay', 'Reconnected to command center — flushing signal queue');
-        this.signal.flushQueue();
-        this.diagnostics.recordSignalFlush(this.signal.queueSize);
-      },
-    });
-
-    // Pass store to SignalReporter for queue persistence
-    this.signal = new SignalReporter(this.relay, this.store);
-
-    if (config.trading.mode === 'paper') {
-      this.paper = new PaperExecutor(config.trading.initialCapitalUSD ?? 10000);
-    }
-  }
-
-  async start(): Promise<void> {
-    const log = getLogger();
-
-    log.info('runtime', 'Starting agent', {
-      agentId: this.config.agentId,
-      mode: this.config.trading.mode,
-      provider: this.config.llm.provider,
-      model: this.config.llm.model,
-    });
-
-    if (this.config.rpcOverrides && Object.keys(this.config.rpcOverrides).length > 0) {
-      log.info('runtime', 'RPC overrides applied', { chains: Object.keys(this.config.rpcOverrides) });
-    }
-
-    // Load strategy
-    try {
-      this.strategy = await loadStrategy(this.config.strategy);
-      log.info('runtime', 'Strategy loaded');
-    } catch (err) {
-      log.error('runtime', `Failed to load strategy: ${(err as Error).message}`);
-      this.strategy = null;
-    }
-
-    // Initialize venue clients (only in live mode)
-    if (this.config.trading.mode === 'live') {
-      await this.initializeVenues();
-    }
-
-    // Connect to relay
-    try {
-      await this.relay.connect();
-      this.signal.reportInfo('Agent Started', `Agent ${this.config.agentId} connected to command center`);
-
-      // Flush any persisted signals from a previous crash
-      if (this.signal.queueSize > 0) {
-        this.signal.flushQueue();
-      }
-    } catch (err) {
-      log.error('runtime', `Failed to connect to relay: ${(err as Error).message}`);
-      log.info('runtime', 'Will retry in background...');
-    }
-
-    this.running = true;
-    this.mode = 'idle';
-    this.sendStatus();
-
-    // Auto-start trading if configured
-    if (this.config.trading.mode === 'paper' || this.config.trading.mode === 'live') {
-      this.startTrading();
-    }
-
-    // Keep process alive
-    process.on('SIGTERM', () => this.stop());
-    process.on('SIGINT', () => this.stop());
-  }
-
-  async stop(): Promise<void> {
-    const log = getLogger();
-    log.info('runtime', 'Stopping agent', { agentId: this.config.agentId });
-    this.running = false;
-    this.stopTrading();
-
-    // Disconnect venue WebSockets
-    if (this.hlWs) {
-      this.hlWs.disconnect();
-    }
-
-    this.signal.reportInfo('Agent Stopped', `Agent ${this.config.agentId} shutting down`);
-    this.relay.disconnect();
-    log.info('runtime', 'Agent stopped');
-    process.exit(0);
-  }
-
-  private configureLLMAdapter(adapter: LLMAdapter): void {
-    if (this.config.llmBudget?.maxDailyTokens && adapter instanceof BaseLLMAdapter) {
-      adapter.setMaxDailyTokens(this.config.llmBudget.maxDailyTokens);
-    }
-
-    if (adapter instanceof BaseLLMAdapter) {
-      adapter.setCallRecordCallback((record) => {
-        this.diagnostics.recordLLMCall(record);
-      });
-    }
-  }
-
-  private teardownVenues(): void {
-    if (this.hlWs) {
-      this.hlWs.disconnect();
-    }
-
-    this.hlWs = null;
-    this.hlClient = null;
-    this.hlSigner = null;
-    this.hlOrders = null;
-    this.hlPositions = null;
-    this.pmClient = null;
-    this.pmOrders = null;
-    this.spotManager = null;
-    this.bridgeManager = null;
-    this.walletAddress = null;
-  }
-
-  private async waitForCycleCompletion(timeoutMs: number = 30000): Promise<void> {
-    let waitedMs = 0;
-    while (this.cycleInProgress && waitedMs < timeoutMs) {
-      await new Promise((resolve) => setTimeout(resolve, 100));
-      waitedMs += 100;
-    }
-  }
-
-  private getConfiguredSpotVenue(): 'aerodrome' | 'uniswap' {
-    return this.config.venues?.spot?.defaultChain === 'base' ? 'aerodrome' : 'uniswap';
-  }
-
-  private normalizeVenueForExecution(venue?: string): string | undefined {
-    if (!venue) return undefined;
-
-    if (venue === 'hyperliquid_spot') {
-      return this.getConfiguredSpotVenue();
-    }
-
-    if (venue === 'sushiswap') {
-      return 'uniswap';
-    }
-
-    return venue;
-  }
-
-  private isVenueConfigured(venue: string): boolean {
-    const normalized = this.normalizeVenueForExecution(venue) ?? venue;
-
-    switch (normalized) {
-      case 'hyperliquid_perp':
-      case 'hyperliquid_deposit':
-      case 'hyperliquid_withdraw':
-        return this.config.venues?.hyperliquid_perp?.enabled === true;
-      case 'polymarket':
-        return this.config.venues?.polymarket?.enabled === true;
-      case 'uniswap':
-      case 'aerodrome':
-        return this.config.venues?.spot?.enabled === true;
-      case 'across':
-        return this.config.venues?.bridge?.enabled === true;
-      default:
-        return false;
-    }
-  }
-
-  private canExecuteVenue(venue: string): boolean {
-    const normalized = this.normalizeVenueForExecution(venue) ?? venue;
-    if (!this.isVenueConfigured(normalized)) {
-      return false;
-    }
-
-    if (this.paper) {
-      return true;
-    }
-
-    switch (normalized) {
-      case 'hyperliquid_perp':
-      case 'hyperliquid_deposit':
-      case 'hyperliquid_withdraw':
-        return !!this.hlOrders || !!this.hlSigner;
-      case 'polymarket':
-        return !!this.pmOrders;
-      case 'uniswap':
-      case 'aerodrome':
-        return !!this.spotManager;
-      case 'across':
-        return !!this.bridgeManager;
-      default:
-        return false;
-    }
-  }
-
-  private getPreferredExecutionVenues(): string[] {
-    const preferred = [
-      ...(this.config.strategy.venues ?? []),
-      ...(this.config.strategy.prompt?.venues ?? []),
-    ];
-
-    const normalized = preferred
-      .map((venue) => this.normalizeVenueForExecution(venue))
-      .filter((venue): venue is string => Boolean(venue));
-
-    const fallback: string[] = [];
-    if (this.config.venues?.hyperliquid_perp?.enabled) fallback.push('hyperliquid_perp');
-    if (this.config.venues?.polymarket?.enabled) fallback.push('polymarket');
-    if (this.config.venues?.spot?.enabled) fallback.push(this.getConfiguredSpotVenue());
-    if (this.config.venues?.bridge?.enabled) fallback.push('across');
-
-    return [...new Set([...normalized, ...fallback])];
-  }
-
-  private buildRuntimeVenuesFromSelection(selectedVenues: string[]): NonNullable<RuntimeConfig['venues']> {
-    const selected = new Set(selectedVenues);
-    const current = this.config.venues ?? {};
-    const spotEnabled = selectedVenues.some((venue) => ['hyperliquid_spot', 'uniswap', 'aerodrome', 'sushiswap'].includes(venue));
-    const multiChainSpot = selected.has('uniswap') || selected.has('sushiswap');
-    const defaultSpotChains = multiChainSpot
-      ? ['base', 'ethereum', 'arbitrum', 'polygon']
-      : ['base'];
-
-    return {
-      hyperliquid_perp: {
-        enabled: selected.has('hyperliquid_perp'),
-        apiUrl: current.hyperliquid_perp?.apiUrl ?? 'https://api.hyperliquid.xyz',
-        wsUrl: current.hyperliquid_perp?.wsUrl ?? 'wss://api.hyperliquid.xyz/ws',
-        maxLeverage: current.hyperliquid_perp?.maxLeverage ?? 10,
-        maxNotionalUSD: current.hyperliquid_perp?.maxNotionalUSD ?? 50000,
-        allowedInstruments: current.hyperliquid_perp?.allowedInstruments,
-      },
-      polymarket: {
-        enabled: selected.has('polymarket'),
-        clobApiUrl: current.polymarket?.clobApiUrl ?? 'https://clob.polymarket.com',
-        gammaApiUrl: current.polymarket?.gammaApiUrl ?? 'https://gamma-api.polymarket.com',
-        maxNotionalUSD: current.polymarket?.maxNotionalUSD ?? 1000,
-        maxTotalExposureUSD: current.polymarket?.maxTotalExposureUSD ?? 5000,
-        allowedCategories: current.polymarket?.allowedCategories,
-      },
-      spot: {
-        enabled: spotEnabled,
-        chains: current.spot?.chains?.length ? Array.from(new Set([...defaultSpotChains, ...current.spot.chains])) : defaultSpotChains,
-        defaultChain: current.spot?.defaultChain ?? 'base',
-        maxSlippageBps: current.spot?.maxSlippageBps ?? this.config.trading.maxSlippageBps,
-        maxSwapValueUSD: current.spot?.maxSwapValueUSD ?? 10000,
-      },
-      bridge: {
-        enabled: selected.has('across'),
-        defaultBridge: current.bridge?.defaultBridge ?? 'across',
-        maxBridgeValueUSD: current.bridge?.maxBridgeValueUSD ?? 10000,
-        fillTimeoutMs: current.bridge?.fillTimeoutMs ?? 300000,
-        pollIntervalMs: current.bridge?.pollIntervalMs ?? 2000,
-      },
-    };
-  }
-
-  private buildStrategyFallbackPrompt(strategy: {
-    name?: string;
-    description?: string;
-    category?: string;
-    venues?: string[];
-  }): string {
-    const name = strategy.name?.trim() || 'Dashboard Strategy';
-    const description = strategy.description?.trim();
-    const category = strategy.category?.trim();
-    const venues = strategy.venues?.length ? strategy.venues.join(', ') : 'any';
-
-    return [
-      `You are the "${name}" trading agent.`,
-      category ? `Strategy category: ${category}.` : null,
-      description
-        ? `Strategy description: ${description}`
-        : 'Strategy description: follow the owner-configured strategy exactly and do not improvise outside it.',
-      `Allowed venues: ${venues}.`,
-      'Stay inside the owner-configured scope. If the setup is unclear or the trade does not fit, return no trades.',
-      'Return ONLY a JSON array of trade signals.',
-    ].filter((line): line is string => Boolean(line)).join('\n');
-  }
-
-  private extractStrategyConfigFromAgentConfig(cfg: Record<string, unknown>): RuntimeConfig['strategy'] {
-    const rawStrategy = cfg.strategy as Record<string, unknown> | undefined;
-    if (!rawStrategy) {
-      return { template: 'hold' };
-    }
-
-    const venues = Array.isArray(rawStrategy.venues)
-      ? rawStrategy.venues.filter((venue): venue is string => typeof venue === 'string')
-      : undefined;
-
-    if (typeof rawStrategy.file === 'string' && rawStrategy.file.trim()) {
-      return { file: rawStrategy.file, venues };
-    }
-
-    if (typeof rawStrategy.code === 'string' && rawStrategy.code.trim()) {
-      return { code: rawStrategy.code, venues };
-    }
-
-    if (typeof rawStrategy.systemPrompt === 'string' && rawStrategy.systemPrompt.trim()) {
-      return {
-        venues,
-        prompt: {
-          name: typeof rawStrategy.name === 'string' ? rawStrategy.name : undefined,
-          systemPrompt: rawStrategy.systemPrompt,
-          venues,
-        },
-      };
-    }
-
-    if (typeof rawStrategy.template === 'string' && rawStrategy.template.trim()) {
-      return {
-        template: rawStrategy.template,
-        venues,
-      };
-    }
-
-    return {
-      venues,
-      prompt: {
-        name: typeof rawStrategy.name === 'string' ? rawStrategy.name : undefined,
-        systemPrompt: this.buildStrategyFallbackPrompt({
-          name: typeof rawStrategy.name === 'string' ? rawStrategy.name : undefined,
-          description: typeof rawStrategy.description === 'string' ? rawStrategy.description : undefined,
-          category: typeof rawStrategy.category === 'string' ? rawStrategy.category : undefined,
-          venues,
-        }),
-        venues,
-      },
-    };
-  }
-
-  private async applyExecutionMode(): Promise<void> {
-    if (this.config.trading.mode === 'paper') {
-      this.teardownVenues();
-      if (!this.paper) {
-        this.paper = new PaperExecutor(this.config.trading.initialCapitalUSD ?? 10000);
-      }
-      return;
-    }
-
-    this.paper = null;
-    this.teardownVenues();
-    await this.initializeVenues();
-  }
-
-  // ── VENUE INITIALIZATION ───────────────────────────────────
-
-  private async initializeVenues(): Promise<void> {
-    const log = getLogger();
-    const privateKey = this.config.wallet?.privateKey;
-    if (!privateKey) {
-      log.warn('runtime', 'No wallet configured — live trading disabled');
-      return;
-    }
-
-    // Derive wallet address from private key
-    const walletAccount = privateKeyToAccount(privateKey as `0x${string}`);
-    this.walletAddress = walletAccount.address;
-
-    // Initialize Hyperliquid
-    const hlConfig = this.config.venues?.hyperliquid_perp;
-    if (hlConfig?.enabled) {
-      try {
-        const account = walletAccount;
-        const walletClient = createWalletClient({
-          account,
-          chain: arbitrum,
-          transport: http(),
-        });
-
-        const perpConfig: PerpConfig = {
-          enabled: true,
-          apiUrl: hlConfig.apiUrl,
-          wsUrl: hlConfig.wsUrl,
-          maxLeverage: hlConfig.maxLeverage,
-          maxNotionalUSD: hlConfig.maxNotionalUSD,
-          allowedInstruments: hlConfig.allowedInstruments,
-        };
-
-        this.hlClient = new HyperliquidClient(perpConfig);
-        this.hlSigner = new HyperliquidSigner(walletClient);
-        this.hlOrders = new HyperliquidOrderManager(this.hlClient, this.hlSigner, perpConfig);
-        this.hlPositions = new HyperliquidPositionManager(this.hlClient, account.address);
-        this.hlWs = new HyperliquidWebSocket(perpConfig, account.address, this.hlClient);
-
-        // Fetch metadata (caches asset indices)
-        await this.hlClient.getMeta();
-
-        // Register fill callback
-        this.hlWs.onFillReceived((fill: PerpFill) => {
-          this.handleHyperliquidFill(fill);
-        });
-
-        this.hlWs.onLiquidationDetected((instrument, size) => {
-          this.signal.reportError('Liquidation Detected', `${instrument}: ${size} liquidated`);
-        });
-
-        // Connect WebSocket
-        await this.hlWs.connect();
-
-        log.info('venue', 'Hyperliquid initialized', { address: account.address });
-      } catch (err) {
-        log.error('venue', `Failed to initialize Hyperliquid: ${(err as Error).message}`);
-      }
-    }
-
-    // Initialize Polymarket
-    const pmConfig = this.config.venues?.polymarket;
-    if (pmConfig?.enabled) {
-      try {
-        const predConfig: PredictionConfig = {
-          enabled: true,
-          clobApiUrl: pmConfig.clobApiUrl,
-          gammaApiUrl: pmConfig.gammaApiUrl,
-          maxNotionalUSD: pmConfig.maxNotionalUSD,
-          maxTotalExposureUSD: pmConfig.maxTotalExposureUSD,
-          allowedCategories: pmConfig.allowedCategories,
-        };
-
-        this.pmClient = new PolymarketClient(privateKey, predConfig);
-        await this.pmClient.initialize();
-        this.pmOrders = new PolymarketOrderManager(this.pmClient, predConfig);
-
-        log.info('venue', 'Polymarket initialized');
-      } catch (err) {
-        log.error('venue', `Failed to initialize Polymarket: ${(err as Error).message}`);
-      }
-    }
-
-    // Initialize Spot DEX
-    const spotConfig = this.config.venues?.spot;
-    if (spotConfig?.enabled) {
-      try {
-        const cfg: SpotConfig = {
-          enabled: true,
-          chains: spotConfig.chains,
-          defaultChain: spotConfig.defaultChain,
-          maxSlippageBps: spotConfig.maxSlippageBps,
-          maxSwapValueUSD: spotConfig.maxSwapValueUSD,
-        };
-        this.spotManager = new SpotSwapManager(privateKey, cfg);
-        log.info('venue', 'Spot DEX initialized', { chains: spotConfig.chains });
-      } catch (err) {
-        log.error('venue', `Failed to initialize Spot DEX: ${(err as Error).message}`);
-      }
-    }
-
-    // Initialize Bridge
-    const bridgeConfig = this.config.venues?.bridge;
-    if (bridgeConfig?.enabled) {
-      try {
-        if (!this.spotManager) {
-          // Bridge needs a SpotDEXClient for approvals — create a minimal spot manager
-          const minimalSpotConfig: SpotConfig = {
-            enabled: true,
-            chains: ['base', 'ethereum', 'arbitrum', 'polygon'],
-            defaultChain: 'base',
-            maxSlippageBps: 50,
-            maxSwapValueUSD: 10_000,
-          };
-          this.spotManager = new SpotSwapManager(privateKey, minimalSpotConfig);
-        }
-
-        const cfg: BridgeConfig = {
-          enabled: true,
-          defaultBridge: bridgeConfig.defaultBridge,
-          maxBridgeValueUSD: bridgeConfig.maxBridgeValueUSD,
-          fillTimeoutMs: bridgeConfig.fillTimeoutMs,
-          pollIntervalMs: bridgeConfig.pollIntervalMs,
-        };
-        this.bridgeManager = new BridgeManager(this.spotManager.client, cfg);
-        log.info('venue', 'Bridge initialized');
-      } catch (err) {
-        log.error('venue', `Failed to initialize Bridge: ${(err as Error).message}`);
-      }
-    }
-  }
-
-  // ── TRADING LOOP ───────────────────────────────────────────
-
-  private startTrading(): void {
-    if (this.tradingInterval) return;
-
-    this.mode = this.config.trading.mode === 'paper' ? 'paper' : 'trading';
-    this.modeBeforePause = null;
-    this.consecutiveCycleFailures = 0;
-    getLogger().info('runtime', 'Trading started', { mode: this.mode, intervalMs: this.config.trading.tradingIntervalMs });
-    this.sendStatus();
-    this.signal.reportInfo('Trading Started', `Mode: ${this.mode}`);
-
-    this.runCycle();
-
-    this.tradingInterval = setInterval(() => {
-      this.runCycle();
-    }, this.config.trading.tradingIntervalMs);
-  }
-
-  private stopTrading(): void {
-    if (this.tradingInterval) {
-      clearInterval(this.tradingInterval);
-      this.tradingInterval = null;
-    }
-    this.mode = 'idle';
-    this.modeBeforePause = null;
-    this.sendStatus();
-    getLogger().info('runtime', 'Trading stopped');
-  }
-
-  private pauseTrading(): void {
-    if (this.tradingInterval) {
-      clearInterval(this.tradingInterval);
-      this.tradingInterval = null;
-    }
-    this.modeBeforePause = this.mode;
-    this.mode = 'paused';
-    this.sendStatus();
-    getLogger().info('runtime', 'Trading paused — heartbeats continue, no new cycles');
-  }
-
-  private resumeTrading(): void {
-    if (this.mode !== 'paused') return;
-
-    this.mode = this.modeBeforePause ?? (this.config.trading.mode === 'paper' ? 'paper' : 'trading');
-    this.modeBeforePause = null;
-    this.consecutiveCycleFailures = 0;
-    getLogger().info('runtime', 'Trading resumed', { mode: this.mode });
-    this.sendStatus();
-    this.signal.reportInfo('Trading Resumed', `Mode: ${this.mode}`);
-
-    this.runCycle();
-
-    this.tradingInterval = setInterval(() => {
-      this.runCycle();
-    }, this.config.trading.tradingIntervalMs);
-  }
-
-  private async runCycle(): Promise<void> {
-    const log = getLogger();
-
-    if (!this.running || !this.strategy) return;
-
-    // Prevent overlapping cycles — if a strategy call takes longer than tradingIntervalMs
-    if (this.cycleInProgress) {
-      log.warn('cycle', 'Skipping cycle — previous cycle still running');
-      return;
-    }
-
-    this.cycleInProgress = true;
-    this.cycleCount++;
-    this.lastCycleAt = Date.now();
-
-    const cycleStart = Date.now();
-    const timings: CycleTimings = {
-      totalMs: 0,
-      priceRefreshMs: 0,
-      strategyMs: 0,
-      riskFilterMs: 0,
-      executionMs: 0,
-    };
-    let signalsGenerated = 0;
-    let signalsFiltered = 0;
-    let tradesExecuted = 0;
-
-    try {
-      // Phase 1: Refresh market prices
-      const priceStart = Date.now();
-      const positionSymbols = this.positions.getPositions().map(p => p.token);
-      const commonSymbols = ['BTC', 'ETH', 'SOL', 'USDC'];
-      const allSymbols = [...new Set([...positionSymbols, ...commonSymbols])];
-      await this.market.refreshPrices(allSymbols);
-      timings.priceRefreshMs = Date.now() - priceStart;
-
-      // Get position summary with fresh prices
-      const prices = this.market.getPrices();
-      const positionSummary = this.positions.getSummary(prices);
-
-      // Phase 2: Run strategy
-      const strategyStart = Date.now();
-      const rawSignals = await this.strategy({
-        llm: this.llm,
-        market: this.market,
-        position: positionSummary,
-        store: this.store,
-        config: this.config.trading,
-        log: (msg: string) => {
-          const safe = scrubSecrets(msg);
-          log.info('strategy', safe);
-          this.signal.reportInfo('Strategy Log', safe);
-        },
-      });
-      timings.strategyMs = Date.now() - strategyStart;
-
-      // Cycle succeeded — reset consecutive failure counter
-      this.consecutiveCycleFailures = 0;
-
-      if (!Array.isArray(rawSignals) || rawSignals.length === 0) {
-        await this.pollPredictionFills();
-        timings.totalMs = Date.now() - cycleStart;
-        this.diagnostics.recordCycle({
-          cycleNumber: this.cycleCount,
-          startedAt: cycleStart,
-          timings,
-          signalsGenerated: 0,
-          signalsFiltered: 0,
-          tradesExecuted: 0,
-          success: true,
-        });
-        log.debug('cycle', 'Completed (no signals)', {
-          cycle: this.cycleCount,
-          totalMs: timings.totalMs,
-          priceMs: timings.priceRefreshMs,
-          strategyMs: timings.strategyMs,
-        });
-        this.sendStatus();
-        return;
-      }
-
-      signalsGenerated = rawSignals.length;
-
-      // Convert strategy outputs to executable signals
-      const signals = rawSignals.map(sig => this.convertToExecutableSignal(sig, prices));
-
-      // Phase 3: Risk filtering
-      const riskStart = Date.now();
-      const filtered = this.risk.filterSignals(signals, this.market, positionSummary.openPositions.length);
-      timings.riskFilterMs = Date.now() - riskStart;
-      signalsFiltered = filtered.length;
-
-      // Phase 4: Execute trades
-      const execStart = Date.now();
-      for (const sig of filtered) {
-        try {
-          await this.executeSignal(sig);
-          tradesExecuted++;
-        } catch (err) {
-          const errMsg = (err as Error).message;
-          log.error('venue', `Trade execution error: ${errMsg}`, { symbol: sig.symbol, venue: sig.venue });
-          this.signal.reportError('Trade Error', errMsg);
-          this.diagnostics.recordError(err as Error, 'venue');
-        }
-      }
-      timings.executionMs = Date.now() - execStart;
-
-      // Poll Polymarket fills
-      await this.pollPredictionFills();
-
-      timings.totalMs = Date.now() - cycleStart;
-      this.diagnostics.recordCycle({
-        cycleNumber: this.cycleCount,
-        startedAt: cycleStart,
-        timings,
-        signalsGenerated,
-        signalsFiltered,
-        tradesExecuted,
-        success: true,
-      });
-
-      log.info('cycle', 'Completed', {
-        cycle: this.cycleCount,
-        totalMs: timings.totalMs,
-        priceMs: timings.priceRefreshMs,
-        strategyMs: timings.strategyMs,
-        riskMs: timings.riskFilterMs,
-        execMs: timings.executionMs,
-        signals: signalsGenerated,
-        filtered: signalsFiltered,
-        executed: tradesExecuted,
-      });
-    } catch (err) {
-      const errMsg = (err as Error).message;
-      timings.totalMs = Date.now() - cycleStart;
-
-      const categorized = this.diagnostics.recordError(err as Error);
-      const hint = getCycleErrorHint(categorized.category, errMsg);
-      log.error('cycle', `Cycle error: ${errMsg}${hint ? ` — ${hint}` : ''}`, {
-        cycle: this.cycleCount,
-        totalMs: timings.totalMs,
-        category: categorized.category,
-      });
-      this.signal.reportError('Cycle Error', `${errMsg}${hint ? ` — ${hint}` : ''}`);
-
-      this.diagnostics.recordCycle({
-        cycleNumber: this.cycleCount,
-        startedAt: cycleStart,
-        timings,
-        signalsGenerated,
-        signalsFiltered,
-        tradesExecuted,
-        success: false,
-        error: errMsg,
-      });
-
-      // Only switch to idle on persistent failures (3 consecutive cycle failures)
-      this.consecutiveCycleFailures++;
-      if (this.consecutiveCycleFailures >= MAX_CONSECUTIVE_FAILURES) {
-        log.error('runtime', `${MAX_CONSECUTIVE_FAILURES} consecutive cycle failures — switching to idle`);
-        this.signal.reportError('Trading Halted', `${MAX_CONSECUTIVE_FAILURES} consecutive cycle failures. Last: ${errMsg}`);
-        this.stopTrading();
-      }
-    } finally {
-      this.cycleInProgress = false;
-    }
-
-    this.sendStatus();
-  }
-
-  // ── SIGNAL EXECUTION ───────────────────────────────────────
-
-  private async executeSignal(sig: TradeSignal): Promise<void> {
-    const venue = sig.venue ? this.normalizeVenueForExecution(sig.venue) ?? sig.venue : sig.venue;
-    const signal = venue && venue !== sig.venue
-      ? { ...sig, venue }
-      : sig;
-
-    if (signal.venue && !this.isVenueConfigured(signal.venue)) {
-      getLogger().warn('runtime', `Venue "${signal.venue}" is not enabled in config — signal dropped`, { symbol: signal.symbol });
-      this.signal.reportInfo('Signal Dropped', `${signal.symbol}: venue ${signal.venue} is not enabled in this agent config.`);
-      return;
-    }
-
-    if (this.paper) {
-      // Paper trading
-      const trade = this.paper.execute(signal, this.market);
-      if (trade) {
-        // Record realized PnL for daily loss circuit breaker
-        this.risk.recordTrade(trade.pnl ?? 0, trade.fee);
-        if (this.risk.isDailyLossLimitHit()) {
-          getLogger().warn('risk', 'Daily loss limit hit (paper) — stopping trading');
-          this.signal.reportError('Daily Loss Limit', `Daily PnL: $${this.risk.getDailyPnL().toFixed(2)} exceeds limit`);
-          this.stopTrading();
-        }
-
-        this.signal.reportTrade({
-          ...signal,
-          price: trade.entryPrice,
-          fee: trade.fee,
-          venue: trade.venue,
-          venueFillId: trade.id,
-          venueTimestamp: new Date(trade.timestamp).toISOString(),
-        });
-      }
-      return;
-    }
-
-    // Live trading — route to venue
-    if (venue === 'hyperliquid_perp' && this.hlOrders) {
-      await this.executeHyperliquidSignal(signal);
-    } else if (venue === 'polymarket' && this.pmOrders) {
-      await this.executePolymarketSignal(signal);
-    } else if ((venue === 'uniswap' || venue === 'aerodrome' || venue === 'hyperliquid_spot') && this.spotManager) {
-      await this.executeSpotSignal(signal);
-    } else if (venue === 'across' && this.bridgeManager) {
-      await this.executeBridgeSignal(signal);
-    } else if (venue === 'hyperliquid_deposit' && this.hlSigner) {
-      await this.executeHyperliquidDeposit(signal);
-    } else if (venue === 'hyperliquid_withdraw' && this.hlSigner) {
-      await this.executeHyperliquidWithdraw(signal);
-    } else {
-      getLogger().warn('runtime', `No executor for venue "${venue}" — signal dropped`, { symbol: sig.symbol });
-    }
-  }
-
-  /**
-   * Convert a raw strategy output to an executable TradeSignal.
-   * LLM templates return { symbol, side, confidence, reasoning } but execution
-   * needs { price, size, fee, venue, venueFillId, venueTimestamp }.
-   */
-  private convertToExecutableSignal(sig: TradeSignal, prices: Record<string, number>): TradeSignal {
-    const result = { ...sig };
-
-    // Fill in price from market data if missing
-    if (!result.price || result.price <= 0) {
-      const symbol = result.symbol || '';
-      const marketPrice = prices[symbol.toUpperCase()] || prices[symbol] || this.market.getPrice(symbol);
-      if (marketPrice && marketPrice > 0) {
-        result.price = marketPrice;
-      } else {
-        getLogger().warn('runtime', `No price for ${symbol} — signal will fail risk checks`);
-        result.price = 0;
-      }
-    }
-
-    // Compute size if missing — use a fixed fraction of capital (2% default)
-    if (!result.size || result.size <= 0) {
-      if (result.price > 0) {
-        const capital = this.config.trading.initialCapitalUSD ?? 10000;
-        // Default to 2% of capital (200 bps) as a conservative position size
-        const defaultPositionBps = 200;
-        const usdSize = (defaultPositionBps / 10000) * capital;
-        result.size = usdSize / result.price;
-      } else {
-        // No price, no size — risk filter will reject
-        result.size = 0;
-      }
-    }
-
-    // Default fee to 0 (filled by venue on execution)
-    if (result.fee === undefined || result.fee === null) {
-      result.fee = 0;
-    }
-
-    // Default venue fill fields (populated after execution)
-    if (!result.venueFillId) result.venueFillId = '';
-    if (!result.venueTimestamp) result.venueTimestamp = '';
-
-    if (result.venue) {
-      result.venue = this.normalizeVenueForExecution(result.venue) ?? result.venue;
-    }
-
-    // Infer venue from the current strategy + enabled venue config if missing
-    if (!result.venue) {
-      const candidates = this.getPreferredExecutionVenues().filter((venue) => this.canExecuteVenue(venue));
-      if (candidates.length > 0) {
-        result.venue = candidates[0];
-      }
-    }
-
-    return result;
-  }
-
-  private async executeHyperliquidSignal(sig: TradeSignal): Promise<void> {
-    if (!this.hlOrders) return;
-
-    // Map unified TradeSignal to PerpTradeSignal
-    const action = sig.side === 'long'
-      ? 'open_long' as const
-      : sig.side === 'short'
-        ? 'open_short' as const
-        : sig.side === 'buy'
-          ? 'open_long' as const
-          : 'close_long' as const;
-
-    const result = await this.hlOrders.placeOrder({
-      action,
-      instrument: sig.symbol,
-      size: sig.size,
-      price: sig.price,
-      leverage: sig.leverage ?? 1,
-      orderType: (sig.orderType as 'limit' | 'market') ?? 'market',
-      reduceOnly: action.startsWith('close'),
-      confidence: sig.confidence ?? 1.0,
-      reasoning: sig.reasoning,
-    });
-
-    if (result.success && result.status === 'filled') {
-      getLogger().info('venue', 'HL order filled', { symbol: sig.symbol, price: result.avgPrice });
-    } else if (result.success && result.status === 'resting') {
-      getLogger().info('venue', 'HL order resting', { symbol: sig.symbol, orderId: result.orderId });
-    } else {
-      getLogger().warn('venue', `HL order failed: ${result.error}`, { symbol: sig.symbol });
-      this.signal.reportError('Perp Order Failed', `${sig.symbol}: ${result.error}`);
-      this.diagnostics.recordError(result.error ?? 'Unknown error', 'venue');
-    }
-  }
-
-  private async executePolymarketSignal(sig: TradeSignal): Promise<void> {
-    if (!this.pmOrders) return;
-
-    // Determine outcome: "no" if orderType === 'no', otherwise "yes" (default)
-    // Convention: signal.orderType carries 'yes'|'no' for Polymarket (defaults to 'yes')
-    const isNo = sig.orderType === 'no';
-    const outcomeIndex = isNo ? 1 : 0;
-
-    // Map unified TradeSignal to PredictionTradeSignal action
-    const isBuy = sig.side === 'buy' || sig.side === 'long';
-    const action = isBuy
-      ? (isNo ? 'buy_no' as const : 'buy_yes' as const)
-      : (isNo ? 'sell_no' as const : 'sell_yes' as const);
-
-    const result = await this.pmOrders.executeSignal({
-      action,
-      marketConditionId: sig.symbol,
-      marketQuestion: sig.reasoning ?? sig.symbol,
-      outcomeIndex,
-      amount: sig.size,
-      limitPrice: sig.price,
-      orderType: 'limit',
-      confidence: sig.confidence ?? 1.0,
-      reasoning: sig.reasoning,
-    });
-
-    if (result.success) {
-      getLogger().info('venue', 'PM order placed', { symbol: sig.symbol });
-    } else {
-      getLogger().warn('venue', `PM order failed: ${result.error}`, { symbol: sig.symbol });
-      this.signal.reportError('Prediction Order Failed', `${sig.symbol}: ${result.error}`);
-      this.diagnostics.recordError(result.error ?? 'Unknown error', 'venue');
-    }
-  }
-
-  private async executeSpotSignal(sig: TradeSignal): Promise<void> {
-    if (!this.spotManager) return;
-
-    const chain = sig.chain ?? this.config.venues?.spot?.defaultChain ?? 'base';
-    const routedVenue = this.normalizeVenueForExecution(sig.venue) ?? this.getConfiguredSpotVenue();
-    const dex = routedVenue === 'aerodrome' ? 'aerodrome' : 'uniswap';
-
-    if (sig.venue === 'hyperliquid_spot') {
-      getLogger().info('venue', 'Routing hyperliquid_spot signal through configured spot executor', { routedAs: dex, chain });
-    }
-
-    // For spot, the symbol format is "TOKENIN/TOKENOUT" (e.g., "ETH/USDC")
-    const parts = sig.symbol.split('/');
-    const isBuy = sig.side === 'buy' || sig.side === 'long';
-
-    // Buy ETH/USDC means: swap USDC → ETH. Sell ETH/USDC means: swap ETH → USDC.
-    const tokenIn = isBuy ? (parts[1] ?? 'USDC') : (parts[0] ?? sig.symbol);
-    const tokenOut = isBuy ? (parts[0] ?? sig.symbol) : (parts[1] ?? 'USDC');
-
-    // Convert size to token amount (size is in quote currency for buys, base for sells)
-    const tokenInAddress = this.spotManager.resolveToken(tokenIn, chain);
-    const decimals = await this.spotManager.client.getDecimals(tokenInAddress, chain);
-    const amountIn = BigInt(Math.floor(sig.size * 10 ** decimals));
-
-    const result = await this.spotManager.executeSwap({
-      tokenIn,
-      tokenOut,
-      amountIn,
-      chain,
-      dex,
-    });
-
-    if (result.success) {
-      const tokenOutSymbol = await this.spotManager.client.getSymbol(result.tokenOut, chain);
-      const tokenInSymbol = await this.spotManager.client.getSymbol(result.tokenIn, chain);
-      const tokenOutDecimals = await this.spotManager.client.getDecimals(result.tokenOut, chain);
-      const amountOutFloat = Number(result.amountOut) / 10 ** tokenOutDecimals;
-      const amountInFloat = Number(result.amountIn) / 10 ** decimals;
-
-      const tradeSignal: TradeSignal = {
-        venue: result.dex,
-        chain,
-        symbol: `${parts[0] ?? sig.symbol}`,
-        side: sig.side,
-        size: isBuy ? amountOutFloat : amountInFloat,
-        price: result.effectivePrice,
-        fee: Number(result.gasCost) / 1e18,
-        venueFillId: result.txHash,
-        venueTimestamp: new Date().toISOString(),
-      };
-
-      // Update local position tracker and record PnL for daily loss limit
-      const baseToken = parts[0] ?? sig.symbol;
-      let realizedPnL = 0;
-      if (isBuy) {
-        realizedPnL = this.positions.recordBuy(
-          baseToken, amountOutFloat, result.effectivePrice,
-          tradeSignal.fee, result.dex, chain, result.txHash,
-        );
-      } else {
-        realizedPnL = this.positions.recordSell(
-          baseToken, amountInFloat, result.effectivePrice,
-          tradeSignal.fee, result.dex, chain, result.txHash,
-        );
-      }
-
-      this.risk.recordTrade(realizedPnL, tradeSignal.fee);
-      if (this.risk.isDailyLossLimitHit()) {
-        getLogger().warn('risk', 'Daily loss limit hit — stopping trading');
-        this.signal.reportError('Daily Loss Limit', `Daily PnL: $${this.risk.getDailyPnL().toFixed(2)} exceeds limit`);
-        this.stopTrading();
-      }
-
-      this.signal.reportSpotFill(tradeSignal);
-      getLogger().info('venue', 'Spot swap filled', { from: tokenInSymbol, to: tokenOutSymbol, dex: result.dex, chain });
-    } else {
-      getLogger().warn('venue', `Spot swap failed: ${result.error}`, { symbol: sig.symbol });
-      this.signal.reportError('Spot Swap Failed', `${sig.symbol}: ${result.error}`);
-    }
-  }
-
-  private async executeBridgeSignal(sig: TradeSignal): Promise<void> {
-    if (!this.bridgeManager || !this.spotManager) return;
-
-    // Bridge signal format: symbol = token symbol, chain = destination chain
-    // sig.chain is the destination; we need to figure out the source chain
-    // Convention: signal.reasoning or orderType can encode "fromChain:toChain"
-    const toChain = sig.chain ?? 'arbitrum';
-    const fromChain = sig.orderType ?? 'base'; // Use orderType as fromChain hint
-
-    const tokenAddress = this.spotManager.resolveToken(sig.symbol, fromChain);
-    const decimals = await this.spotManager.client.getDecimals(tokenAddress, fromChain);
-    const amount = BigInt(Math.floor(sig.size * 10 ** decimals));
-
-    const result = await this.bridgeManager.bridge({
-      token: tokenAddress,
-      amount,
-      fromChain,
-      toChain,
-    });
-
-    if (result.success) {
-      const tradeSignal: TradeSignal = {
-        venue: 'across',
-        chain: toChain,
-        symbol: sig.symbol,
-        side: 'buy',
-        size: sig.size,
-        price: sig.price || 1,
-        fee: Number(result.fee) / 10 ** decimals,
-        venueFillId: result.depositTxHash,
-        venueTimestamp: new Date().toISOString(),
-      };
-
-      this.signal.reportBridgeFill(tradeSignal);
-      getLogger().info('bridge', 'Bridge completed', { from: fromChain, to: toChain, bridge: 'across' });
-    } else {
-      getLogger().warn('bridge', `Bridge failed: ${result.error}`, { symbol: sig.symbol });
-      this.signal.reportError('Bridge Failed', `${sig.symbol} ${fromChain}→${toChain}: ${result.error}`);
-    }
-  }
-
-  // ── HYPERLIQUID DEPOSIT / WITHDRAW ────────────────────────
-
-  /** Hyperliquid bridge contract on Arbitrum — accepts plain USDC transfers */
-  private static readonly HL_BRIDGE_CONTRACT: `0x${string}` = '0x2Df1c51E09aECF9cacB7bc98cB1742757f163dF7';
-
-  /**
-   * Deposit USDC into Hyperliquid by transferring to the bridge contract on Arbitrum.
-   * Signal format: venue='hyperliquid_deposit', size=amount in USDC, chain is ignored (always Arbitrum).
-   * The wallet must already have USDC + ETH for gas on Arbitrum.
-   */
-  private async executeHyperliquidDeposit(sig: TradeSignal): Promise<void> {
-    if (!this.spotManager) {
-      this.signal.reportError('HL Deposit Failed', 'Spot manager not initialized (needed for chain clients)');
-      return;
-    }
-
-    const arbConfig = getChainConfig('arbitrum');
-    if (!arbConfig) {
-      this.signal.reportError('HL Deposit Failed', 'Arbitrum chain config not found');
-      return;
-    }
-
-    const usdcAddress = arbConfig.usdcAddress;
-    const amount = BigInt(Math.floor(sig.size * 1e6)); // USDC has 6 decimals
-
-    // Pre-check: gas balance on Arbitrum
-    const MIN_GAS_WEI = 100_000_000_000_000n; // 0.0001 ETH
-    try {
-      const gasBalance = await this.spotManager.client.getNativeBalance('arbitrum');
-      if (gasBalance < MIN_GAS_WEI) {
-        this.signal.reportError('HL Deposit Failed', `Insufficient ETH for gas on Arbitrum. Balance: ${formatUnits(gasBalance, 18)} ETH. Need at least 0.0001 ETH.`);
-        return;
-      }
-    } catch {
-      // proceed — let the transfer itself fail with a clearer error
-    }
-
-    // Pre-check: USDC balance on Arbitrum
-    try {
-      const usdcBalance = await this.spotManager.client.getBalance(usdcAddress, 'arbitrum');
-      if (usdcBalance < amount) {
-        this.signal.reportError('HL Deposit Failed', `Insufficient USDC on Arbitrum. Have ${formatUnits(usdcBalance, 6)}, need ${formatUnits(amount, 6)}. Bridge USDC to Arbitrum first.`);
-        return;
-      }
-    } catch (err) {
-      this.signal.reportError('HL Deposit Failed', `Could not check USDC balance: ${(err as Error).message}`);
-      return;
-    }
-
-    // Deposit = plain ERC20 transfer of USDC to the HL bridge contract
-    try {
-      const { publicClient, walletClient } = this.spotManager.client.getClients('arbitrum');
-      const hash = await walletClient.writeContract({
-        address: usdcAddress,
-        abi: ERC20_ABI,
-        functionName: 'transfer',
-        args: [AgentRuntime.HL_BRIDGE_CONTRACT, amount],
-      });
-
-      const receipt = await publicClient.waitForTransactionReceipt({ hash });
-      if (receipt.status === 'reverted') {
-        this.signal.reportError('HL Deposit Failed', `Transfer reverted: ${hash}`);
-        return;
-      }
-
-      getLogger().info('venue', 'HL deposit completed', { amount: formatUnits(amount, 6), tx: hash });
-      this.signal.reportInfo('HL Deposit', `Deposited ${formatUnits(amount, 6)} USDC to Hyperliquid`);
-    } catch (err) {
-      getLogger().error('venue', `HL deposit failed: ${(err as Error).message}`);
-      this.signal.reportError('HL Deposit Failed', (err as Error).message);
-    }
-  }
-
-  /**
-   * Withdraw USDC from Hyperliquid to the wallet on Arbitrum.
-   * Signal format: venue='hyperliquid_withdraw', size=amount in USDC.
-   * Uses the withdraw3 EIP-712 signing scheme.
-   */
-  private async executeHyperliquidWithdraw(sig: TradeSignal): Promise<void> {
-    if (!this.hlSigner || !this.hlClient) {
-      this.signal.reportError('HL Withdraw Failed', 'Hyperliquid signer/client not initialized');
-      return;
-    }
-
-    const destination = this.hlSigner.getAddress();
-    const amount = sig.size.toString();
-
-    try {
-      const { action, signature, nonce } = await this.hlSigner.signWithdraw(destination, amount);
-
-      const apiUrl = this.config.venues?.hyperliquid_perp?.apiUrl ?? 'https://api.hyperliquid.xyz';
-      const resp = await fetch(`${apiUrl}/exchange`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ action, nonce, signature, vaultAddress: null }),
-      });
-
-      if (!resp.ok) {
-        const text = await resp.text();
-        throw new Error(`HL Exchange API error: ${resp.status} ${text}`);
-      }
-
-      const data = await resp.json() as { status: string; response?: { type: string } };
-      if (data.status !== 'ok') {
-        throw new Error(`HL withdraw3 failed: ${JSON.stringify(data)}`);
-      }
-
-      getLogger().info('venue', 'HL withdrawal completed', { amount, destination });
-      this.signal.reportInfo('HL Withdrawal', `Withdrew ${amount} USDC from Hyperliquid to ${destination}`);
-    } catch (err) {
-      getLogger().error('venue', `HL withdrawal failed: ${(err as Error).message}`);
-      this.signal.reportError('HL Withdraw Failed', (err as Error).message);
-    }
-  }
-
-  // ── FILL HANDLING ──────────────────────────────────────────
-
-  private handleHyperliquidFill(fill: PerpFill): void {
-    const tradeSignal: TradeSignal = {
-      venue: 'hyperliquid_perp',
-      symbol: fill.coin,
-      side: fill.side === 'B' ? 'long' : 'short',
-      size: parseFloat(fill.sz),
-      price: parseFloat(fill.px),
-      fee: parseFloat(fill.fee),
-      venueFillId: fill.hash,
-      venueTimestamp: new Date(fill.time).toISOString(),
-      orderType: fill.isMaker ? 'limit' : 'market',
-    };
-
-    // Update local position tracker and record PnL for daily loss limit
-    const action = fill.side === 'B' ? 'buy' as const : 'sell' as const;
-    const fee = parseFloat(fill.fee);
-    let realizedPnL = 0;
-    if (action === 'buy') {
-      realizedPnL = this.positions.recordBuy(
-        fill.coin, parseFloat(fill.sz), parseFloat(fill.px),
-        fee, 'hyperliquid_perp', undefined, fill.hash,
-      );
-    } else {
-      realizedPnL = this.positions.recordSell(
-        fill.coin, parseFloat(fill.sz), parseFloat(fill.px),
-        fee, 'hyperliquid_perp', undefined, fill.hash,
-      );
-    }
-
-    // Feed realized PnL to risk manager for daily loss circuit breaker
-    this.risk.recordTrade(realizedPnL, fee);
-    if (this.risk.isDailyLossLimitHit()) {
-      getLogger().warn('risk', 'Daily loss limit hit — stopping trading');
-      this.diagnostics.recordError('Daily loss limit hit', 'risk');
-      this.signal.reportError('Daily Loss Limit', `Daily PnL: $${this.risk.getDailyPnL().toFixed(2)} exceeds limit of -$${this.risk.getDailyLossLimit().toFixed(2)}`);
-      this.stopTrading();
-    }
-
-    // Report to command center
-    this.signal.reportPerpFill(tradeSignal);
-  }
-
-  private async pollPredictionFills(): Promise<void> {
-    if (!this.pmOrders) return;
-
-    try {
-      const newFills = await this.pmOrders.pollNewFills();
-      for (const fill of newFills) {
-        const tradeSignal: TradeSignal = {
-          venue: 'polymarket',
-          chain: 'polygon',
-          symbol: encodePredictionInstrument(fill.marketConditionId, fill.outcomeIndex),
-          side: fill.side === 'BUY' ? 'buy' : 'sell',
-          size: parseFloat(fill.size),
-          price: parseFloat(fill.price),
-          fee: parseFloat(fill.fee),
-          venueFillId: fill.tradeId,
-          venueTimestamp: new Date(fill.timestamp).toISOString(),
-        };
-
-        // Update position tracker and daily loss limit
-        const fillFee = parseFloat(fill.fee);
-        let realizedPnL = 0;
-        if (fill.side === 'BUY') {
-          realizedPnL = this.positions.recordBuy(
-            tradeSignal.symbol, parseFloat(fill.size), parseFloat(fill.price),
-            fillFee, 'polymarket', 'polygon', fill.tradeId,
-          );
-        } else {
-          realizedPnL = this.positions.recordSell(
-            tradeSignal.symbol, parseFloat(fill.size), parseFloat(fill.price),
-            fillFee, 'polymarket', 'polygon', fill.tradeId,
-          );
-        }
-        this.risk.recordTrade(realizedPnL, fillFee);
-        if (this.risk.isDailyLossLimitHit()) {
-          getLogger().warn('risk', 'Daily loss limit hit — stopping trading');
-          this.signal.reportError('Daily Loss Limit', `Daily PnL: $${this.risk.getDailyPnL().toFixed(2)} exceeds limit`);
-          this.stopTrading();
-        }
-
-        this.signal.reportPredictionFill(tradeSignal);
-      }
-    } catch (err) {
-      // Non-critical — log and continue
-      getLogger().warn('venue', `Prediction fill poll error: ${(err as Error).message}`);
-    }
-  }
-
-  // ── COMMANDS ───────────────────────────────────────────────
-
-  private handleCommand(command: RelayCommand): void {
-    getLogger().info('runtime', 'Command received', { type: command.type, id: command.id });
-
-    switch (command.type) {
-      case 'start_trading':
-        if (this.mode === 'paused') {
-          this.resumeTrading();
-          this.relay.sendCommandAck(command.id, true, 'Trading resumed from paused state');
-        } else {
-          this.startTrading();
-          this.relay.sendCommandAck(command.id, true, 'Trading started');
-        }
-        break;
-      case 'stop_trading':
-        this.stopTrading();
-        this.relay.sendCommandAck(command.id, true, 'Trading stopped');
-        break;
-      case 'pause_trading':
-        this.pauseTrading();
-        this.relay.sendCommandAck(command.id, true, 'Trading paused — heartbeats continue, no new cycles');
-        break;
-      case 'update_risk_params':
-        if (command.params) {
-          this.risk.updateParams(command.params as Record<string, number>);
-          this.sendStatus();
-          this.relay.sendCommandAck(command.id, true, 'Risk params updated');
-        } else {
-          this.relay.sendCommandAck(command.id, false, 'No params provided');
-        }
-        break;
-      case 'get_status':
-        this.sendStatus();
-        this.relay.sendCommandAck(command.id, true);
-        break;
-      case 'reload_config':
-        this.reloadConfig(command);
-        break;
-      case 'close_all_positions':
-        this.closeAllPositions(command);
-        break;
-      case 'update_strategy':
-        this.updateStrategy(command);
-        break;
-      case 'shutdown':
-        this.relay.sendCommandAck(command.id, true, 'Agent shutting down');
-        // Give the ack time to send before exiting
-        setTimeout(() => {
-          this.stop();
-        }, 500);
-        break;
-      default:
-        getLogger().warn('runtime', `Unknown command: ${command.type}`);
-        this.relay.sendCommandAck(command.id, false, `Unknown command: ${command.type}`);
-    }
-  }
-
-  private async reloadConfig(command: RelayCommand): Promise<void> {
-    try {
-      const apiBase = this.config.apiUrl || this.config.relay.url.replace(/\/ws\/.*/, '');
-      const res = await fetch(`${apiBase}/v1/agents/${this.config.agentId}`, {
-        headers: { 'Authorization': `Bearer ${this.config.apiToken}` },
-      });
-      if (!res.ok) {
-        throw new Error(`API returned ${res.status}`);
-      }
-      const agent = await res.json() as { config?: Record<string, unknown> };
-      if (agent.config) {
-        const cfg = agent.config as Record<string, unknown>;
-        const previousMode = this.mode;
-
-        if (this.tradingInterval) {
-          clearInterval(this.tradingInterval);
-          this.tradingInterval = null;
-        }
-
-        await this.waitForCycleCompletion();
-
-        // Update risk params if present
-        const risk = cfg.risk as Record<string, unknown> | undefined;
-        if (risk) {
-          const updates: Record<string, number> = {};
-          if (typeof risk.maxPositionSize === 'number') updates.maxPositionSizeBps = risk.maxPositionSize * 100;
-          if (typeof risk.maxPositionSizePct === 'number') updates.maxPositionSizeBps = risk.maxPositionSizePct * 100;
-          if (typeof risk.maxDailyLoss === 'number') updates.maxDailyLossBps = risk.maxDailyLoss * 100;
-          if (typeof risk.maxDailyLossPct === 'number') updates.maxDailyLossBps = risk.maxDailyLossPct * 100;
-          if (typeof risk.maxConcurrentPositions === 'number') updates.maxConcurrentPositions = risk.maxConcurrentPositions;
-          if (typeof risk.slippageTolerance === 'number') updates.maxSlippageBps = risk.slippageTolerance * 100;
-          if (typeof risk.maxSlippagePct === 'number') updates.maxSlippageBps = risk.maxSlippagePct * 100;
-          if (typeof risk.tradingInterval === 'number') {
-            this.config.trading.tradingIntervalMs = risk.tradingInterval * 1000;
-          }
-          if (typeof risk.tradingIntervalSec === 'number') {
-            this.config.trading.tradingIntervalMs = risk.tradingIntervalSec * 1000;
-          }
-          if (typeof risk.minTradeValueUSD === 'number') {
-            this.config.trading.minTradeValueUSD = risk.minTradeValueUSD;
-            updates.minTradeValueUSD = risk.minTradeValueUSD;
-          }
-          if (Object.keys(updates).length > 0) {
-            this.risk.updateParams(updates);
-          }
-        }
-
-        if (typeof cfg.paperTrading === 'boolean') {
-          this.config.trading.mode = cfg.paperTrading ? 'paper' : 'live';
-        }
-
-        const llm = cfg.llm as Record<string, unknown> | undefined;
-        if (llm) {
-          let llmChanged = false;
-          const nextLlm = { ...this.config.llm };
-
-          if (typeof llm.provider === 'string' && llm.provider !== nextLlm.provider) {
-            nextLlm.provider = llm.provider as RuntimeConfig['llm']['provider'];
-            llmChanged = true;
-          }
-          if (typeof llm.model === 'string' && llm.model !== nextLlm.model) {
-            nextLlm.model = llm.model;
-            llmChanged = true;
-          }
-          if (typeof llm.endpoint === 'string' && llm.endpoint !== nextLlm.endpoint) {
-            nextLlm.endpoint = llm.endpoint;
-            llmChanged = true;
-          }
-          if (typeof llm.temperature === 'number' && llm.temperature !== nextLlm.temperature) {
-            nextLlm.temperature = llm.temperature;
-            llmChanged = true;
-          }
-          if (typeof llm.maxTokens === 'number' && llm.maxTokens !== nextLlm.maxTokens) {
-            nextLlm.maxTokens = llm.maxTokens;
-            llmChanged = true;
-          }
-
-          if (llmChanged) {
-            this.config.llm = nextLlm;
-            this.llm = createLLMAdapter(this.config.llm);
-            this.configureLLMAdapter(this.llm);
-          }
-        }
-
-        if (Array.isArray(cfg.venues)) {
-          const selectedVenues = cfg.venues.filter((venue): venue is string => typeof venue === 'string');
-          this.config.venues = this.buildRuntimeVenuesFromSelection(selectedVenues);
-        }
-
-        const nextStrategyConfig = this.extractStrategyConfigFromAgentConfig(cfg);
-        const nextStrategy = await loadStrategy(nextStrategyConfig);
-        this.config.strategy = nextStrategyConfig;
-        this.strategy = nextStrategy;
-        await this.applyExecutionMode();
-
-        if (previousMode === 'trading' || previousMode === 'paper') {
-          this.startTrading();
-        } else if (previousMode === 'paused') {
-          this.modeBeforePause = this.config.trading.mode === 'paper' ? 'paper' : 'trading';
-          this.mode = 'paused';
-        } else {
-          this.mode = 'idle';
-          this.modeBeforePause = null;
-        }
-
-        getLogger().info('runtime', 'Config reloaded from API');
-        this.sendStatus();
-      }
-      this.relay.sendCommandAck(command.id, true, 'Config reloaded');
-    } catch (err) {
-      getLogger().error('runtime', `Config reload failed: ${(err as Error).message}`);
-      this.relay.sendCommandAck(command.id, false, (err as Error).message);
-    }
-  }
-
-  private async closeAllPositions(command: RelayCommand): Promise<void> {
-    const log = getLogger();
-    log.info('runtime', 'Emergency close all positions');
-
-    // Stop trading first to prevent new positions
-    this.stopTrading();
-
-    const positions = this.positions.getPositions();
-    if (positions.length === 0) {
-      this.relay.sendCommandAck(command.id, true, 'No open positions');
-      this.sendStatus();
-      return;
-    }
-
-    const results: { token: string; venue: string; success: boolean; error?: string }[] = [];
-
-    for (const pos of positions) {
-      try {
-        if (pos.venue?.startsWith('hyperliquid_perp') && this.hlOrders) {
-          const result = await this.hlOrders.closePosition(pos.token, pos.quantity);
-          results.push({ token: pos.token, venue: pos.venue, success: result.success, error: result.error });
-        } else if (pos.venue === 'polymarket' && this.pmOrders) {
-          // Sell shares at market to close
-          const result = await this.pmOrders.executeSignal({
-            action: pos.quantity > 0 ? 'sell_yes' : 'sell_no',
-            marketConditionId: pos.token,
-            marketQuestion: '',
-            outcomeIndex: 0,
-            amount: Math.abs(pos.quantity),
-            limitPrice: 0.01,
-            confidence: 1.0,
-            orderType: 'market',
-          });
-          results.push({ token: pos.token, venue: 'polymarket', success: result.success, error: result.error });
-        } else {
-          // Spot positions or unknown venues — skip
-          results.push({ token: pos.token, venue: pos.venue || 'spot', success: false, error: 'Spot positions not auto-closable' });
-        }
-      } catch (err) {
-        results.push({ token: pos.token, venue: pos.venue || 'unknown', success: false, error: (err as Error).message });
-      }
-    }
-
-    const closed = results.filter(r => r.success).length;
-    const failed = results.filter(r => !r.success && r.error !== 'Spot positions not auto-closable').length;
-    const msg = `Closed ${closed}/${positions.length} positions${failed > 0 ? ` (${failed} failed)` : ''}`;
-
-    log.info('runtime', msg, { results });
-    this.signal.reportInfo('Emergency Close', msg);
-    this.relay.sendCommandAck(command.id, failed === 0, msg);
-    this.sendStatus();
-  }
-
-  private async updateStrategy(command: RelayCommand): Promise<void> {
-    const log = getLogger();
-    const params = command.params as { template?: string; file?: string } | undefined;
-
-    if (!params || (!params.template && !params.file)) {
-      this.relay.sendCommandAck(command.id, false, 'No strategy specified (need template or file)');
-      return;
-    }
-
-    try {
-      const oldName = this.config.strategy?.template || this.config.strategy?.file || 'unknown';
-
-      // Pause trading cycle if running
-      const wasTrading = this.mode === 'trading' || this.mode === 'paper';
-      if (wasTrading && this.tradingInterval) {
-        clearInterval(this.tradingInterval);
-        this.tradingInterval = null;
-      }
-
-      // Wait for any in-progress cycle to complete
-      let waitMs = 0;
-      while (this.cycleInProgress && waitMs < 30000) {
-        await new Promise(resolve => setTimeout(resolve, 100));
-        waitMs += 100;
-      }
-
-      // Load new strategy
-      const newStrategy = await loadStrategy({
-        file: params.file,
-        template: params.template,
-      });
-
-      // Swap
-      this.strategy = newStrategy;
-      const newName = params.template || params.file || 'unknown';
-
-      // Update config reference
-      if (params.template) {
-        this.config.strategy = { ...this.config.strategy, template: params.template };
-      }
-      if (params.file) {
-        this.config.strategy = { ...this.config.strategy, file: params.file };
-      }
-
-      // Resume trading if it was running
-      if (wasTrading) {
-        this.tradingInterval = setInterval(() => {
-          this.runCycle();
-        }, this.config.trading.tradingIntervalMs);
-      }
-
-      const msg = `Strategy swapped: ${oldName} → ${newName}`;
-      log.info('runtime', msg);
-      this.signal.reportInfo('Strategy Updated', msg);
-      this.relay.sendCommandAck(command.id, true, msg);
-      this.sendStatus();
-    } catch (err) {
-      const msg = `Strategy swap failed: ${(err as Error).message}`;
-      log.error('runtime', msg);
-      this.relay.sendCommandAck(command.id, false, msg);
-    }
-  }
-
-  // ── STATUS ─────────────────────────────────────────────────
-
-  private sendStatus(): void {
-    // Compute unrealized PnL from current market prices
-    const prices = this.market.getPrices();
-    const positionSummary = this.positions.getSummary(prices);
-
-    // Update paper equity with current market prices
-    if (this.paper) {
-      this.paper.recordEquityWithPrices(prices);
-    }
-
-    // Get LLM usage stats
-    const llmUsage = this.llm instanceof BaseLLMAdapter
-      ? this.llm.getUsageStats()
-      : null;
-
-    const status: AgentStatusPayload = {
-      mode: this.mode,
-      agentId: this.config.agentId,
-      walletAddress: this.walletAddress || undefined,
-      sdkVersion: SDK_VERSION,
-      cycleCount: this.cycleCount,
-      lastCycleAt: this.lastCycleAt,
-      tradingIntervalMs: this.config.trading.tradingIntervalMs,
-      llm: {
-        provider: this.config.llm.provider,
-        model: this.config.llm.model || 'default',
-        ...(llmUsage ? {
-          dailyTokens: llmUsage.dailyInputTokens + llmUsage.dailyOutputTokens,
-          totalTokens: llmUsage.totalInputTokens + llmUsage.totalOutputTokens,
-          dailyCalls: llmUsage.dailyCalls,
-          totalCalls: llmUsage.totalCalls,
-          dailyBudgetExceeded: this.llm instanceof BaseLLMAdapter
-            ? this.llm.isDailyBudgetExceeded()
-            : false,
-        } : {}),
-      },
-      risk: {
-        dailyPnL: this.risk.getDailyPnL(),
-        dailyLossLimit: this.risk.getDailyLossLimit(),
-        isLimitHit: this.risk.isDailyLossLimitHit(),
-      },
-      positions: {
-        openPositions: positionSummary.openPositions.length,
-        totalUnrealizedPnL: positionSummary.totalUnrealizedPnL,
-        totalRealizedPnL: positionSummary.totalRealizedPnL,
-      },
-      venues: {
-        hyperliquid: {
-          enabled: this.config.venues?.hyperliquid_perp?.enabled === true,
-          trading: !!this.hlOrders && (this.mode === 'trading' || this.mode === 'paused'),
-        },
-        polymarket: {
-          enabled: this.config.venues?.polymarket?.enabled === true,
-          trading: !!this.pmOrders && (this.mode === 'trading' || this.mode === 'paused'),
-        },
-        spot: {
-          enabled: this.config.venues?.spot?.enabled === true,
-          trading: !!this.spotManager && (this.mode === 'trading' || this.mode === 'paused'),
-        },
-        bridge: {
-          enabled: this.config.venues?.bridge?.enabled === true,
-        },
-      },
-    };
-
-    if (this.paper) {
-      const metrics = this.paper.getMetrics();
-      status.paper = {
-        active: true,
-        simulatedValue: this.paper.getEquity(),
-        simulatedPnLPct: metrics.totalReturn * 100,
-      };
-      status.portfolioValue = this.paper.getEquity();
-    }
-
-    // Diagnostics snapshot
-    const health = this.diagnostics.getHealthSnapshot(this.signal.queueSize);
-    const lastCycle = this.diagnostics.getLastCycle();
-    status.diagnostics = {
-      uptime: health.uptime,
-      uptimeHuman: health.uptimeHuman,
-      memoryMB: health.memoryMB,
-      cycleStats: health.cycleStats,
-      lastCycleTimings: lastCycle?.timings,
-      errorCounts: health.errorCounts,
-      recentErrors: health.recentErrors,
-      llmStats: health.llmStats,
-      signalQueue: health.signalQueue,
-    };
-
-    this.relay.sendHeartbeat(status);
-  }
-}