hedgequantx 2.9.145 → 2.9.147

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgequantx",
-  "version": "2.9.145",
+  "version": "2.9.147",
   "description": "HedgeQuantX - Prop Futures Trading CLI",
   "main": "src/app.js",
   "bin": {

package/src/pages/algo/algo-executor.js

@@ -361,17 +361,25 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
   // P&L polling - uses CACHED data (NO API CALLS to avoid Rithmic rate limits)
   const pollPnL = async () => {
     try {
-      // Get P&L from cache (no API call)
       const accId = account.rithmicAccountId || account.accountId;
-      const pnlData = service.getAccountPnL ? service.getAccountPnL(accId) : null;
       
-      if (pnlData && pnlData.pnl !== null) {
+      // Get P&L from cache (handle sync/async)
+      let pnlData = null;
+      if (service.getAccountPnL) {
+        const result = service.getAccountPnL(accId);
+        pnlData = result && result.then ? await result : result;
+      }
+      
+      if (pnlData && pnlData.pnl !== null && pnlData.pnl !== undefined && !isNaN(pnlData.pnl)) {
         if (startingPnL === null) startingPnL = pnlData.pnl;
-        stats.pnl = pnlData.pnl - startingPnL;
-        if (stats.pnl !== 0) strategy.recordTradeResult(stats.pnl);
+        const newPnl = pnlData.pnl - startingPnL;
+        if (!isNaN(newPnl)) {
+          stats.pnl = newPnl;
+          if (stats.pnl !== 0) strategy.recordTradeResult(stats.pnl);
+        }
       }
       
-      // Check positions (less frequent - every 10s to reduce API calls)
+      // Check positions (every 10s)
       if (Date.now() % 10000 < 2000) {
         const posResult = await service.getPositions(accId);
         if (posResult.success && posResult.positions) {
@@ -379,29 +387,27 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
             const sym = p.contractId || p.symbol || '';
             return sym.includes(contract.name) || sym.includes(contractId);
           });
-          
           if (pos && pos.quantity !== 0) {
             currentPosition = pos.quantity;
-            const pnl = pos.profitAndLoss || 0;
-            if (pnl > 0) stats.wins = Math.max(stats.wins, 1);
-            else if (pnl < 0) stats.losses = Math.max(stats.losses, 1);
           } else {
             currentPosition = 0;
           }
         }
       }
       
-      if (stats.pnl >= dailyTarget) {
-        stopReason = 'target'; running = false;
-        ui.addLog('fill_win', `TARGET REACHED! +$${stats.pnl.toFixed(2)}`);
-        sessionLogger.log('TARGET', `Daily target reached: +$${stats.pnl.toFixed(2)}`);
-      } else if (stats.pnl <= -maxRisk) {
-        stopReason = 'risk'; running = false;
-        ui.addLog('fill_loss', `MAX RISK! -$${Math.abs(stats.pnl).toFixed(2)}`);
-        sessionLogger.log('RISK', `Max risk hit: -$${Math.abs(stats.pnl).toFixed(2)}`);
+      // Risk checks (only if pnl is valid)
+      if (!isNaN(stats.pnl)) {
+        if (stats.pnl >= dailyTarget) {
+          stopReason = 'target'; running = false;
+          ui.addLog('fill_win', `TARGET REACHED! +$${stats.pnl.toFixed(2)}`);
+          sessionLogger.log('TARGET', `Daily target reached: +$${stats.pnl.toFixed(2)}`);
+        } else if (stats.pnl <= -maxRisk) {
+          stopReason = 'risk'; running = false;
+          ui.addLog('fill_loss', `MAX RISK! -$${Math.abs(stats.pnl).toFixed(2)}`);
+          sessionLogger.log('RISK', `Max risk hit: -$${Math.abs(stats.pnl).toFixed(2)}`);
+        }
+        sessionLogger.pnl(stats.pnl, 0, currentPosition);
       }
-      // Log P&L every poll
-      sessionLogger.pnl(stats.pnl, 0, currentPosition);
     } catch (e) { /* silent */ }
   };
   

package/src/pages/algo/one-account.js

@@ -389,8 +389,8 @@ const selectMultipleSymbols = async (service, account) => {
 const selectSymbol = async (service, account) => {
   const spinner = ora({ text: 'Loading symbols...', color: 'yellow' }).start();
   
-  // Ensure we have a logged-in service
-  if (!service.loginInfo && service.credentials) {
+  // Ensure we have a logged-in service (for direct RithmicService, not BrokerClient)
+  if (!service.loginInfo && service.credentials && typeof service.login === 'function') {
     spinner.text = 'Reconnecting to broker...';
     const loginResult = await service.login(service.credentials.username, service.credentials.password);
     if (!loginResult.success) {
@@ -400,8 +400,11 @@ const selectSymbol = async (service, account) => {
   }
   
   const contractsResult = await service.getContracts();
+  
   if (!contractsResult.success || !contractsResult.contracts?.length) {
-    spinner.fail(`Failed to load contracts: ${contractsResult.error || 'No contracts'}`);
+    const errorMsg = contractsResult.error || 'No contracts available';
+    spinner.fail(`Failed to load contracts: ${errorMsg}`);
+    console.log(chalk.gray('  Tip: Try reconnecting with "hqx login"'));
     return null;
   }
   

package/src/services/rithmic/index.js

@@ -19,6 +19,7 @@ const {
 const { placeOrder, cancelOrder, getOrders, getOrderHistory, getOrderHistoryDates, getTradeHistoryFull, closePosition } = require('./orders');
 const { fillsToRoundTrips, calculateTradeStats } = require('./trades');
 const { getContracts, searchContracts } = require('./contracts');
+const { handleAutoReconnect } = require('./reconnect');
 const { TIMEOUTS } = require('../../config/settings');
 const { logger } = require('../../utils/logger');
 
@@ -83,7 +84,15 @@ class RithmicService extends EventEmitter {
 
   // ==================== AUTH ====================
 
-  async login(username, password) {
+  /**
+   * Login to Rithmic
+   * @param {string} username - Rithmic username
+   * @param {string} password - Rithmic password
+   * @param {Object} options - Login options
+   * @param {boolean} options.skipFetchAccounts - Skip fetchAccounts API call (use cached)
+   * @param {Array} options.cachedAccounts - Cached accounts to use instead of fetching
+   */
+  async login(username, password, options = {}) {
     try {
       this.orderConn = new RithmicConnection();
       
@@ -121,11 +130,17 @@ class RithmicService extends EventEmitter {
           this.loginInfo = data;
           this.user = { userName: username, fcmId: data.fcmId, ibId: data.ibId };
           
-          try {
-            await fetchAccounts(this);
-            log.debug('Fetched accounts', { count: this.accounts.length });
-          } catch (err) {
-            log.warn('Failed to fetch accounts', { error: err.message });
+          // Skip fetchAccounts if using cached accounts (avoids API quota)
+          if (options.skipFetchAccounts && options.cachedAccounts) {
+            this.accounts = options.cachedAccounts;
+            log.debug('Using cached accounts', { count: this.accounts.length });
+          } else {
+            try {
+              await fetchAccounts(this);
+              log.debug('Fetched accounts', { count: this.accounts.length });
+            } catch (err) {
+              log.warn('Failed to fetch accounts', { error: err.message });
+            }
           }
           
           this.credentials = { username, password };
@@ -140,6 +155,7 @@ class RithmicService extends EventEmitter {
             log.warn('PnL connection failed', { error: err.message });
           }
           
+          // Get trading accounts (uses existing this.accounts, no new API call)
           const result = await getTradingAccounts(this);
           log.info('Login successful', { accounts: result.accounts.length });
           
@@ -423,33 +439,14 @@ class RithmicService extends EventEmitter {
 
   // ==================== AUTO-RECONNECT ====================
 
+  /**
+   * Auto-reconnect with rate limiting (delegated to reconnect module)
+   * - Minimum 1 hour between attempts
+   * - Maximum 10 attempts per 24 hours
+   * - Reuses cached accounts (no fetchAccounts API call)
+   */
   async _autoReconnect() {
-    if (!this.credentials) {
-      log.warn('Cannot auto-reconnect: no credentials');
-      return;
-    }
-    
-    const { username, password } = this.credentials;
-    log.info('Auto-reconnecting...');
-    this.emit('reconnecting');
-    
-    try {
-      const result = await this.login(username, password);
-      if (result.success) {
-        log.info('Auto-reconnect successful');
-        this.emit('reconnected', { accounts: result.accounts });
-      } else {
-        log.warn('Auto-reconnect failed', { error: result.error });
-        this.emit('reconnectFailed', { error: result.error });
-        // Retry in 10s
-        setTimeout(() => this._autoReconnect(), 10000);
-      }
-    } catch (err) {
-      log.error('Auto-reconnect error', { error: err.message });
-      this.emit('reconnectFailed', { error: err.message });
-      // Retry in 10s
-      setTimeout(() => this._autoReconnect(), 10000);
-    }
+    return handleAutoReconnect(this);
   }
 
   // ==================== CLEANUP ====================

package/src/services/rithmic/reconnect.js

@@ -0,0 +1,138 @@
+/**
+ * Rithmic Reconnection Module
+ * 
+ * Rate-limited reconnection logic to avoid API quota exhaustion.
+ * Rithmic limit: 2000 GetAccounts calls between system reboots.
+ * 
+ * Rate limiting:
+ * - Minimum 1 hour between reconnection attempts
+ * - Maximum 10 reconnection attempts per 24 hours
+ */
+
+'use strict';
+
+const { logger } = require('../../utils/logger');
+const log = logger.scope('Rithmic:Reconnect');
+
+// Rate limiting constants
+const RECONNECT_MIN_INTERVAL = 3600000;  // 1 hour minimum between attempts
+const RECONNECT_MAX_PER_DAY = 10;        // Max 10 reconnects per 24h
+
+/**
+ * Check if reconnection is allowed (rate limiting)
+ * @param {Object} state - { lastAttempt, count, resetTime }
+ * @returns {{ allowed: boolean, waitMinutes?: number, reason?: string }}
+ */
+function canReconnect(state) {
+  const now = Date.now();
+
+  // Reset daily counter every 24h
+  if (now - state.resetTime > 86400000) {
+    state.count = 0;
+    state.resetTime = now;
+  }
+
+  // Check minimum interval
+  const timeSinceLastAttempt = now - state.lastAttempt;
+  if (state.lastAttempt > 0 && timeSinceLastAttempt < RECONNECT_MIN_INTERVAL) {
+    const waitMinutes = Math.ceil((RECONNECT_MIN_INTERVAL - timeSinceLastAttempt) / 60000);
+    return { allowed: false, waitMinutes, reason: 'rate_limited' };
+  }
+
+  // Check daily limit
+  if (state.count >= RECONNECT_MAX_PER_DAY) {
+    return { allowed: false, reason: 'daily_limit', waitMinutes: 0 };
+  }
+
+  return { allowed: true };
+}
+
+/**
+ * Record a reconnection attempt
+ * @param {Object} state - { lastAttempt, count, resetTime }
+ */
+function recordAttempt(state) {
+  state.lastAttempt = Date.now();
+  state.count++;
+}
+
+/**
+ * Create initial reconnect state
+ * @returns {Object} - { lastAttempt, count, resetTime }
+ */
+function createReconnectState() {
+  return {
+    lastAttempt: 0,
+    count: 0,
+    resetTime: Date.now()
+  };
+}
+
+/**
+ * Auto-reconnect handler for RithmicService
+ * @param {RithmicService} service - The service instance
+ */
+async function handleAutoReconnect(service) {
+  if (!service.credentials) {
+    log.warn('Cannot auto-reconnect: no credentials');
+    return;
+  }
+
+  // Initialize reconnect state if needed
+  if (!service._reconnectState) {
+    service._reconnectState = createReconnectState();
+  }
+
+  // Check rate limits
+  const check = canReconnect(service._reconnectState);
+  if (!check.allowed) {
+    if (check.reason === 'rate_limited') {
+      log.warn('Reconnect rate limited', { waitMinutes: check.waitMinutes });
+      service.emit('reconnectRateLimited', { waitMinutes: check.waitMinutes });
+    } else {
+      log.error('Daily reconnect limit reached', { limit: RECONNECT_MAX_PER_DAY });
+      service.emit('reconnectBlocked', { reason: 'Daily limit reached' });
+    }
+    return;
+  }
+
+  // Record this attempt
+  recordAttempt(service._reconnectState);
+
+  const { username, password } = service.credentials;
+  const savedAccounts = [...service.accounts]; // Save accounts before reconnect
+
+  log.info('Auto-reconnecting...', { 
+    attempt: service._reconnectState.count, 
+    maxPerDay: RECONNECT_MAX_PER_DAY 
+  });
+  service.emit('reconnecting');
+
+  try {
+    // Login with cached accounts (NO fetchAccounts API call)
+    const result = await service.login(username, password, {
+      skipFetchAccounts: true,
+      cachedAccounts: savedAccounts
+    });
+
+    if (result.success) {
+      log.info('Auto-reconnect successful');
+      service.emit('reconnected', { accounts: result.accounts });
+    } else {
+      log.warn('Auto-reconnect failed', { error: result.error });
+      service.emit('reconnectFailed', { error: result.error });
+    }
+  } catch (err) {
+    log.error('Auto-reconnect error', { error: err.message });
+    service.emit('reconnectFailed', { error: err.message });
+  }
+}
+
+module.exports = {
+  RECONNECT_MIN_INTERVAL,
+  RECONNECT_MAX_PER_DAY,
+  canReconnect,
+  recordAttempt,
+  createReconnectState,
+  handleAutoReconnect
+};

package/src/services/rithmic-broker/client.js

@@ -211,7 +211,7 @@ class RithmicBrokerClient extends EventEmitter {
    */
   async getContracts() {
     const result = await this._request('getContracts', { propfirmKey: this.propfirmKey });
-    if (result.error) return { success: false, contracts: [] };
+    if (result.error) return { success: false, contracts: [], error: result.error };
     return result.payload || { success: true, contracts: [] };
   }
 

package/src/services/rithmic-broker/daemon-reconnect.js

@@ -0,0 +1,312 @@
+/**
+ * Daemon Reconnection Module
+ * 
+ * Handles connection monitoring and smart reconnection with rate limiting.
+ * Designed to avoid API quota exhaustion (Rithmic limit: 2000 GetAccounts calls)
+ * 
+ * Key principles:
+ * - Never spam reconnection attempts
+ * - Reuse cached accounts (no fetchAccounts on reconnect)
+ * - Rate limit: 1 attempt per hour, max 10 per day
+ */
+
+'use strict';
+
+const fs = require('fs');
+
+// Rate limiting configuration
+const RECONNECT_CONFIG = {
+  MIN_INTERVAL_MS: 3600000,    // 1 hour minimum between attempts
+  MAX_PER_DAY: 10,             // Max 10 reconnects per 24h
+  HEALTH_CHECK_INTERVAL: 30000, // Check every 30s
+  RESTORE_RETRY_DELAY: 5000,   // 5s between restore attempts
+  RESTORE_MAX_ATTEMPTS: 3,     // Max 3 attempts on restore
+};
+
+/**
+ * ReconnectManager - Manages connection monitoring and reconnection
+ */
+class ReconnectManager {
+  constructor(daemon, logger) {
+    this.daemon = daemon;
+    this.log = logger;
+    this.healthCheckTimer = null;
+    
+    // Rate limiting state per propfirm
+    this.reconnectState = new Map(); // propfirmKey -> { lastAttempt, countToday, resetTime }
+  }
+
+  /**
+   * Start health check loop
+   */
+  startHealthCheck() {
+    if (this.healthCheckTimer) clearInterval(this.healthCheckTimer);
+    
+    this.healthCheckTimer = setInterval(() => {
+      this._checkAllConnections();
+    }, RECONNECT_CONFIG.HEALTH_CHECK_INTERVAL);
+    
+    this.log('INFO', 'Health check started', { interval: RECONNECT_CONFIG.HEALTH_CHECK_INTERVAL });
+  }
+
+  /**
+   * Stop health check loop
+   */
+  stopHealthCheck() {
+    if (this.healthCheckTimer) {
+      clearInterval(this.healthCheckTimer);
+      this.healthCheckTimer = null;
+    }
+  }
+
+  /**
+   * Check all connections health
+   */
+  _checkAllConnections() {
+    for (const [propfirmKey, conn] of this.daemon.connections) {
+      this._checkConnection(propfirmKey, conn);
+    }
+  }
+
+  /**
+   * Check single connection health
+   */
+  _checkConnection(propfirmKey, conn) {
+    const service = conn.service;
+    
+    // No service = not connected
+    if (!service) {
+      if (conn.status !== 'disconnected' && conn.status !== 'reconnecting') {
+        conn.status = 'disconnected';
+        this._broadcastStatus(propfirmKey, 'disconnected');
+      }
+      return;
+    }
+    
+    // Check if ORDER_PLANT is alive
+    const isAlive = service.orderConn?.isConnected && 
+                    service.orderConn?.connectionState === 'LOGGED_IN';
+    
+    if (!isAlive && conn.status === 'connected') {
+      this.log('WARN', 'Health check: connection lost', { propfirm: propfirmKey });
+      conn.status = 'disconnected';
+      this._broadcastStatus(propfirmKey, 'disconnected');
+      
+      // Attempt reconnect if we have credentials
+      if (conn.credentials) {
+        this._attemptReconnect(propfirmKey, conn);
+      }
+    } else if (isAlive && conn.status !== 'connected') {
+      conn.status = 'connected';
+      this._broadcastStatus(propfirmKey, 'connected');
+    }
+  }
+
+  /**
+   * Setup connection event monitoring for a service
+   */
+  setupConnectionMonitoring(propfirmKey, service) {
+    const conn = this.daemon.connections.get(propfirmKey);
+    if (!conn) return;
+
+    service.on('disconnected', ({ plant, code, reason }) => {
+      this.log('WARN', 'Service disconnected', { propfirm: propfirmKey, plant, code, reason });
+      conn.status = 'disconnected';
+      this._broadcastStatus(propfirmKey, 'disconnected', { code, reason });
+    });
+
+    service.on('reconnecting', () => {
+      this.log('INFO', 'Service reconnecting', { propfirm: propfirmKey });
+      conn.status = 'reconnecting';
+      this._broadcastStatus(propfirmKey, 'reconnecting');
+    });
+
+    service.on('reconnected', ({ accounts }) => {
+      this.log('INFO', 'Service reconnected', { propfirm: propfirmKey });
+      conn.status = 'connected';
+      conn.connectedAt = new Date().toISOString();
+      if (accounts) conn.accounts = accounts;
+      this._broadcastStatus(propfirmKey, 'connected');
+    });
+
+    service.on('reconnectFailed', ({ error }) => {
+      this.log('WARN', 'Service reconnect failed', { propfirm: propfirmKey, error });
+      // Don't change status - let health check handle it
+    });
+  }
+
+  /**
+   * Attempt reconnection with rate limiting
+   */
+  async _attemptReconnect(propfirmKey, conn) {
+    // Check rate limits
+    if (!this._canReconnect(propfirmKey)) {
+      this.log('WARN', 'Reconnect rate limited', { propfirm: propfirmKey });
+      this._broadcastStatus(propfirmKey, 'rate_limited', { 
+        message: 'Reconnection rate limited. Try again later or run "hqx login".' 
+      });
+      return;
+    }
+
+    conn.status = 'reconnecting';
+    this._broadcastStatus(propfirmKey, 'reconnecting');
+    this._recordReconnectAttempt(propfirmKey);
+
+    this.log('INFO', 'Attempting reconnect', { propfirm: propfirmKey });
+
+    try {
+      // Disconnect old service
+      if (conn.service) {
+        try { await conn.service.disconnect(); } catch (e) { /* ignore */ }
+      }
+
+      // Create new service and login WITH cached accounts (no API call for accounts)
+      const Service = this.daemon.loadRithmicService();
+      const service = new Service(propfirmKey);
+
+      const result = await service.login(conn.credentials.username, conn.credentials.password, {
+        skipFetchAccounts: true,
+        cachedAccounts: conn.accounts
+      });
+
+      if (result.success) {
+        this.log('INFO', 'Reconnect successful', { propfirm: propfirmKey });
+        
+        conn.service = service;
+        conn.status = 'connected';
+        conn.connectedAt = new Date().toISOString();
+        // Keep existing accounts (from cache)
+        
+        this.daemon._setupPnLUpdates(propfirmKey, service);
+        this.setupConnectionMonitoring(propfirmKey, service);
+        this.daemon._saveState();
+        
+        this._broadcastStatus(propfirmKey, 'connected');
+      } else {
+        this.log('WARN', 'Reconnect failed', { propfirm: propfirmKey, error: result.error });
+        conn.status = 'disconnected';
+        this._broadcastStatus(propfirmKey, 'disconnected', { error: result.error });
+      }
+    } catch (err) {
+      this.log('ERROR', 'Reconnect error', { propfirm: propfirmKey, error: err.message });
+      conn.status = 'disconnected';
+      this._broadcastStatus(propfirmKey, 'disconnected', { error: err.message });
+    }
+  }
+
+  /**
+   * Check if we can attempt reconnection (rate limiting)
+   */
+  _canReconnect(propfirmKey) {
+    const now = Date.now();
+    let state = this.reconnectState.get(propfirmKey);
+    
+    if (!state) {
+      state = { lastAttempt: 0, countToday: 0, resetTime: now };
+      this.reconnectState.set(propfirmKey, state);
+    }
+
+    // Reset daily counter
+    if (now - state.resetTime > 86400000) {
+      state.countToday = 0;
+      state.resetTime = now;
+    }
+
+    // Check minimum interval
+    if (now - state.lastAttempt < RECONNECT_CONFIG.MIN_INTERVAL_MS) {
+      return false;
+    }
+
+    // Check daily limit
+    if (state.countToday >= RECONNECT_CONFIG.MAX_PER_DAY) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Record a reconnect attempt
+   */
+  _recordReconnectAttempt(propfirmKey) {
+    const state = this.reconnectState.get(propfirmKey) || { 
+      lastAttempt: 0, 
+      countToday: 0, 
+      resetTime: Date.now() 
+    };
+    
+    state.lastAttempt = Date.now();
+    state.countToday++;
+    this.reconnectState.set(propfirmKey, state);
+  }
+
+  /**
+   * Restore connections from state with retry logic
+   */
+  async restoreConnections(stateFile) {
+    if (!fs.existsSync(stateFile)) return;
+
+    try {
+      const data = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
+      
+      for (const saved of data.connections || []) {
+        if (!saved.credentials || !saved.propfirmKey) continue;
+
+        this.log('INFO', 'Restoring connection', { propfirm: saved.propfirmKey });
+        
+        let success = false;
+        let attempts = 0;
+
+        while (!success && attempts < RECONNECT_CONFIG.RESTORE_MAX_ATTEMPTS) {
+          attempts++;
+          
+          const result = await this.daemon._handleLogin({
+            ...saved.credentials,
+            propfirmKey: saved.propfirmKey,
+            cachedAccounts: saved.accounts  // Use cached accounts!
+          }, null);
+
+          if (result.payload?.success) {
+            success = true;
+            this.log('INFO', 'Connection restored', { propfirm: saved.propfirmKey });
+          } else {
+            this.log('WARN', 'Restore attempt failed', {
+              propfirm: saved.propfirmKey,
+              attempt: attempts,
+              error: result.payload?.error || result.error
+            });
+
+            if (attempts < RECONNECT_CONFIG.RESTORE_MAX_ATTEMPTS) {
+              await new Promise(r => setTimeout(r, RECONNECT_CONFIG.RESTORE_RETRY_DELAY));
+            }
+          }
+        }
+
+        if (!success) {
+          this.log('WARN', 'Failed to restore, storing for later', { propfirm: saved.propfirmKey });
+          this.daemon.connections.set(saved.propfirmKey, {
+            service: null,
+            credentials: saved.credentials,
+            connectedAt: null,
+            accounts: saved.accounts || [],
+            status: 'disconnected',
+          });
+        }
+      }
+    } catch (e) {
+      this.log('ERROR', 'Restore failed', { error: e.message });
+    }
+  }
+
+  /**
+   * Broadcast connection status to CLI clients
+   */
+  _broadcastStatus(propfirmKey, status, extra = {}) {
+    this.daemon._broadcast({
+      type: 'connectionStatus',
+      payload: { propfirmKey, status, ...extra }
+    });
+  }
+}
+
+module.exports = { ReconnectManager, RECONNECT_CONFIG };

package/src/services/rithmic-broker/daemon.js

@@ -5,6 +5,11 @@
  * Survives CLI restarts/updates. Only stops on explicit logout or reboot.
  * 
  * Communication: WebSocket server on port 18765
+ * 
+ * Key features:
+ * - Persistent connections (no disconnect on CLI restart)
+ * - Smart reconnection with rate limiting (max 10/day)
+ * - Cached accounts (no repeated API calls)
  */
 
 'use strict';
@@ -13,6 +18,7 @@ const WebSocket = require('ws');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { ReconnectManager } = require('./daemon-reconnect');
 
 // Paths
 const BROKER_DIR = path.join(os.homedir(), '.hqx', 'rithmic-broker');
@@ -45,9 +51,15 @@ class RithmicBrokerDaemon {
   constructor() {
     this.wss = null;
     this.clients = new Set();
-    this.connections = new Map(); // propfirmKey -> { service, credentials, connectedAt, accounts }
+    this.connections = new Map(); // propfirmKey -> { service, credentials, connectedAt, accounts, status }
     this.pnlCache = new Map();    // accountId -> { pnl, openPnl, closedPnl, balance, updatedAt }
     this.running = false;
+    
+    // Reconnection manager (handles health checks & reconnection with rate limiting)
+    this.reconnectManager = new ReconnectManager(this, log);
+    
+    // Expose loadRithmicService for ReconnectManager
+    this.loadRithmicService = loadRithmicService;
   }
 
   async start() {
@@ -56,7 +68,8 @@ class RithmicBrokerDaemon {
     if (!fs.existsSync(BROKER_DIR)) fs.mkdirSync(BROKER_DIR, { recursive: true });
     fs.writeFileSync(PID_FILE, String(process.pid));
     
-    await this._restoreState();
+    // Restore connections from state (with cached accounts - no API spam)
+    await this.reconnectManager.restoreConnections(STATE_FILE);
     
     this.wss = new WebSocket.Server({ port: BROKER_PORT, host: '127.0.0.1' });
     this.wss.on('connection', (ws) => this._handleClient(ws));
@@ -67,13 +80,21 @@ class RithmicBrokerDaemon {
     
     process.on('SIGTERM', () => this.stop());
     process.on('SIGINT', () => this.stop());
+    
+    // Auto-save state every 30s
     setInterval(() => this._saveState(), 30000);
+    
+    // Start health check (monitoring + rate-limited reconnection)
+    this.reconnectManager.startHealthCheck();
   }
 
   async stop() {
     log('INFO', 'Daemon stopping...');
     this.running = false;
     
+    // Stop health check
+    this.reconnectManager.stopHealthCheck();
+    
     for (const [key, conn] of this.connections) {
       try { if (conn.service?.disconnect) await conn.service.disconnect(); } 
       catch (e) { log('WARN', 'Disconnect error', { propfirm: key, error: e.message }); }
@@ -138,18 +159,22 @@ class RithmicBrokerDaemon {
   _getStatus() {
     const conns = [];
     for (const [key, conn] of this.connections) {
+      const isAlive = conn.service?.orderConn?.isConnected && 
+                      conn.service?.orderConn?.connectionState === 'LOGGED_IN';
       conns.push({
         propfirmKey: key,
         propfirm: conn.service?.propfirm?.name || key,
         connectedAt: conn.connectedAt,
         accountCount: conn.accounts?.length || 0,
+        status: conn.status || (isAlive ? 'connected' : 'disconnected'),
+        isAlive,
       });
     }
     return { running: this.running, pid: process.pid, uptime: process.uptime(), connections: conns };
   }
 
   async _handleLogin(payload, requestId) {
-    const { propfirmKey, username, password } = payload;
+    const { propfirmKey, username, password, cachedAccounts } = payload;
     if (!propfirmKey || !username || !password) {
       return { error: 'Missing credentials', requestId };
     }
@@ -165,20 +190,30 @@ class RithmicBrokerDaemon {
     const Service = loadRithmicService();
     const service = new Service(propfirmKey);
     
-    log('INFO', 'Logging in...', { propfirm: propfirmKey });
-    const result = await service.login(username, password);
+    log('INFO', 'Logging in...', { propfirm: propfirmKey, hasCachedAccounts: !!cachedAccounts });
+    
+    // Login with optional cached accounts (skips fetchAccounts API call)
+    const loginOptions = cachedAccounts ? { skipFetchAccounts: true, cachedAccounts } : {};
+    const result = await service.login(username, password, loginOptions);
     
     if (result.success) {
+      // Use cached accounts if provided, otherwise use result from login
+      const accounts = cachedAccounts || result.accounts || [];
+      
       this.connections.set(propfirmKey, {
         service,
         credentials: { username, password },
         connectedAt: new Date().toISOString(),
-        accounts: result.accounts || [],
+        accounts,
+        status: 'connected',
       });
+      
       this._setupPnLUpdates(propfirmKey, service);
+      this.reconnectManager.setupConnectionMonitoring(propfirmKey, service);
       this._saveState();
-      log('INFO', 'Login successful', { propfirm: propfirmKey, accounts: result.accounts?.length });
-      return { type: 'loginResult', payload: { success: true, accounts: result.accounts }, requestId };
+      
+      log('INFO', 'Login successful', { propfirm: propfirmKey, accounts: accounts.length });
+      return { type: 'loginResult', payload: { success: true, accounts }, requestId };
     }
     
     log('WARN', 'Login failed', { propfirm: propfirmKey, error: result.error });
@@ -226,8 +261,14 @@ class RithmicBrokerDaemon {
   async _handleGetAccounts(requestId) {
     const allAccounts = [];
     for (const [propfirmKey, conn] of this.connections) {
+      // Include accounts even if service is temporarily disconnected (from cache)
       for (const acc of conn.accounts || []) {
-        allAccounts.push({ ...acc, propfirmKey, propfirm: conn.service.propfirm?.name || propfirmKey });
+        allAccounts.push({ 
+          ...acc, 
+          propfirmKey, 
+          propfirm: conn.service?.propfirm?.name || propfirmKey,
+          connectionStatus: conn.status
+        });
       }
     }
     return { type: 'accounts', payload: { accounts: allAccounts }, requestId };
@@ -258,8 +299,15 @@ class RithmicBrokerDaemon {
 
   async _handleGetContracts(payload, requestId) {
     const conn = this.connections.get(payload.propfirmKey);
-    if (!conn?.service) return { error: 'Not connected', requestId };
-    return { type: 'contracts', payload: await conn.service.getContracts(), requestId };
+    if (!conn?.service) return { error: 'Not connected to broker', requestId };
+    
+    try {
+      const result = await conn.service.getContracts();
+      return { type: 'contracts', payload: result, requestId };
+    } catch (err) {
+      log('ERROR', 'getContracts failed', { propfirm: payload.propfirmKey, error: err.message });
+      return { type: 'contracts', payload: { success: false, error: err.message, contracts: [] }, requestId };
+    }
   }
 
   async _handleSearchContracts(payload, requestId) {
@@ -274,26 +322,23 @@ class RithmicBrokerDaemon {
     return { type: 'credentials', payload: conn.service.getRithmicCredentials?.() || null, requestId };
   }
 
+  /**
+   * Save state including accounts (for reconnection without API calls)
+   */
   _saveState() {
-    const state = { connections: [] };
+    const state = { connections: [], savedAt: new Date().toISOString() };
     for (const [key, conn] of this.connections) {
-      if (conn.credentials) state.connections.push({ propfirmKey: key, credentials: conn.credentials });
+      if (conn.credentials) {
+        state.connections.push({ 
+          propfirmKey: key, 
+          credentials: conn.credentials,
+          accounts: conn.accounts || [],  // Save accounts to avoid fetchAccounts on restore
+          connectedAt: conn.connectedAt
+        });
+      }
     }
     try { fs.writeFileSync(STATE_FILE, JSON.stringify(state)); } catch (e) { /* ignore */ }
   }
-
-  async _restoreState() {
-    if (!fs.existsSync(STATE_FILE)) return;
-    try {
-      const data = JSON.parse(fs.readFileSync(STATE_FILE, 'utf8'));
-      for (const conn of data.connections || []) {
-        if (conn.credentials && conn.propfirmKey) {
-          log('INFO', 'Restoring connection...', { propfirm: conn.propfirmKey });
-          await this._handleLogin({ ...conn.credentials, propfirmKey: conn.propfirmKey }, null);
-        }
-      }
-    } catch (e) { log('WARN', 'Restore failed', { error: e.message }); }
-  }
 }
 
 // Main entry point