hedgequantx 2.9.48 → 2.9.50

package/package.json

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

package/src/app.js

@@ -77,7 +77,7 @@ const refreshStats = async () => {
 
   try {
     const allAccounts = await connections.getAllAccounts();
-    // Filter active accounts: status === 0 (ProjectX) OR status === 'active' (Rithmic) OR no status
+    // Filter active accounts: status === 'active' (Rithmic) OR status === 0 OR no status
     const activeAccounts = allAccounts.filter(acc => 
       acc.status === 0 || acc.status === 'active' || acc.status === undefined || acc.status === null
     );

package/src/config/propfirms.js

@@ -15,14 +15,7 @@ const PROPFIRMS = {
     rithmicSystem: 'Apex',
     wsEndpoint: 'wss://ritpa11120.11.rithmic.com:443',
   },
-  topsteptrader: {
-    id: 'topsteptrader',
-    name: 'TopstepTrader',
-    displayName: 'TopstepTrader',
-    platform: 'Rithmic',
-    rithmicSystem: 'TopstepTrader',
-    wsEndpoint: 'wss://ritpa11120.11.rithmic.com:443'
-  },
+
   mes_capital: {
     id: 'mes-capital',
     name: 'MES Capital',

package/src/lib/data.js

@@ -1,328 +1,259 @@
 /**
  * =============================================================================
- * MARKET DATA FEED - SignalR Real-Time Data
+ * MARKET DATA FEED - Rithmic TICKER_PLANT Real-Time Data
  * =============================================================================
- * Connects to ProjectX Gateway RTC for real-time market data
+ * Connects to Rithmic TICKER_PLANT for real-time market data
  * 
  * Events emitted:
  * - tick: Quote/trade updates (price, bid, ask, volume)
- * - quote: Quote updates only
- * - trade: Trade executions only
- * - depth: DOM/Level 2 updates
  * - connected: Connection established
  * - disconnected: Connection lost
  * - error: Connection error
- * 
- * SOURCE: Based on ProjectX Gateway RTC API
  */
 
 'use strict';
 
 const EventEmitter = require('events');
-const { HubConnectionBuilder, HttpTransportType, LogLevel } = require('@microsoft/signalr');
-
-// Inline PROPFIRMS config for RTC URLs (standalone module)
-// RTC URL pattern: api.xxx.com -> rtc.xxx.com
-const PROPFIRMS = {
-  topstep: { gatewayApi: 'api.topstepx.com' },
-  alpha_futures: { gatewayApi: 'api.alphafutures.projectx.com' },
-  tickticktrader: { gatewayApi: 'api.tickticktrader.projectx.com' },
-  bulenox: { gatewayApi: 'api.bulenox.projectx.com' },
-  tradeday: { gatewayApi: 'api.tradeday.projectx.com' },
-  blusky: { gatewayApi: 'api.blusky.projectx.com' },
-  goat_futures: { gatewayApi: 'api.goatfutures.projectx.com' },
-  futures_desk: { gatewayApi: 'api.thefuturesdesk.projectx.com' },
-  daytraders: { gatewayApi: 'api.daytraders.projectx.com' },
-  e8_futures: { gatewayApi: 'api.e8futures.projectx.com' },
-  blue_guardian: { gatewayApi: 'api.blueguardianfutures.projectx.com' },
-  futures_elite: { gatewayApi: 'api.futureselite.projectx.com' },
-  fxify: { gatewayApi: 'api.fxify.projectx.com' },
-  hola_prime: { gatewayApi: 'api.holaprime.projectx.com' },
-  top_one_futures: { gatewayApi: 'api.toponefutures.projectx.com' },
-  funding_futures: { gatewayApi: 'api.fundingfutures.projectx.com' },
-  tx3_funding: { gatewayApi: 'api.tx3funding.projectx.com' },
-  lucid_trading: { gatewayApi: 'api.lucidtrading.projectx.com' },
-  tradeify: { gatewayApi: 'api.tradeify.projectx.com' }
-};
+const { RithmicConnection } = require('../services/rithmic/connection');
+const { proto } = require('../services/rithmic/protobuf');
+const { REQ, RES, STREAM, RITHMIC_ENDPOINTS, RITHMIC_SYSTEMS } = require('../services/rithmic/constants');
 
 // =============================================================================
-// MARKET DATA FEED CLASS
+// MARKET DATA FEED CLASS (Rithmic TICKER_PLANT)
 // =============================================================================
 
 class MarketDataFeed extends EventEmitter {
   constructor(options = {}) {
     super();
     
-    this.propfirmKey = (options.propfirm || 'topstep').toLowerCase().replace(/\s+/g, '_');
     this.connection = null;
     this.connected = false;
     this.subscriptions = new Set();
-    this.reconnectAttempts = 0;
-    this.maxReconnectAttempts = 5;
+    this.credentials = null;
+    this.config = null;
   }
 
   /**
-   * Get market hub URL for propfirm
-   * Pattern: api.xxx.com -> rtc.xxx.com
+   * Connect to Rithmic TICKER_PLANT
+   * @param {Object} rithmicCredentials - Credentials from RithmicService.getRithmicCredentials()
    */
-  _getMarketHubUrl(propfirmKey) {
-    const propfirm = PROPFIRMS[propfirmKey] || PROPFIRMS.topstep;
-    
-    if (propfirm.gatewayApi) {
-      // Convert api.xxx.com to rtc.xxx.com
-      const rtcHost = propfirm.gatewayApi.replace(/^api\./, 'rtc.');
-      return `https://${rtcHost}/hubs/market`;
+  async connect(rithmicCredentials) {
+    if (this.connected) return;
+
+    if (!rithmicCredentials || !rithmicCredentials.userId || !rithmicCredentials.password) {
+      throw new Error('Rithmic credentials required (userId, password, systemName, gateway)');
     }
-    
-    // Fallback for topstep
-    return 'https://rtc.topstepx.com/hubs/market';
-  }
 
-  /**
-   * Connect to market data hub
-   */
-  async connect(token, propfirmKey, contractId = null) {
-    if (this.connected) return;
+    this.credentials = rithmicCredentials;
+    this.connection = new RithmicConnection();
+
+    this.config = {
+      uri: rithmicCredentials.gateway || RITHMIC_ENDPOINTS.CHICAGO,
+      systemName: rithmicCredentials.systemName || RITHMIC_SYSTEMS.PAPER,
+      userId: rithmicCredentials.userId,
+      password: rithmicCredentials.password,
+      appName: 'HQX-CLI',
+      appVersion: '2.0.0',
+    };
 
-    this.propfirmKey = propfirmKey || this.propfirmKey;
-    this.token = token;
-    const hubUrl = this._getMarketHubUrl(this.propfirmKey);
-    
-    // CRITICAL: Token must be in URL query string (same as HQX-TG and Python SDK)
-    const urlWithToken = `${hubUrl}?access_token=${encodeURIComponent(this.token)}`;
-    
     try {
-      // CRITICAL: skipNegotiation=true + WebSockets transport is REQUIRED for ProjectX/TopstepX
-      // This is how the Python SDK and HQX-TG connect successfully
-      this.connection = new HubConnectionBuilder()
-        .withUrl(urlWithToken, {
-          skipNegotiation: true,
-          transport: HttpTransportType.WebSockets
-        })
-        .withAutomaticReconnect({
-          nextRetryDelayInMilliseconds: (ctx) => {
-            if (ctx.previousRetryCount >= this.maxReconnectAttempts) return null;
-            return Math.min(1000 * Math.pow(2, ctx.previousRetryCount), 30000);
-          }
-        })
-        .configureLogging(LogLevel.Warning)
-        .build();
-
-      // Set server timeout and keepalive
-      this.connection.serverTimeoutInMilliseconds = 60000; // 60s
-      this.connection.keepAliveIntervalInMilliseconds = 15000; // 15s
-
-      this._setupEventHandlers();
-      await this.connection.start();
-      
-      this.connected = true;
-      this.reconnectAttempts = 0;
-      this.emit('connected');
+      await this.connection.connect(this.config);
 
-      if (contractId) {
-        await this.subscribe(null, contractId);
-      }
-    } catch (error) {
-      this.connected = false;
-      this.emit('error', error);
-      throw error;
-    }
-  }
+      // Setup message handler for market data
+      this.connection.on('message', (msg) => this._handleMessage(msg));
 
-  /**
-   * Setup SignalR event handlers
-   */
-  _setupEventHandlers() {
-    if (!this.connection) return;
-
-    // Quote updates - GatewayQuote receives (contractId, data)
-    this.connection.on('GatewayQuote', (contractId, data) => {
-      // Handle both (contractId, data) and single object formats
-      const quote = data || contractId;
-      const cid = data ? contractId : (quote.symbol || quote.symbolId);
-      
-      const tick = {
-        type: 'quote',
-        contractId: cid,
-        symbol: quote.symbolName || quote.symbol || cid,
-        price: quote.lastPrice,
-        bid: quote.bestBid,
-        ask: quote.bestAsk,
-        change: quote.change,
-        changePercent: quote.changePercent,
-        open: quote.open,
-        high: quote.high,
-        low: quote.low,
-        volume: quote.volume,
-        timestamp: quote.timestamp ? new Date(quote.timestamp).getTime() : Date.now()
-      };
-      this.emit('tick', tick);
-      this.emit('quote', tick);
-    });
-
-    // Trade executions - GatewayTrade receives (contractId, data[])
-    this.connection.on('GatewayTrade', (contractId, trades) => {
-      // Handle both formats
-      const tradeList = Array.isArray(trades) ? trades : (Array.isArray(contractId) ? contractId : [trades || contractId]);
-      const cid = typeof contractId === 'string' ? contractId : null;
-      
-      for (const trade of tradeList) {
-        if (!trade) continue;
-        const tick = {
-          type: 'trade',
-          contractId: cid || trade.symbolId,
-          price: trade.price,
-          volume: trade.volume,
-          side: trade.type === 0 ? 'buy' : 'sell',
-          lastTradeSide: trade.type === 0 ? 'buy' : 'sell',
-          timestamp: trade.timestamp ? new Date(trade.timestamp).getTime() : Date.now()
-        };
-        this.emit('tick', tick);
-        this.emit('trade', tick);
-      }
-    });
+      // Login to TICKER_PLANT
+      return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          reject(new Error('TICKER_PLANT login timeout'));
+        }, 15000);
 
-    // DOM updates - GatewayDepth receives (contractId, data[])
-    this.connection.on('GatewayDepth', (contractId, depthData) => {
-      // Handle both formats
-      const depthList = Array.isArray(depthData) ? depthData : (Array.isArray(contractId) ? contractId : [depthData || contractId]);
-      const cid = typeof contractId === 'string' ? contractId : null;
-      
-      for (const depth of depthList) {
-        if (!depth) continue;
-        const domUpdate = {
-          type: 'depth',
-          contractId: cid,
-          price: depth.price,
-          volume: depth.volume || depth.totalVolume,
-          currentVolume: depth.currentVolume,
-          side: depth.type === 0 ? 'bid' : 'ask',
-          timestamp: depth.timestamp ? new Date(depth.timestamp).getTime() : Date.now()
-        };
-        this.emit('depth', domUpdate);
-        this.emit('dom', domUpdate);
-      }
-    });
-
-    // Connection state
-    this.connection.onreconnecting((error) => {
-      this.connected = false;
-      this.emit('reconnecting', error);
-    });
-
-    this.connection.onreconnected((connectionId) => {
-      this.connected = true;
-      this.reconnectAttempts = 0;
-      this.emit('reconnected', connectionId);
-      this._resubscribeAll();
-    });
-
-    this.connection.onclose((error) => {
-      this.connected = false;
-      // Emit detailed error for debugging
-      let errMsg = 'unknown';
-      if (error) {
-        errMsg = error.message || error.toString();
-        if (error.stack) errMsg += ' | ' + error.stack.split('\n')[0];
-      }
-      this.emit('disconnected', new Error(errMsg));
-    });
+        this.connection.once('loggedIn', () => {
+          clearTimeout(timeout);
+          this.connected = true;
+          this.emit('connected');
+          resolve(true);
+        });
+
+        this.connection.once('loginFailed', (data) => {
+          clearTimeout(timeout);
+          reject(new Error(data.message || 'TICKER_PLANT login failed'));
+        });
+
+        this.connection.login('TICKER_PLANT');
+      });
+    } catch (e) {
+      this.emit('error', e);
+      throw e;
+    }
   }
 
   /**
-   * Subscribe to contract market data
+   * Subscribe to market data for a symbol
+   * @param {string} symbol - Symbol name (e.g., 'ESH6')
+   * @param {string} exchange - Exchange (default: 'CME')
    */
-  async subscribe(symbol, contractId) {
-    if (!this.connection || !this.connected) {
-      throw new Error('Not connected');
+  async subscribe(symbol, exchange = 'CME') {
+    if (!this.connected) {
+      throw new Error('Not connected to TICKER_PLANT');
     }
 
-    const id = contractId || symbol;
-    
+    const key = `${symbol}:${exchange}`;
+    if (this.subscriptions.has(key)) return;
+
     try {
-      await this.connection.invoke('SubscribeContractQuotes', id);
-      await this.connection.invoke('SubscribeContractTrades', id);
-      await this.connection.invoke('SubscribeContractMarketDepth', id);
-      this.subscriptions.add(id);
-      this.emit('subscribed', { symbol, contractId: id });
-    } catch (error) {
-      this.emit('error', new Error(`Subscribe failed: ${error.message}`));
-      throw error;
+      // Subscribe to LAST_TRADE and BBO (Best Bid/Offer)
+      // UpdateBits: 1 = LAST_TRADE, 2 = BBO, 3 = BOTH
+      this.connection.send('RequestMarketDataUpdate', {
+        templateId: REQ.MARKET_DATA,
+        symbol: symbol,
+        exchange: exchange,
+        request: 1, // SUBSCRIBE
+        updateBits: 3, // LAST_TRADE + BBO
+      });
+
+      this.subscriptions.add(key);
+      this.emit('subscribed', `${symbol}:${exchange}`);
+    } catch (e) {
+      this.emit('error', e);
+      throw e;
     }
   }
 
   /**
-   * Unsubscribe from contract
+   * Unsubscribe from market data for a symbol
    */
-  async unsubscribe(contractId) {
-    if (!this.connection || !this.connected) return;
+  async unsubscribe(symbol, exchange = 'CME') {
+    if (!this.connected) return;
+
+    const key = `${symbol}:${exchange}`;
+    if (!this.subscriptions.has(key)) return;
 
     try {
-      await this.connection.invoke('UnsubscribeContractQuotes', contractId);
-      await this.connection.invoke('UnsubscribeContractTrades', contractId);
-      await this.connection.invoke('UnsubscribeContractMarketDepth', contractId);
-      this.subscriptions.delete(contractId);
-      this.emit('unsubscribed', { contractId });
-    } catch (error) {
-      // Silently handle
+      this.connection.send('RequestMarketDataUpdate', {
+        templateId: REQ.MARKET_DATA,
+        symbol: symbol,
+        exchange: exchange,
+        request: 2, // UNSUBSCRIBE
+      });
+
+      this.subscriptions.delete(key);
+    } catch (e) {
+      // Ignore unsubscribe errors
     }
   }
 
   /**
-   * Resubscribe after reconnect
+   * Disconnect from TICKER_PLANT
    */
-  async _resubscribeAll() {
-    for (const contractId of this.subscriptions) {
+  async disconnect() {
+    // Unsubscribe from all
+    for (const key of this.subscriptions) {
+      const [symbol, exchange] = key.split(':');
+      await this.unsubscribe(symbol, exchange);
+    }
+
+    if (this.connection) {
       try {
-        await this.connection.invoke('SubscribeContractQuotes', contractId);
-        await this.connection.invoke('SubscribeContractTrades', contractId);
-        await this.connection.invoke('SubscribeContractMarketDepth', contractId);
-      } catch (error) {
-        // Continue
+        await this.connection.disconnect();
+      } catch (e) {
+        // Ignore
       }
     }
+
+    this.connection = null;
+    this.connected = false;
+    this.subscriptions.clear();
+    this.emit('disconnected');
   }
 
   /**
-   * Disconnect with timeout to prevent hanging
+   * Handle incoming messages from TICKER_PLANT
    */
-  async disconnect() {
-    if (this.connection) {
-      const timeoutPromise = new Promise(r => setTimeout(r, 3000));
-      
-      try {
-        // Race between disconnect and timeout
-        await Promise.race([
-          (async () => {
-            for (const contractId of this.subscriptions) {
-              try { await this.unsubscribe(contractId); } catch {}
-            }
-            await this.connection.stop();
-          })(),
-          timeoutPromise
-        ]);
-      } catch (error) {
-        // Ignore disconnect errors
-      }
-      
-      this.connection = null;
-      this.connected = false;
-      this.subscriptions.clear();
+  _handleMessage(msg) {
+    const { templateId, data } = msg;
+
+    // Debug: log all message template IDs
+    if (!this._seenTemplates) this._seenTemplates = new Set();
+    if (!this._seenTemplates.has(templateId)) {
+      this._seenTemplates.add(templateId);
+      this.emit('debug', `New message type: templateId=${templateId}`);
+    }
+
+    switch (templateId) {
+      case RES.MARKET_DATA:
+        // Subscription confirmed
+        this.emit('debug', 'Market data subscription confirmed');
+        break;
+
+      case STREAM.LAST_TRADE:
+        this._handleLastTrade(data);
+        break;
+
+      case STREAM.BBO:
+        this._handleBBO(data);
+        break;
+
+      default:
+        // Log unknown messages for debugging
+        if (templateId && !this._seenTemplates.has(`logged_${templateId}`)) {
+          this._seenTemplates.add(`logged_${templateId}`);
+        }
+        break;
     }
   }
 
   /**
-   * Check connection status
+   * Handle LastTrade message
    */
-  isConnected() {
-    return this.connected && this.connection?.state === 'Connected';
+  _handleLastTrade(data) {
+    try {
+      const trade = proto.decode('LastTrade', data);
+      
+      const tick = {
+        type: 'trade',
+        symbol: trade.symbol,
+        exchange: trade.exchange,
+        price: trade.tradePrice,
+        size: trade.tradeSize,
+        volume: trade.volume,
+        side: trade.aggressor === 1 ? 'buy' : trade.aggressor === 2 ? 'sell' : 'unknown',
+        timestamp: Date.now(),
+        ssboe: trade.ssboe,
+        usecs: trade.usecs,
+      };
+
+      this.emit('tick', tick);
+    } catch (e) {
+      // Ignore decode errors
+    }
   }
 
   /**
-   * Get active subscriptions
+   * Handle BestBidOffer message
    */
-  getSubscriptions() {
-    return Array.from(this.subscriptions);
+  _handleBBO(data) {
+    try {
+      const bbo = proto.decode('BestBidOffer', data);
+      
+      const tick = {
+        type: 'quote',
+        symbol: bbo.symbol,
+        exchange: bbo.exchange,
+        bid: bbo.bidPrice,
+        bidSize: bbo.bidSize,
+        ask: bbo.askPrice,
+        askSize: bbo.askSize,
+        price: bbo.bidPrice && bbo.askPrice ? (bbo.bidPrice + bbo.askPrice) / 2 : null,
+        timestamp: Date.now(),
+        ssboe: bbo.ssboe,
+        usecs: bbo.usecs,
+      };
+
+      this.emit('tick', tick);
+    } catch (e) {
+      // Ignore decode errors
+    }
   }
 }
 

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

@@ -13,7 +13,7 @@ const { SupervisionEngine } = require('../../services/ai-supervision');
 /**
  * Execute algo strategy with market data
  * @param {Object} params - Execution parameters
- * @param {Object} params.service - Trading service (Rithmic/ProjectX)
+ * @param {Object} params.service - Rithmic trading service
  * @param {Object} params.account - Account object
  * @param {Object} params.contract - Contract object
  * @param {Object} params.config - Algo config (contracts, target, risk, showName)
@@ -77,8 +77,8 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
   const strategy = new StrategyClass({ tickSize });
   strategy.initialize(contractId, tickSize);
   
-  // Initialize Market Data Feed
-  const marketFeed = new MarketDataFeed({ propfirm: account.propfirm });
+  // Initialize Market Data Feed (Rithmic TICKER_PLANT)
+  const marketFeed = new MarketDataFeed();
   
   // Log startup
   ui.addLog('info', `Strategy: ${strategyName}${supervisionEnabled ? ' + AI' : ''}`);
@@ -93,7 +93,20 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
   
   // Handle strategy signals
   strategy.on('signal', async (signal) => {
-    if (!running || pendingOrder || currentPosition !== 0) return;
+    ui.addLog('info', `SIGNAL DETECTED: ${signal.direction?.toUpperCase()}`);
+    
+    if (!running) {
+      ui.addLog('info', 'Signal ignored: not running');
+      return;
+    }
+    if (pendingOrder) {
+      ui.addLog('info', 'Signal ignored: order pending');
+      return;
+    }
+    if (currentPosition !== 0) {
+      ui.addLog('info', `Signal ignored: position open (${currentPosition})`);
+      return;
+    }
     
     let { direction, entry, stopLoss, takeProfit, confidence } = signal;
     let orderSize = contracts;
@@ -185,34 +198,96 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
   });
   
   // Handle market data ticks
+  let lastPrice = null;
+  let lastBid = null;
+  let lastAsk = null;
+  let ticksPerSecond = 0;
+  let lastTickSecond = Math.floor(Date.now() / 1000);
+  
   marketFeed.on('tick', (tick) => {
     tickCount++;
     const latencyStart = Date.now();
+    const currentSecond = Math.floor(Date.now() / 1000);
+    
+    // Count ticks per second
+    if (currentSecond === lastTickSecond) {
+      ticksPerSecond++;
+    } else {
+      ticksPerSecond = 1;
+      lastTickSecond = currentSecond;
+    }
     
     aiContext.recentTicks.push(tick);
     if (aiContext.recentTicks.length > aiContext.maxTicks) aiContext.recentTicks.shift();
     
+    // Smart logs for tick flow
+    const price = tick.price || tick.tradePrice;
+    const bid = tick.bid || tick.bidPrice;
+    const ask = tick.ask || tick.askPrice;
+    
+    // Log first tick
+    if (tickCount === 1) {
+      ui.addLog('info', `First tick received @ ${price?.toFixed(2) || 'N/A'}`);
+      ui.addLog('info', `Tick type: ${tick.type || 'unknown'}`);
+    }
+    
+    // Log price changes
+    if (price && lastPrice && price !== lastPrice) {
+      const direction = price > lastPrice ? 'UP' : 'DOWN';
+      const change = Math.abs(price - lastPrice).toFixed(2);
+      if (tickCount <= 10 || tickCount % 50 === 0) {
+        ui.addLog('info', `Price ${direction} ${change} -> ${price.toFixed(2)}`);
+      }
+    }
+    
+    // Log bid/ask spread
+    if (bid && ask && (bid !== lastBid || ask !== lastAsk)) {
+      const spread = (ask - bid).toFixed(2);
+      if (tickCount <= 5) {
+        ui.addLog('info', `Spread: ${spread} (Bid: ${bid.toFixed(2)} / Ask: ${ask.toFixed(2)})`);
+      }
+    }
+    
+    lastPrice = price;
+    lastBid = bid;
+    lastAsk = ask;
+    
     strategy.processTick({
       contractId: tick.contractId || contractId,
-      price: tick.price, bid: tick.bid, ask: tick.ask,
-      volume: tick.volume || 1, side: tick.lastTradeSide || 'unknown',
+      price: price, bid: bid, ask: ask,
+      volume: tick.volume || tick.size || 1, 
+      side: tick.side || tick.lastTradeSide || 'unknown',
       timestamp: tick.timestamp || Date.now()
     });
     
     stats.latency = Date.now() - latencyStart;
-    if (tickCount % 100 === 0) ui.addLog('info', `Tick #${tickCount} @ ${tick.price?.toFixed(2) || 'N/A'}`);
+    
+    // Periodic status logs
+    if (tickCount === 10) ui.addLog('info', `Receiving ticks... (${ticksPerSecond}/sec)`);
+    if (tickCount === 50) ui.addLog('info', `50 ticks processed, strategy analyzing...`);
+    if (tickCount % 200 === 0) {
+      ui.addLog('info', `Tick #${tickCount} @ ${price?.toFixed(2) || 'N/A'} | ${ticksPerSecond}/sec`);
+    }
   });
   
-  marketFeed.on('connected', () => { stats.connected = true; ui.addLog('connected', 'Market data connected!'); });
+  marketFeed.on('connected', () => { 
+    stats.connected = true; 
+    ui.addLog('connected', 'Market data connected!');
+    ui.addLog('info', 'Subscribing to market data...');
+  });
+  marketFeed.on('subscribed', (symbol) => ui.addLog('info', `Subscribed to ${symbol}`));
+  marketFeed.on('debug', (msg) => ui.addLog('info', msg));
   marketFeed.on('error', (err) => ui.addLog('error', `Market: ${err.message}`));
   marketFeed.on('disconnected', () => { stats.connected = false; ui.addLog('error', 'Market disconnected'); });
   
-  // Connect to market data
+  // Connect to market data (Rithmic TICKER_PLANT)
   try {
-    const token = service.token || service.getToken?.();
-    const propfirmKey = (account.propfirm || 'topstep').toLowerCase().replace(/\s+/g, '_');
-    await marketFeed.connect(token, propfirmKey, contractId);
-    await marketFeed.subscribe(symbolName, contractId);
+    const rithmicCredentials = service.getRithmicCredentials?.();
+    if (!rithmicCredentials) {
+      throw new Error('Rithmic credentials not available');
+    }
+    await marketFeed.connect(rithmicCredentials);
+    await marketFeed.subscribe(symbolName, contract.exchange || 'CME');
   } catch (e) {
     ui.addLog('error', `Failed to connect: ${e.message}`);
   }

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

@@ -77,8 +77,8 @@ const launchCopyTrading = async (config) => {
   const strategy = new StrategyClass({ tickSize });
   strategy.initialize(contractId, tickSize);
   
-  // Initialize Market Data Feed
-  const marketFeed = new MarketDataFeed({ propfirm: leadAccount.propfirm });
+  // Initialize Market Data Feed (Rithmic TICKER_PLANT)
+  const marketFeed = new MarketDataFeed();
   
   // Log startup
   ui.addLog('info', `Lead: ${leadName} | Followers: ${followers.length}`);
@@ -186,12 +186,14 @@ const launchCopyTrading = async (config) => {
   marketFeed.on('error', (err) => ui.addLog('error', `Market: ${err.message}`));
   marketFeed.on('disconnected', () => { stats.connected = false; ui.addLog('error', 'Disconnected'); });
   
-  // Connect to market data
+  // Connect to market data (Rithmic TICKER_PLANT)
   try {
-    const token = leadService.token || leadService.getToken?.();
-    const pk = (leadAccount.propfirm || 'topstep').toLowerCase().replace(/\s+/g, '_');
-    await marketFeed.connect(token, pk, contractId);
-    await marketFeed.subscribe(symbolName, contractId);
+    const rithmicCredentials = leadService.getRithmicCredentials?.();
+    if (!rithmicCredentials) {
+      throw new Error('Rithmic credentials not available');
+    }
+    await marketFeed.connect(rithmicCredentials);
+    await marketFeed.subscribe(symbolName, contract.exchange || 'CME');
   } catch (e) {
     ui.addLog('error', `Connect failed: ${e.message}`);
   }

package/src/pages/algo/copy-trading.js

@@ -40,7 +40,7 @@ const copyTradingMenu = async () => {
     return;
   }
   
-  // Filter active accounts: status === 0 (ProjectX) OR status === 'active' (Rithmic) OR no status
+  // Filter active accounts: status === 'active' (Rithmic) OR status === 0 OR no status
   const activeAccounts = allAccounts.filter(acc => 
     acc.status === 0 || acc.status === 'active' || acc.status === undefined || acc.status === null
   );

package/src/pages/algo/custom-strategy.js

@@ -46,7 +46,7 @@ const customStrategyMenu = async (service) => {
   
   if (!allAccounts?.length) { spinner.fail('No accounts found'); await prompts.waitForEnter(); return; }
   
-  // Filter active accounts: status === 0 (ProjectX) OR status === 'active' (Rithmic) OR no status
+  // Filter active accounts: status === 'active' (Rithmic) OR status === 0 OR no status
   const activeAccounts = allAccounts.filter(acc => 
     acc.status === 0 || acc.status === 'active' || acc.status === undefined || acc.status === null
   );

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

@@ -41,7 +41,7 @@ const oneAccountMenu = async (service) => {
     return;
   }
   
-  // Filter active accounts: status === 0 (ProjectX) OR status === 'active' (Rithmic) OR no status
+  // Filter active accounts: status === 'active' (Rithmic) OR status === 0 OR no status
   const activeAccounts = allAccounts.filter(acc => 
     acc.status === 0 || acc.status === 'active' || acc.status === undefined || acc.status === null
   );