hedgequantx 2.9.142 → 2.9.144

package/package.json

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

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

@@ -214,15 +214,25 @@ const SYMBOLS = {
   // S&P
   ES: { name: 'ES', floor: 'Spooz', asset: 'index', slang: 'the Spooz' },
   MES: { name: 'MES', floor: 'Micro S&P', asset: 'index', slang: 'micro spooz' },
+  // Dow
+  YM: { name: 'YM', floor: 'Dow', asset: 'index', slang: 'the Dow' },
+  MYM: { name: 'MYM', floor: 'Micro Dow', asset: 'index', slang: 'mini Dow' },
   // Crude
   CL: { name: 'CL', floor: 'Crude', asset: 'energy', slang: 'oil' },
   MCL: { name: 'MCL', floor: 'Micro Crude', asset: 'energy', slang: 'micro crude' },
   // Gold
   GC: { name: 'GC', floor: 'Gold', asset: 'metals', slang: 'yellow metal' },
   MGC: { name: 'MGC', floor: 'Micro Gold', asset: 'metals', slang: 'micro gold' },
+  '1OZ': { name: '1OZ', floor: 'Micro Gold', asset: 'metals', slang: '1oz gold' },
+  // Silver
+  SI: { name: 'SI', floor: 'Silver', asset: 'metals', slang: 'silver' },
+  SIL: { name: 'SIL', floor: 'Micro Silver', asset: 'metals', slang: 'micro silver' },
   // Bonds
   ZB: { name: 'ZB', floor: 'Bonds', asset: 'rates', slang: 'long bond' },
   ZN: { name: 'ZN', floor: '10Y', asset: 'rates', slang: 'tens' },
+  // Russell
+  RTY: { name: 'RTY', floor: 'Russell', asset: 'index', slang: 'small caps' },
+  M2K: { name: 'M2K', floor: 'Micro Russell', asset: 'index', slang: 'micro russell' },
   // Default
   DEFAULT: { name: 'Contract', floor: 'Futures', asset: 'futures', slang: 'contract' }
 };

package/src/menus/connect.js

@@ -6,7 +6,7 @@ const chalk = require('chalk');
 const ora = require('ora');
 
 const { connections } = require('../services');
-const { RithmicService } = require('../services/rithmic');
+const { RithmicBrokerClient, manager: brokerManager } = require('../services/rithmic-broker');
 const { PROPFIRM_CHOICES } = require('../config');
 const { getLogoWidth, centerText, prepareStdin, displayBanner , clearScreen } = require('../ui');
 const { validateUsername, validatePassword } = require('../security');
