hedgequantx 2.9.144 → 2.9.146

package/package.json

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

package/src/lib/smart-logs-engine.js

@@ -358,45 +358,7 @@ class SmartLogsEngine {
     
     const t = [];
     
-    // === BULLISH FLOW ===
-    if (isBull) {
-      t.push({ type: 'bullish', message: `${S} ${P} heavy paper on the bid | Size lifting offers ${D} | Tape running` });
-      t.push({ type: 'bullish', message: `${SL} bid refreshing at ${P} | ${OFI} | Buyers in control` });
-      t.push({ type: 'bullish', message: `Large prints on ${S} ${P} | ${VPIN} toxic | Institutions lifting` });
-      t.push({ type: 'bullish', message: `${S} squeeze building at ${P} | Shorts underwater | ${D} accelerating` });
-      t.push({ type: 'bullish', message: `Block buyer ${SL} ${P} | ${IMB} buy tape | Iceberg absorbing supply` });
-      t.push({ type: 'bullish', message: `${S} momentum ignition at ${P} | DOM stacked bid | Offers lifted` });
-      t.push({ type: 'bullish', message: `Aggressive buying ${S} at ${P} | ${ZS} | Sellers capitulating` });
-      t.push({ type: 'bullish', message: `${S} ${P} bid wall holding | ${D} | Passive offers exhausted` });
-      t.push({ type: 'bullish', message: `Dark pool bid ${SL} ${P} | ${VPIN} | Smart money accumulating` });
-      t.push({ type: 'bullish', message: `${S} footprint bullish at ${P} | ${tps} tps | Institutional absorption` });
-    }
-    // === BEARISH FLOW ===
-    else if (isBear) {
-      t.push({ type: 'bearish', message: `${S} ${P} heavy paper on offer | Size hitting bids ${D} | Tape dumping` });
-      t.push({ type: 'bearish', message: `${SL} offer refreshing at ${P} | ${OFI} | Sellers in control` });
-      t.push({ type: 'bearish', message: `Large prints selling ${S} ${P} | ${VPIN} toxic | Institutions hitting` });
-      t.push({ type: 'bearish', message: `${S} breakdown at ${P} | Longs underwater | ${D} accelerating` });
-      t.push({ type: 'bearish', message: `Block seller ${SL} ${P} | ${IMB} sell tape | Iceberg absorbing demand` });
-      t.push({ type: 'bearish', message: `${S} momentum breakdown at ${P} | DOM stacked offer | Bids hit` });
-      t.push({ type: 'bearish', message: `Aggressive selling ${S} at ${P} | ${ZS} | Buyers capitulating` });
-      t.push({ type: 'bearish', message: `${S} ${P} offer wall capping | ${D} | Passive bids exhausted` });
-      t.push({ type: 'bearish', message: `Dark pool offer ${SL} ${P} | ${VPIN} | Smart money distributing` });
-      t.push({ type: 'bearish', message: `${S} footprint bearish at ${P} | ${tps} tps | Institutional distribution` });
-    }
-    // === NEUTRAL/CHOP ===
-    else {
-      t.push({ type: 'analysis', message: `${S} ${P} two-way paper | ${D} flat | Locals making markets` });
-      t.push({ type: 'analysis', message: `${SL} chopping at ${P} | Spread ${spd}t | No directional flow` });
-      t.push({ type: 'analysis', message: `${S} balanced at ${P} | ${VPIN} | Waiting for size to show` });
-      t.push({ type: 'analysis', message: `Range trade ${S} ${P} | Book symmetric | Mean reversion active` });
-      t.push({ type: 'analysis', message: `${S} consolidating at ${P} | ${ZS} | No edge either side` });
-      t.push({ type: 'analysis', message: `Quiet tape ${SL} ${P} | ${tps} tps | Institutions on sidelines` });
-      t.push({ type: 'analysis', message: `${S} ${P} fair value auction | ${D} | Algos scalping spread` });
-      t.push({ type: 'analysis', message: `Flow balanced ${S} at ${P} | ${OFI} | Awaiting catalyst` });
-    }
-    
-    // === HQX-2B: Liquidity Sweep ===
+    // === HQX-2B: Liquidity Sweep Strategy ===
     if (isHQX2B) {
       if (phase === 'ready' && zones > 0) {
         t.push({ type: 'signal', message: `${chalk.green.bold('SWEEP')} ${S} ${P} | ${zones} stops triggered | Reversal confirmed` });
@@ -406,12 +368,24 @@ class SmartLogsEngine {
         t.push({ type: 'analysis', message: `${S} ${P} approaching liquidity | ${zones} clusters mapped | Sweep imminent` });
         t.push({ type: 'analysis', message: `Stop hunt setup ${SL} ${P} | ${swings} swings | Watching penetration` });
         t.push({ type: 'analysis', message: `${S} zone test at ${P} | ${zones} targets | Monitoring rejection` });
+      } else if (isBull) {
+        t.push({ type: 'bullish', message: `${S} ${P} bid absorption | ${D} | Stops below being hunted` });
+        t.push({ type: 'bullish', message: `${SL} liquidity building at ${P} | Sweep setup forming | ${swings} pivots` });
+        t.push({ type: 'bullish', message: `Institutional bid ${S} ${P} | ${OFI} | Retail shorts trapped` });
+        t.push({ type: 'bullish', message: `${S} false breakdown at ${P} | ${D} | Smart money buying dip` });
+      } else if (isBear) {
+        t.push({ type: 'bearish', message: `${S} ${P} offer absorption | ${D} | Stops above being hunted` });
+        t.push({ type: 'bearish', message: `${SL} liquidity building at ${P} | Sweep setup forming | ${swings} pivots` });
+        t.push({ type: 'bearish', message: `Institutional offer ${S} ${P} | ${OFI} | Retail longs trapped` });
+        t.push({ type: 'bearish', message: `${S} false breakout at ${P} | ${D} | Smart money selling rally` });
       } else {
-        t.push({ type: 'system', message: `Mapping ${S} structure at ${P} | ${bars} bars | ${swings} swings | Zones` });
-        t.push({ type: 'system', message: `${SL} topology at ${P} | ${tickCount} ticks | Detecting clusters` });
+        t.push({ type: 'system', message: `Mapping ${S} structure at ${P} | ${bars} bars | ${swings} swings` });
+        t.push({ type: 'system', message: `${SL} scanning zones at ${P} | ${tickCount} ticks | Detecting clusters` });
+        t.push({ type: 'analysis', message: `${S} ${P} consolidating | ${D} | Liquidity pooling at extremes` });
+        t.push({ type: 'analysis', message: `${SL} range at ${P} | Stops accumulating | Sweep pending` });
       }
     }
-    // === ULTRA-SCALPING: Quant/Stats ===
+    // === ULTRA-SCALPING: Quant/Stats Strategy ===
     else {
       if (phase === 'ready') {
         t.push({ type: 'signal', message: `${chalk.green.bold('EDGE')} ${S} ${P} | ${ZS} breach | ${VPIN} | Execute` });
@@ -421,9 +395,19 @@ class SmartLogsEngine {
         t.push({ type: 'analysis', message: `${S} ${P} factors building | ${ZS} | Threshold proximity` });
         t.push({ type: 'analysis', message: `${SL} edge forming at ${P} | ${VPIN} | Monitoring` });
         t.push({ type: 'analysis', message: `Statistical setup ${S} ${P} | ${OFI} | Alignment ${IMB}` });
+      } else if (isBull) {
+        t.push({ type: 'bullish', message: `${S} ${P} heavy paper bid | ${D} | ${VPIN} rising` });
+        t.push({ type: 'bullish', message: `${SL} ${P} ${ZS} bullish | ${OFI} | Mean reversion long` });
+        t.push({ type: 'bullish', message: `${S} momentum ${P} | ${IMB} buy | Quant signal building` });
+      } else if (isBear) {
+        t.push({ type: 'bearish', message: `${S} ${P} heavy paper offer | ${D} | ${VPIN} rising` });
+        t.push({ type: 'bearish', message: `${SL} ${P} ${ZS} bearish | ${OFI} | Mean reversion short` });
+        t.push({ type: 'bearish', message: `${S} momentum ${P} | ${IMB} sell | Quant signal building` });
       } else {
         t.push({ type: 'system', message: `Calibrating ${S} models at ${P} | ${bars} bars | Computing factors` });
         t.push({ type: 'system', message: `${SL} tick analysis at ${P} | ${tickCount} samples | ${tps} tps` });
+        t.push({ type: 'analysis', message: `${S} ${P} neutral | ${ZS} | ${VPIN} | Awaiting edge` });
+        t.push({ type: 'analysis', message: `${SL} range at ${P} | ${D} | Statistical mean reversion` });
       }
     }
     

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/multi-symbol-executor.js

@@ -286,16 +286,22 @@ const executeMultiSymbol = async ({ service, account, contracts, config, strateg
   let startingPnL = null;
   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 (sync for RithmicService, async for BrokerClient)
+      let pnlData = null;
+      if (service.getAccountPnL) {
+        const result = service.getAccountPnL(accId);
+        pnlData = result && result.then ? await result : result; // Handle both sync/async
+      }
+      
+      if (pnlData && pnlData.pnl !== null && pnlData.pnl !== undefined && !isNaN(pnlData.pnl)) {
         if (startingPnL === null) startingPnL = pnlData.pnl;
-        globalStats.pnl = pnlData.pnl - startingPnL;
+        const newPnl = pnlData.pnl - startingPnL;
+        if (!isNaN(newPnl)) globalStats.pnl = newPnl;
       }
       
-      // Check positions (less frequent - every 10s instead of 2s)
+      // Check positions (less frequent - every 10s)
       if (Date.now() % 10000 < 2000) {
         const posResult = await service.getPositions(accId);
         if (posResult.success && posResult.positions) {
@@ -306,13 +312,15 @@ const executeMultiSymbol = async ({ service, account, contracts, config, strateg
         }
       }
       
-      // Risk checks
-      if (globalStats.pnl >= dailyTarget) {
-        stopReason = 'target'; running = false;
-        ui.addLog('fill_win', `TARGET REACHED! +$${globalStats.pnl.toFixed(2)}`);
-      } else if (globalStats.pnl <= -maxRisk) {
-        stopReason = 'risk'; running = false;
-        ui.addLog('fill_loss', `MAX RISK! -$${Math.abs(globalStats.pnl).toFixed(2)}`);
+      // Risk checks (only if pnl is valid)
+      if (!isNaN(globalStats.pnl)) {
+        if (globalStats.pnl >= dailyTarget) {
+          stopReason = 'target'; running = false;
+          ui.addLog('fill_win', `TARGET REACHED! +$${globalStats.pnl.toFixed(2)}`);
+        } else if (globalStats.pnl <= -maxRisk) {
+          stopReason = 'risk'; running = false;
+          ui.addLog('fill_loss', `MAX RISK! -$${Math.abs(globalStats.pnl).toFixed(2)}`);
+        }
       }
     } catch (e) { /* silent */ }
   };
@@ -321,23 +329,29 @@ const executeMultiSymbol = async ({ service, account, contracts, config, strateg
   const pnlInterval = setInterval(() => { if (running) pollPnL(); }, 2000);
   pollPnL();
   
-  // Live analysis logs every 1 second (rotates through symbols)
+  // Live analysis logs every 5 seconds (rotates through symbols with data)
   let liveLogSymbolIndex = 0;
-  let lastLiveLogSecond = 0;
+  let lastLiveLogTime = 0;
   const liveLogInterval = setInterval(() => {
     if (!running) return;
-    const now = Math.floor(Date.now() / 1000);
-    if (now === lastLiveLogSecond) return;
-    lastLiveLogSecond = now;
+    const now = Date.now();
+    if (now - lastLiveLogTime < 5000) return; // Every 5 seconds
+    lastLiveLogTime = now;
     
-    // Get a symbol to log (rotate through all)
+    // Get symbols with tick data (skip symbols without data)
     const symbolCodes = Array.from(symbolData.keys());
     if (symbolCodes.length === 0) return;
     
-    const symbolCode = symbolCodes[liveLogSymbolIndex % symbolCodes.length];
-    liveLogSymbolIndex++;
+    // Find next symbol with data
+    let attempts = 0;
+    let symbolCode, data;
+    do {
+      symbolCode = symbolCodes[liveLogSymbolIndex % symbolCodes.length];
+      liveLogSymbolIndex++;
+      data = symbolData.get(symbolCode);
+      attempts++;
+    } while ((!data || data.stats.tickCount === 0) && attempts < symbolCodes.length);
     
-    const data = symbolData.get(symbolCode);
     if (!data) return;
     
     const state = data.strategy.getAnalysisState?.(symbolCode, data.stats.lastPrice);
@@ -353,10 +367,13 @@ const executeMultiSymbol = async ({ service, account, contracts, config, strateg
       tickCount: data.stats.tickCount || 0,
     };
     
-    logsEngine.setSymbol(symbolCode);
-    const log = logsEngine.getLog(logState);
-    ui.addLog(log.type, log.message);
-    if (log.logToSession) sessionLogger.log('ANALYSIS', `[${symbolCode}] ${log.message}`);
+    // Only log if we have meaningful data
+    if (logState.price > 0 || logState.tickCount > 0) {
+      logsEngine.setSymbol(symbolCode);
+      const log = logsEngine.getLog(logState);
+      ui.addLog(log.type, log.message);
+      if (log.logToSession) sessionLogger.log('ANALYSIS', `[${symbolCode}] ${log.message}`);
+    }
   }, 1000);
   
   // Key handler

package/src/pages/algo/ui.js

@@ -188,9 +188,9 @@ class AlgoUI {
     // Row 1: Account | Symbol(s)
     const accountName = String(stats.accountName || 'N/A').substring(0, 40);
     const isMultiSymbol = stats.symbolCount && stats.symbolCount > 1;
-    const symbolDisplay = isMultiSymbol 
-      ? `${stats.symbolCount} symbols` 
-      : String(stats.symbol || stats.symbols || 'N/A').substring(0, 35);
+    // Show actual symbols list, truncate if too long
+    const symbolsStr = String(stats.symbols || stats.symbol || 'N/A');
+    const symbolDisplay = symbolsStr.length > 35 ? symbolsStr.substring(0, 32) + '...' : symbolsStr;
     const r1c1 = buildCell('Account', accountName, chalk.cyan, colL);
     const r1c2 = buildCell(isMultiSymbol ? 'Symbols' : 'Symbol', symbolDisplay, chalk.yellow, colR);
     row(r1c1.padded, r1c2.padded);

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

@@ -232,13 +232,13 @@ class RithmicBrokerClient extends EventEmitter {
    */
   getRithmicCredentials() {
     // Sync call - return cached credentials
-    // For async, use _request('getRithmicCredentials')
-    return this.credentials ? {
+    if (!this.credentials) return null;
+    return {
       userId: this.credentials.username,
       password: this.credentials.password,
       systemName: this.propfirm?.systemName || 'Apex',
-      gateway: 'wss://rituz.rithmic.com:443',
-    } : null;
+      gateway: 'wss://rprotocol.rithmic.com:443',
+    };
   }
 
   /**

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 };
@@ -274,26 +315,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