@@ -87,19 +87,29 @@ const rithmicMenu = async () => {
   const credentials = await loginPrompt(selectedPropfirm.name);
   if (!credentials) return null;
 
-  const spinner = ora({ text: 'CONNECTING TO RITHMIC...', color: 'yellow' }).start();
+  const spinner = ora({ text: 'STARTING BROKER DAEMON...', color: 'yellow' }).start();
 
   try {
-    const service = new RithmicService(selectedPropfirm.key);
-    const result = await service.login(credentials.username, credentials.password);
+    // Ensure broker daemon is running
+    const daemonResult = await brokerManager.ensureRunning();
+    if (!daemonResult.success) {
+      spinner.fail('FAILED TO START BROKER DAEMON');
+      console.log(chalk.yellow(`  → ${daemonResult.error}`));
+      await new Promise(r => setTimeout(r, 3000));
+      return null;
+    }
+    
+    spinner.text = 'CONNECTING TO RITHMIC...';
+    const client = new RithmicBrokerClient(selectedPropfirm.key);
+    const result = await client.login(credentials.username, credentials.password);
 
     if (result.success) {
       spinner.text = 'FETCHING ACCOUNTS...';
-      const accResult = await service.getTradingAccounts();
-      connections.add('rithmic', service, service.propfirm.name);
-      spinner.succeed(`CONNECTED TO ${service.propfirm.name.toUpperCase()} (${accResult.accounts?.length || 0} ACCOUNTS)`);
+      const accResult = await client.getTradingAccounts();
+      connections.add('rithmic', client, client.propfirm.name || selectedPropfirm.name);
+      spinner.succeed(`CONNECTED TO ${selectedPropfirm.name.toUpperCase()} (${accResult.accounts?.length || 0} ACCOUNTS)`);
       await new Promise(r => setTimeout(r, 1500));
-      return service;
+      return client;
     } else {
       // Detailed error messages for common Rithmic issues
       const err = (result.error || '').toLowerCase();

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

@@ -358,32 +358,36 @@ const executeAlgo = async ({ service, account, contract, config, strategy: strat
     ui.addLog('error', `Failed to connect: ${e.message}`);
   }
   
+  // P&L polling - uses CACHED data (NO API CALLS to avoid Rithmic rate limits)
   const pollPnL = async () => {
     try {
-      const accountResult = await service.getTradingAccounts();
-      if (accountResult.success && accountResult.accounts) {
-        const acc = accountResult.accounts.find(a => a.accountId === account.accountId);
-        if (acc && acc.profitAndLoss !== undefined) {
-          if (startingPnL === null) startingPnL = acc.profitAndLoss;
-          stats.pnl = acc.profitAndLoss - startingPnL;
-          if (stats.pnl !== 0) strategy.recordTradeResult(stats.pnl);
-        }
+      // 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) {
+        if (startingPnL === null) startingPnL = pnlData.pnl;
+        stats.pnl = pnlData.pnl - startingPnL;
+        if (stats.pnl !== 0) strategy.recordTradeResult(stats.pnl);
       }
       
-      const posResult = await service.getPositions(account.accountId);
-      if (posResult.success && posResult.positions) {
-        const pos = posResult.positions.find(p => {
-          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;
+      // Check positions (less frequent - every 10s to reduce API calls)
+      if (Date.now() % 10000 < 2000) {
+        const posResult = await service.getPositions(accId);
+        if (posResult.success && posResult.positions) {
+          const pos = posResult.positions.find(p => {
+            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;
+          }
         }
       }
       

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

@@ -282,24 +282,27 @@ const executeMultiSymbol = async ({ service, account, contracts, config, strateg
     ui.addLog('error', `Failed to connect: ${e.message}`);
   }
   
-  // P&L polling
+  // P&L polling - uses CACHED data (NO API CALLS)
+  let startingPnL = null;
   const pollPnL = async () => {
     try {
-      const accountResult = await service.getTradingAccounts();
-      if (accountResult.success && accountResult.accounts) {
-        const acc = accountResult.accounts.find(a => a.accountId === account.accountId);
-        if (acc && acc.profitAndLoss !== undefined) {
-          // For multi-symbol, we track total P&L
-          globalStats.pnl = acc.profitAndLoss;
-        }
+      // 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) {
+        if (startingPnL === null) startingPnL = pnlData.pnl;
+        globalStats.pnl = pnlData.pnl - startingPnL;
       }
       
-      // Check positions per symbol
-      const posResult = await service.getPositions(account.accountId);
-      if (posResult.success && posResult.positions) {
-        for (const [sym, data] of symbolData) {
-          const pos = posResult.positions.find(p => (p.contractId || p.symbol || '').includes(sym));
-          data.stats.position = pos?.quantity || 0;
+      // Check positions (less frequent - every 10s instead of 2s)
+      if (Date.now() % 10000 < 2000) {
+        const posResult = await service.getPositions(accId);
+        if (posResult.success && posResult.positions) {
+          for (const [sym, data] of symbolData) {
+            const pos = posResult.positions.find(p => (p.contractId || p.symbol || '').includes(sym));
+            data.stats.position = pos?.quantity || 0;
+          }
         }
       }
       

package/src/services/rithmic/index.js

@@ -269,6 +269,23 @@ class RithmicService extends EventEmitter {
 
   async getTradingAccounts() { return getTradingAccounts(this); }
   async getPositions() { return getPositions(this); }
+  
+  /**
+   * Get cached P&L for an account (NO API CALL - from PNL_PLANT stream cache)
+   * @param {string} accountId - Account ID (rithmicAccountId)
+   * @returns {Object} { pnl, openPnl, closedPnl, balance }
+   */
+  getAccountPnL(accountId) {
+    const pnlData = this.accountPnL.get(accountId);
+    if (!pnlData) return { pnl: null, openPnl: null, closedPnl: null, balance: null };
+    return {
+      pnl: pnlData.dayPnl !== undefined ? pnlData.dayPnl : 
+           ((pnlData.openPositionPnl || 0) + (pnlData.closedPositionPnl || 0)),
+      openPnl: pnlData.openPositionPnl || 0,
+      closedPnl: pnlData.closedPositionPnl || 0,
+      balance: pnlData.accountBalance || null,
+    };
+  }
   async getOrders() { return getOrders(this); }
   async getOrderHistory(date) { return getOrderHistory(this, date); }
   async getOrderHistoryDates() { return getOrderHistoryDates(this); }
@@ -381,44 +398,26 @@ class RithmicService extends EventEmitter {
     return { success: true, stats };
   }
 
-  async getMarketStatus() {
-    const status = this.checkMarketHours();
-    return { success: true, isOpen: status.isOpen, message: status.message };
-  }
-
+  async getMarketStatus() { return { success: true, ...this.checkMarketHours() }; }
   getToken() { return this.loginInfo ? 'connected' : null; }
   getPropfirm() { return this.propfirmKey || 'apex'; }
-
   getRithmicCredentials() {
     if (!this.credentials) return null;
-    return {
-      userId: this.credentials.username,
-      password: this.credentials.password,
-      systemName: this.propfirm.systemName,
-      gateway: this.propfirm.gateway || RITHMIC_ENDPOINTS.CHICAGO,
-    };
+    return { userId: this.credentials.username, password: this.credentials.password,
+      systemName: this.propfirm.systemName, gateway: this.propfirm.gateway || RITHMIC_ENDPOINTS.CHICAGO };
   }
 
-  // ==================== MARKET HOURS ====================
-
   checkMarketHours() {
-    const now = new Date();
-    const utcDay = now.getUTCDay();
-    const utcHour = now.getUTCHours();
-
+    const now = new Date(), utcDay = now.getUTCDay(), utcHour = now.getUTCHours();
     const isDST = now.getTimezoneOffset() < Math.max(
       new Date(now.getFullYear(), 0, 1).getTimezoneOffset(),
-      new Date(now.getFullYear(), 6, 1).getTimezoneOffset()
-    );
-    const ctOffset = isDST ? 5 : 6;
-    const ctHour = (utcHour - ctOffset + 24) % 24;
+      new Date(now.getFullYear(), 6, 1).getTimezoneOffset());
+    const ctOffset = isDST ? 5 : 6, ctHour = (utcHour - ctOffset + 24) % 24;
     const ctDay = utcHour < ctOffset ? (utcDay + 6) % 7 : utcDay;
-
     if (ctDay === 6) return { isOpen: false, message: 'Market closed (Saturday)' };
-    if (ctDay === 0 && ctHour < 17) return { isOpen: false, message: 'Market opens Sunday 5:00 PM CT' };
-    if (ctDay === 5 && ctHour >= 16) return { isOpen: false, message: 'Market closed (Friday after 4PM CT)' };
-    if (ctHour === 16 && ctDay >= 1 && ctDay <= 4) return { isOpen: false, message: 'Daily maintenance (4:00-5:00 PM CT)' };
-    
+    if (ctDay === 0 && ctHour < 17) return { isOpen: false, message: 'Market opens Sunday 5PM CT' };
+    if (ctDay === 5 && ctHour >= 16) return { isOpen: false, message: 'Market closed (Friday 4PM CT)' };
+    if (ctHour === 16 && ctDay >= 1 && ctDay <= 4) return { isOpen: false, message: 'Daily maintenance' };
     return { isOpen: true, message: 'Market is open' };
   }
 

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

@@ -0,0 +1,300 @@
+/**
+ * RithmicBroker Client
+ * 
+ * Client for CLI to communicate with the RithmicBroker daemon.
+ * Provides same interface as RithmicService for seamless integration.
+ */
+
+'use strict';
+
+const WebSocket = require('ws');
+const EventEmitter = require('events');
+const { BROKER_PORT } = require('./daemon');
+const manager = require('./manager');
+
+/**
+ * RithmicBroker Client - connects to daemon via WebSocket
+ */
+class RithmicBrokerClient extends EventEmitter {
+  constructor(propfirmKey) {
+    super();
+    this.propfirmKey = propfirmKey;
+    this.ws = null;
+    this.connected = false;
+    this.requestId = 0;
+    this.pendingRequests = new Map();
+    this.credentials = null;
+    this.accounts = [];
+    this.propfirm = { name: propfirmKey };
+  }
+
+  /**
+   * Connect to daemon
+   */
+  async connect() {
+    if (this.connected) return { success: true };
+    
+    // Ensure daemon is running
+    const daemonStatus = await manager.ensureRunning();
+    if (!daemonStatus.success) {
+      return { success: false, error: daemonStatus.error || 'Failed to start daemon' };
+    }
+    
+    return new Promise((resolve) => {
+      this.ws = new WebSocket(`ws://127.0.0.1:${BROKER_PORT}`);
+      
+      const timeout = setTimeout(() => {
+        this.ws?.terminate();
+        resolve({ success: false, error: 'Connection timeout' });
+      }, 5000);
+      
+      this.ws.on('open', () => {
+        clearTimeout(timeout);
+        this.connected = true;
+        resolve({ success: true });
+      });
+      
+      this.ws.on('message', (data) => this._handleMessage(data));
+      
+      this.ws.on('close', () => {
+        this.connected = false;
+        this.emit('disconnected');
+      });
+      
+      this.ws.on('error', (err) => {
+        clearTimeout(timeout);
+        this.connected = false;
+        resolve({ success: false, error: err.message });
+      });
+    });
+  }
+
+  /**
+   * Handle incoming message from daemon
+   */
+  _handleMessage(data) {
+    try {
+      const msg = JSON.parse(data.toString());
+      
+      // Handle response to pending request
+      if (msg.requestId && this.pendingRequests.has(msg.requestId)) {
+        const { resolve } = this.pendingRequests.get(msg.requestId);
+        this.pendingRequests.delete(msg.requestId);
+        resolve(msg);
+        return;
+      }
+      
+      // Handle broadcast events
+      if (msg.type === 'pnlUpdate') this.emit('pnlUpdate', msg.payload);
+      if (msg.type === 'positionUpdate') this.emit('positionUpdate', msg.payload);
+      if (msg.type === 'trade') this.emit('trade', msg.payload);
+    } catch (e) { /* ignore parse errors */ }
+  }
+
+  /**
+   * Send request to daemon and wait for response
+   */
+  async _request(type, payload = {}, timeout = 30000) {
+    if (!this.connected) {
+      const conn = await this.connect();
+      if (!conn.success) return { error: conn.error };
+    }
+    
+    const requestId = String(++this.requestId);
+    
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(requestId);
+        resolve({ error: 'Request timeout' });
+      }, timeout);
+      
+      this.pendingRequests.set(requestId, {
+        resolve: (msg) => {
+          clearTimeout(timer);
+          resolve(msg);
+        }
+      });
+      
+      try {
+        this.ws.send(JSON.stringify({ type, payload, requestId }));
+      } catch (e) {
+        clearTimeout(timer);
+        this.pendingRequests.delete(requestId);
+        resolve({ error: e.message });
+      }
+    });
+  }
+
+  // ==================== RithmicService-compatible API ====================
+
+  /**
+   * Login to Rithmic via daemon
+   */
+  async login(username, password) {
+    const result = await this._request('login', {
+      propfirmKey: this.propfirmKey,
+      username,
+      password,
+    }, 60000);
+    
+    if (result.error) {
+      return { success: false, error: result.error };
+    }
+    
+    if (result.payload?.success) {
+      this.credentials = { username, password };
+      this.accounts = result.payload.accounts || [];
+      return { success: true, accounts: this.accounts, user: { userName: username } };
+    }
+    
+    return { success: false, error: result.payload?.error || 'Login failed' };
+  }
+
+  /**
+   * Get trading accounts
+   */
+  async getTradingAccounts() {
+    const result = await this._request('getAccounts');
+    if (result.error) return { success: false, accounts: [] };
+    
+    const accounts = (result.payload?.accounts || [])
+      .filter(a => a.propfirmKey === this.propfirmKey);
+    
+    return { success: true, accounts };
+  }
+
+  /**
+   * Get cached P&L (NO API CALL - from daemon cache)
+   */
+  async getAccountPnL(accountId) {
+    const result = await this._request('getPnL', { accountId });
+    return result.payload || { pnl: null };
+  }
+
+  /**
+   * Get positions
+   */
+  async getPositions() {
+    const result = await this._request('getPositions', { propfirmKey: this.propfirmKey });
+    if (result.error) return { success: false, positions: [] };
+    return result.payload || { success: true, positions: [] };
+  }
+
+  /**
+   * Place order
+   */
+  async placeOrder(orderData) {
+    const result = await this._request('placeOrder', {
+      propfirmKey: this.propfirmKey,
+      orderData,
+    }, 15000);
+    
+    if (result.error) return { success: false, error: result.error };
+    return result.payload || { success: false, error: 'No response' };
+  }
+
+  /**
+   * Cancel order
+   */
+  async cancelOrder(orderId) {
+    const result = await this._request('cancelOrder', {
+      propfirmKey: this.propfirmKey,
+      orderId,
+    });
+    
+    if (result.error) return { success: false, error: result.error };
+    return result.payload || { success: false, error: 'No response' };
+  }
+
+  /**
+   * Get contracts
+   */
+  async getContracts() {
+    const result = await this._request('getContracts', { propfirmKey: this.propfirmKey });
+    if (result.error) return { success: false, contracts: [] };
+    return result.payload || { success: true, contracts: [] };
+  }
+
+  /**
+   * Search contracts
+   */
+  async searchContracts(searchText) {
+    const result = await this._request('searchContracts', {
+      propfirmKey: this.propfirmKey,
+      searchText,
+    });
+    if (result.error) return { success: false, contracts: [] };
+    return result.payload || { success: true, contracts: [] };
+  }
+
+  /**
+   * Get Rithmic credentials for MarketDataFeed
+   */
+  getRithmicCredentials() {
+    // Sync call - return cached credentials
+    // For async, use _request('getRithmicCredentials')
+    return this.credentials ? {
+      userId: this.credentials.username,
+      password: this.credentials.password,
+      systemName: this.propfirm?.systemName || 'Apex',
+      gateway: 'wss://rituz.rithmic.com:443',
+    } : null;
+  }
+
+  /**
+   * Get async Rithmic credentials from daemon
+   */
+  async getRithmicCredentialsAsync() {
+    const result = await this._request('getRithmicCredentials', { propfirmKey: this.propfirmKey });
+    return result.payload || null;
+  }
+
+  /**
+   * Disconnect from daemon (does NOT stop daemon)
+   */
+  disconnect() {
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.connected = false;
+    this.credentials = null;
+    this.accounts = [];
+  }
+
+  /**
+   * Logout from Rithmic (stops daemon connection for this propfirm)
+   */
+  async logout() {
+    const result = await this._request('logout', { propfirmKey: this.propfirmKey });
+    this.disconnect();
+    return result.payload || { success: true };
+  }
+
+  // ==================== Compatibility methods ====================
+
+  getToken() { return this.connected ? 'broker-connected' : null; }
+  getPropfirm() { return this.propfirmKey; }
+  async getUser() { return { userName: this.credentials?.username }; }
+  
+  checkMarketHours() {
+    const now = new Date();
+    const utcDay = now.getUTCDay();
+    const utcHour = now.getUTCHours();
+    const isDST = now.getTimezoneOffset() < Math.max(
+      new Date(now.getFullYear(), 0, 1).getTimezoneOffset(),
+      new Date(now.getFullYear(), 6, 1).getTimezoneOffset()
+    );
+    const ctOffset = isDST ? 5 : 6;
+    const ctHour = (utcHour - ctOffset + 24) % 24;
+    const ctDay = utcHour < ctOffset ? (utcDay + 6) % 7 : utcDay;
+
+    if (ctDay === 6) return { isOpen: false, message: 'Market closed (Saturday)' };
+    if (ctDay === 0 && ctHour < 17) return { isOpen: false, message: 'Market opens Sunday 5:00 PM CT' };
+    if (ctDay === 5 && ctHour >= 16) return { isOpen: false, message: 'Market closed (Friday after 4PM CT)' };
+    if (ctHour === 16 && ctDay >= 1 && ctDay <= 4) return { isOpen: false, message: 'Daily maintenance' };
+    return { isOpen: true, message: 'Market is open' };
+  }
+}
+
+module.exports = { RithmicBrokerClient };

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

@@ -0,0 +1,305 @@
+/**
+ * RithmicBroker Daemon
+ * 
+ * Background process that maintains persistent Rithmic connections.
+ * Survives CLI restarts/updates. Only stops on explicit logout or reboot.
+ * 
+ * Communication: WebSocket server on port 18765
+ */
+
+'use strict';
+
+const WebSocket = require('ws');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Paths
+const BROKER_DIR = path.join(os.homedir(), '.hqx', 'rithmic-broker');
+const PID_FILE = path.join(BROKER_DIR, 'broker.pid');
+const LOG_FILE = path.join(BROKER_DIR, 'broker.log');
+const STATE_FILE = path.join(BROKER_DIR, 'state.json');
+const BROKER_PORT = 18765;
+
+// Lazy load RithmicService
+let RithmicService = null;
+const loadRithmicService = () => {
+  if (!RithmicService) {
+    ({ RithmicService } = require('../rithmic'));
+  }
+  return RithmicService;
+};
+
+// Logger
+const log = (level, msg, data = {}) => {
+  const ts = new Date().toISOString();
+  const line = `[${ts}] [${level}] ${msg} ${JSON.stringify(data)}\n`;
+  try { fs.appendFileSync(LOG_FILE, line); } catch (e) { /* ignore */ }
+  if (process.env.HQX_DEBUG === '1') console.log(`[Broker] [${level}] ${msg}`, data);
+};
+
+/**
+ * RithmicBroker Daemon Class
+ */
+class RithmicBrokerDaemon {
+  constructor() {
+    this.wss = null;
+    this.clients = new Set();
+    this.connections = new Map(); // propfirmKey -> { service, credentials, connectedAt, accounts }
+    this.pnlCache = new Map();    // accountId -> { pnl, openPnl, closedPnl, balance, updatedAt }
+    this.running = false;
+  }
+
+  async start() {
+    if (this.running) return;
+    
+    if (!fs.existsSync(BROKER_DIR)) fs.mkdirSync(BROKER_DIR, { recursive: true });
+    fs.writeFileSync(PID_FILE, String(process.pid));
+    
+    await this._restoreState();
+    
+    this.wss = new WebSocket.Server({ port: BROKER_PORT, host: '127.0.0.1' });
+    this.wss.on('connection', (ws) => this._handleClient(ws));
+    this.wss.on('error', (err) => log('ERROR', 'WSS error', { error: err.message }));
+    
+    this.running = true;
+    log('INFO', 'Daemon started', { pid: process.pid, port: BROKER_PORT });
+    
+    process.on('SIGTERM', () => this.stop());
+    process.on('SIGINT', () => this.stop());
+    setInterval(() => this._saveState(), 30000);
+  }
+
+  async stop() {
+    log('INFO', 'Daemon stopping...');
+    this.running = false;
+    
+    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 }); }
+    }
+    this.connections.clear();
+    
+    if (this.wss) {
+      for (const client of this.clients) client.close(1000, 'Daemon shutting down');
+      this.wss.close();
+    }
+    
+    if (fs.existsSync(PID_FILE)) fs.unlinkSync(PID_FILE);
+    if (fs.existsSync(STATE_FILE)) fs.unlinkSync(STATE_FILE);
+    
+    log('INFO', 'Daemon stopped');
+    process.exit(0);
+  }
+
+  _handleClient(ws) {
+    this.clients.add(ws);
+    log('DEBUG', 'Client connected', { total: this.clients.size });
+    
+    ws.on('message', async (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        const response = await this._handleMessage(msg);
+        ws.send(JSON.stringify(response));
+      } catch (e) {
+        ws.send(JSON.stringify({ error: e.message, requestId: null }));
+      }
+    });
+    
+    ws.on('close', () => { this.clients.delete(ws); });
+    ws.on('error', () => { this.clients.delete(ws); });
+  }
+
+  async _handleMessage(msg) {
+    const { type, payload = {}, requestId } = msg;
+    
+    const handlers = {
+      ping: () => ({ type: 'pong', requestId }),
+      status: () => ({ type: 'status', payload: this._getStatus(), requestId }),
+      login: () => this._handleLogin(payload, requestId),
+      logout: () => this._handleLogout(payload, requestId),
+      getAccounts: () => this._handleGetAccounts(requestId),
+      getPnL: () => this._handleGetPnL(payload, requestId),
+      getPositions: () => this._handleGetPositions(payload, requestId),
+      placeOrder: () => this._handlePlaceOrder(payload, requestId),
+      cancelOrder: () => this._handleCancelOrder(payload, requestId),
+      getContracts: () => this._handleGetContracts(payload, requestId),
+      searchContracts: () => this._handleSearchContracts(payload, requestId),
+      getRithmicCredentials: () => this._handleGetCredentials(payload, requestId),
+    };
+    
+    if (handlers[type]) {
+      try { return await handlers[type](); } 
+      catch (e) { return { error: e.message, requestId }; }
+    }
+    return { error: `Unknown type: ${type}`, requestId };
+  }
+
+  _getStatus() {
+    const conns = [];
+    for (const [key, conn] of this.connections) {
+      conns.push({
+        propfirmKey: key,
+        propfirm: conn.service?.propfirm?.name || key,
+        connectedAt: conn.connectedAt,
+        accountCount: conn.accounts?.length || 0,
+      });
+    }
+    return { running: this.running, pid: process.pid, uptime: process.uptime(), connections: conns };
+  }
+
+  async _handleLogin(payload, requestId) {
+    const { propfirmKey, username, password } = payload;
+    if (!propfirmKey || !username || !password) {
+      return { error: 'Missing credentials', requestId };
+    }
+    
+    // Already connected?
+    if (this.connections.has(propfirmKey)) {
+      const conn = this.connections.get(propfirmKey);
+      if (conn.service?.loginInfo) {
+        return { type: 'loginResult', payload: { success: true, accounts: conn.accounts, alreadyConnected: true }, requestId };
+      }
+    }
+    
+    const Service = loadRithmicService();
+    const service = new Service(propfirmKey);
+    
+    log('INFO', 'Logging in...', { propfirm: propfirmKey });
+    const result = await service.login(username, password);
+    
+    if (result.success) {
+      this.connections.set(propfirmKey, {
+        service,
+        credentials: { username, password },
+        connectedAt: new Date().toISOString(),
+        accounts: result.accounts || [],
+      });
+      this._setupPnLUpdates(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('WARN', 'Login failed', { propfirm: propfirmKey, error: result.error });
+    return { type: 'loginResult', payload: { success: false, error: result.error }, requestId };
+  }
+
+  _setupPnLUpdates(propfirmKey, service) {
+    service.on('pnlUpdate', (pnl) => {
+      if (pnl.accountId) {
+        this.pnlCache.set(pnl.accountId, {
+          pnl: pnl.dayPnl || ((pnl.openPositionPnl || 0) + (pnl.closedPositionPnl || 0)),
+          openPnl: pnl.openPositionPnl || 0,
+          closedPnl: pnl.closedPositionPnl || 0,
+          balance: pnl.accountBalance || 0,
+          updatedAt: Date.now(),
+        });
+      }
+      this._broadcast({ type: 'pnlUpdate', payload: pnl });
+    });
+    service.on('positionUpdate', (pos) => this._broadcast({ type: 'positionUpdate', payload: pos }));
+    service.on('trade', (trade) => this._broadcast({ type: 'trade', payload: trade }));
+  }
+
+  _broadcast(msg) {
+    const data = JSON.stringify(msg);
+    for (const client of this.clients) {
+      if (client.readyState === WebSocket.OPEN) {
+        try { client.send(data); } catch (e) { /* ignore */ }
+      }
+    }
+  }
+
+  async _handleLogout(payload, requestId) {
+    const { propfirmKey } = payload;
+    if (propfirmKey) {
+      const conn = this.connections.get(propfirmKey);
+      if (conn?.service) { await conn.service.disconnect(); this.connections.delete(propfirmKey); }
+    } else {
+      await this.stop();
+    }
+    this._saveState();
+    return { type: 'logoutResult', payload: { success: true }, requestId };
+  }
+
+  async _handleGetAccounts(requestId) {
+    const allAccounts = [];
+    for (const [propfirmKey, conn] of this.connections) {
+      for (const acc of conn.accounts || []) {
+        allAccounts.push({ ...acc, propfirmKey, propfirm: conn.service.propfirm?.name || propfirmKey });
+      }
+    }
+    return { type: 'accounts', payload: { accounts: allAccounts }, requestId };
+  }
+
+  _handleGetPnL(payload, requestId) {
+    const cached = this.pnlCache.get(payload.accountId);
+    return { type: 'pnl', payload: cached || { pnl: null }, requestId };
+  }
+
+  async _handleGetPositions(payload, requestId) {
+    const conn = this.connections.get(payload.propfirmKey);
+    if (!conn?.service) return { error: 'Not connected', requestId };
+    return { type: 'positions', payload: await conn.service.getPositions(), requestId };
+  }
+
+  async _handlePlaceOrder(payload, requestId) {
+    const conn = this.connections.get(payload.propfirmKey);
+    if (!conn?.service) return { error: 'Not connected', requestId };
+    return { type: 'orderResult', payload: await conn.service.placeOrder(payload.orderData), requestId };
+  }
+
+  async _handleCancelOrder(payload, requestId) {
+    const conn = this.connections.get(payload.propfirmKey);
+    if (!conn?.service) return { error: 'Not connected', requestId };
+    return { type: 'cancelResult', payload: await conn.service.cancelOrder(payload.orderId), requestId };
+  }
+
+  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 };
+  }
+
+  async _handleSearchContracts(payload, requestId) {
+    const conn = this.connections.get(payload.propfirmKey);
+    if (!conn?.service) return { error: 'Not connected', requestId };
+    return { type: 'searchResults', payload: await conn.service.searchContracts(payload.searchText), requestId };
+  }
+
+  _handleGetCredentials(payload, requestId) {
+    const conn = this.connections.get(payload.propfirmKey);
+    if (!conn?.service) return { error: 'Not connected', requestId };
+    return { type: 'credentials', payload: conn.service.getRithmicCredentials?.() || null, requestId };
+  }
+
+  _saveState() {
+    const state = { connections: [] };
+    for (const [key, conn] of this.connections) {
+      if (conn.credentials) state.connections.push({ propfirmKey: key, credentials: conn.credentials });
+    }
+    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
+if (require.main === module) {
+  const daemon = new RithmicBrokerDaemon();
+  daemon.start().catch((e) => { console.error('Daemon failed:', e.message); process.exit(1); });
+}
+
+module.exports = { RithmicBrokerDaemon, BROKER_PORT, BROKER_DIR, PID_FILE, LOG_FILE, STATE_FILE };

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

@@ -0,0 +1,46 @@
+/**
+ * RithmicBroker Service
+ * 
+ * Persistent Rithmic connection manager.
+ * Daemon runs in background, survives CLI restarts.
+ * 
+ * Usage:
+ *   const { RithmicBrokerClient, manager } = require('./rithmic-broker');
+ *   
+ *   // Start daemon if not running
+ *   await manager.ensureRunning();
+ *   
+ *   // Create client (same API as RithmicService)
+ *   const client = new RithmicBrokerClient('apex');
+ *   await client.login(username, password);
+ *   
+ *   // Use like RithmicService
+ *   const accounts = await client.getTradingAccounts();
+ */
+
+'use strict';
+
+const { RithmicBrokerClient } = require('./client');
+const manager = require('./manager');
+const { BROKER_PORT, BROKER_DIR, PID_FILE, LOG_FILE, STATE_FILE } = require('./daemon');
+
+module.exports = {
+  // Client class (use instead of RithmicService)
+  RithmicBrokerClient,
+  
+  // Manager functions
+  manager,
+  isRunning: manager.isRunning,
+  start: manager.start,
+  stop: manager.stop,
+  getStatus: manager.getStatus,
+  ensureRunning: manager.ensureRunning,
+  restart: manager.restart,
+  
+  // Constants
+  BROKER_PORT,
+  BROKER_DIR,
+  PID_FILE,
+  LOG_FILE,
+  STATE_FILE,
+};

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

@@ -0,0 +1,256 @@
+/**
+ * RithmicBroker Manager
+ * 
+ * Start/stop/status functions for the RithmicBroker daemon.
+ * Similar pattern to cliproxy/manager.js
+ */
+
+'use strict';
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const http = require('http');
+const WebSocket = require('ws');
+
+const { BROKER_PORT, BROKER_DIR, PID_FILE, LOG_FILE } = require('./daemon');
+
+// Path to daemon script
+const DAEMON_SCRIPT = path.join(__dirname, 'daemon.js');
+
+/**
+ * Check if daemon is running
+ * @returns {Promise<{running: boolean, pid: number|null}>}
+ */
+const isRunning = async () => {
+  // Check PID file first
+  if (fs.existsSync(PID_FILE)) {
+    try {
+      const pid = parseInt(fs.readFileSync(PID_FILE, 'utf8').trim(), 10);
+      process.kill(pid, 0); // Test if process exists
+      return { running: true, pid };
+    } catch (e) {
+      // Process doesn't exist, clean up stale PID file
+      try { fs.unlinkSync(PID_FILE); } catch (e2) { /* ignore */ }
+    }
+  }
+  
+  // Try connecting to WebSocket
+  return new Promise((resolve) => {
+    const ws = new WebSocket(`ws://127.0.0.1:${BROKER_PORT}`);
+    const timeout = setTimeout(() => {
+      ws.terminate();
+      resolve({ running: false, pid: null });
+    }, 2000);
+    
+    ws.on('open', () => {
+      clearTimeout(timeout);
+      ws.close();
+      resolve({ running: true, pid: null });
+    });
+    
+    ws.on('error', () => {
+      clearTimeout(timeout);
+      resolve({ running: false, pid: null });
+    });
+  });
+};
+
+/**
+ * Start the daemon
+ * @returns {Promise<{success: boolean, error: string|null, pid: number|null}>}
+ */
+const start = async () => {
+  const status = await isRunning();
+  if (status.running) {
+    return { success: true, error: null, pid: status.pid, alreadyRunning: true };
+  }
+  
+  // Ensure directory exists
+  if (!fs.existsSync(BROKER_DIR)) {
+    fs.mkdirSync(BROKER_DIR, { recursive: true });
+  }
+  
+  try {
+    // Open log file for daemon output
+    const logFd = fs.openSync(LOG_FILE, 'a');
+    
+    // Spawn detached daemon process
+    const child = spawn(process.execPath, [DAEMON_SCRIPT], {
+      detached: true,
+      stdio: ['ignore', logFd, logFd],
+      cwd: BROKER_DIR,
+      env: { ...process.env, HQX_BROKER_DAEMON: '1' },
+    });
+    
+    child.unref();
+    fs.closeSync(logFd);
+    
+    // Wait for daemon to start
+    await new Promise(r => setTimeout(r, 2000));
+    
+    const runStatus = await isRunning();
+    if (runStatus.running) {
+      return { success: true, error: null, pid: runStatus.pid || child.pid };
+    } else {
+      // Read log for error details
+      let errorDetail = 'Failed to start RithmicBroker daemon';
+      if (fs.existsSync(LOG_FILE)) {
+        const log = fs.readFileSync(LOG_FILE, 'utf8').slice(-500);
+        if (log) errorDetail += `: ${log.split('\n').filter(l => l).pop()}`;
+      }
+      return { success: false, error: errorDetail, pid: null };
+    }
+  } catch (error) {
+    return { success: false, error: error.message, pid: null };
+  }
+};
+
+/**
+ * Stop the daemon
+ * @returns {Promise<{success: boolean, error: string|null}>}
+ */
+const stop = async () => {
+  const status = await isRunning();
+  if (!status.running) {
+    return { success: true, error: null };
+  }
+  
+  try {
+    // Try graceful shutdown via WebSocket
+    const ws = new WebSocket(`ws://127.0.0.1:${BROKER_PORT}`);
+    
+    await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        ws.terminate();
+        reject(new Error('Shutdown timeout'));
+      }, 5000);
+      
+      ws.on('open', () => {
+        ws.send(JSON.stringify({ type: 'logout', payload: {}, requestId: 'shutdown' }));
+        setTimeout(() => {
+          clearTimeout(timeout);
+          ws.close();
+          resolve();
+        }, 1000);
+      });
+      
+      ws.on('error', () => {
+        clearTimeout(timeout);
+        reject(new Error('Connection failed'));
+      });
+    });
+    
+    // Wait for process to exit
+    await new Promise(r => setTimeout(r, 1000));
+    
+    // Verify stopped
+    const newStatus = await isRunning();
+    if (!newStatus.running) {
+      return { success: true, error: null };
+    }
+    
+    // Force kill if still running
+    if (status.pid) {
+      try {
+        process.kill(status.pid, 'SIGKILL');
+      } catch (e) { /* ignore */ }
+    }
+    
+    // Clean up PID file
+    if (fs.existsSync(PID_FILE)) {
+      try { fs.unlinkSync(PID_FILE); } catch (e) { /* ignore */ }
+    }
+    
+    return { success: true, error: null };
+  } catch (error) {
+    // Force kill via PID
+    if (status.pid) {
+      try {
+        process.kill(status.pid, 'SIGKILL');
+        if (fs.existsSync(PID_FILE)) fs.unlinkSync(PID_FILE);
+        return { success: true, error: null };
+      } catch (e) { /* ignore */ }
+    }
+    return { success: false, error: error.message };
+  }
+};
+
+/**
+ * Get daemon status
+ * @returns {Promise<Object>}
+ */
+const getStatus = async () => {
+  const status = await isRunning();
+  
+  if (!status.running) {
+    return { running: false, pid: null, connections: [], uptime: 0 };
+  }
+  
+  // Get detailed status from daemon
+  return new Promise((resolve) => {
+    const ws = new WebSocket(`ws://127.0.0.1:${BROKER_PORT}`);
+    const timeout = setTimeout(() => {
+      ws.terminate();
+      resolve({ running: true, pid: status.pid, connections: [], uptime: 0 });
+    }, 3000);
+    
+    ws.on('open', () => {
+      ws.send(JSON.stringify({ type: 'status', requestId: 'status' }));
+    });
+    
+    ws.on('message', (data) => {
+      clearTimeout(timeout);
+      try {
+        const msg = JSON.parse(data.toString());
+        if (msg.type === 'status') {
+          ws.close();
+          resolve(msg.payload);
+        }
+      } catch (e) {
+        ws.close();
+        resolve({ running: true, pid: status.pid, connections: [], uptime: 0 });
+      }
+    });
+    
+    ws.on('error', () => {
+      clearTimeout(timeout);
+      resolve({ running: true, pid: status.pid, connections: [], uptime: 0 });
+    });
+  });
+};
+
+/**
+ * Ensure daemon is running (start if not)
+ * @returns {Promise<{success: boolean, error: string|null}>}
+ */
+const ensureRunning = async () => {
+  const status = await isRunning();
+  if (status.running) {
+    return { success: true, error: null };
+  }
+  return start();
+};
+
+/**
+ * Restart the daemon
+ * @returns {Promise<{success: boolean, error: string|null}>}
+ */
+const restart = async () => {
+  await stop();
+  await new Promise(r => setTimeout(r, 1000));
+  return start();
+};
+
+module.exports = {
+  isRunning,
+  start,
+  stop,
+  getStatus,
+  ensureRunning,
+  restart,
+  BROKER_PORT,
+  BROKER_DIR,
+  PID_FILE,
+  LOG_FILE,
+};

package/src/services/session.js

@@ -84,11 +84,11 @@ const storage = {
   },
 };
 
-// Lazy load RithmicService to avoid circular dependencies
-let RithmicService;
+// Lazy load services to avoid circular dependencies
+let RithmicBrokerClient, brokerManager;
 const loadServices = () => {
-  if (!RithmicService) {
-    ({ RithmicService } = require('./rithmic'));
+  if (!RithmicBrokerClient) {
+    ({ RithmicBrokerClient, manager: brokerManager } = require('./rithmic-broker'));
   }
 };
 
@@ -130,16 +130,44 @@ const connections = {
 
   async restoreFromStorage() {
     loadServices();
-    const sessions = storage.load();
     
-    // Filter only Rithmic sessions (AI sessions are managed by ai-agents.js)
+    // Check if daemon is already running with active connections
+    const daemonStatus = await brokerManager.getStatus();
+    
+    if (daemonStatus.running && daemonStatus.connections?.length > 0) {
+      // Daemon has active connections - just create clients (NO API calls)
+      log.info('Daemon active, restoring from broker', { connections: daemonStatus.connections.length });
+      
+      for (const conn of daemonStatus.connections) {
+        const client = new RithmicBrokerClient(conn.propfirmKey);
+        await client.connect();
+        
+        // Get accounts from daemon cache
+        const accountsResult = await client.getTradingAccounts();
+        client.accounts = accountsResult.accounts || [];
+        
+        this.services.push({
+          type: 'rithmic',
+          service: client,
+          propfirm: conn.propfirm,
+          propfirmKey: conn.propfirmKey,
+          connectedAt: new Date(conn.connectedAt),
+        });
+        log.debug('Restored from broker', { propfirm: conn.propfirmKey });
+      }
+      
+      return this.services.length > 0;
+    }
+    
+    // Daemon not running or no connections - check local storage
+    const sessions = storage.load();
     const rithmicSessions = sessions.filter(s => s.type === 'rithmic');
     
     if (!rithmicSessions.length) {
       return false;
     }
     
-    log.info('Restoring sessions', { count: rithmicSessions.length });
+    log.info('Restoring sessions via broker', { count: rithmicSessions.length });
     
     for (const session of rithmicSessions) {
       try {
@@ -155,20 +183,20 @@ const connections = {
   async _restoreSession(session) {
     const { type, propfirm, propfirmKey } = session;
     
-    // Only restore Rithmic sessions
+    // Use broker client (daemon handles persistence)
     if (type === 'rithmic' && session.credentials) {
-      const service = new RithmicService(propfirmKey || 'apex_rithmic');
-      const result = await service.login(session.credentials.username, session.credentials.password);
+      const client = new RithmicBrokerClient(propfirmKey || 'apex_rithmic');
+      const result = await client.login(session.credentials.username, session.credentials.password);
       
       if (result.success) {
         this.services.push({
           type,
-          service,
+          service: client,
           propfirm,
           propfirmKey,
           connectedAt: new Date(),
         });
-        log.debug('Rithmic session restored');
+        log.debug('Rithmic session restored via broker');
       }
     }
   },
@@ -251,15 +279,23 @@ const connections = {
     return this.services.length > 0;
   },
 
-  disconnectAll() {
+  async disconnectAll() {
+    loadServices();
+    
+    // Stop the broker daemon (closes all Rithmic connections)
+    try {
+      await brokerManager.stop();
+      log.info('Broker daemon stopped');
+    } catch (err) {
+      log.warn('Broker stop failed', { error: err.message });
+    }
+    
+    // Disconnect local clients
     for (const conn of this.services) {
       try {
         if (conn.service?.disconnect) {
           conn.service.disconnect();
         }
-        if (conn.service?.credentials) {
-          conn.service.credentials = null;
-        }
       } catch (err) {
         log.warn('Disconnect failed', { type: conn.type, error: err.message });
       }