feat: add feed health monitoring and structure-based TP2/trailing stop rules

server.js

@@ -88,6 +88,8 @@ const tradeManager = new TradeManager({ isServer: true, db: dbManager });
 const historyMap = {};
 const livePrices = {};
 const streams = {};
+const lastUpdate = {};    // last time each symbol's feed delivered data (ms)
+const staleAlerted = {};  // de-dupe flag for feed-stale Telegram alerts
 const lastScannedCandleTime = {};
 
 // Helper delay utility
@@ -138,6 +140,7 @@ function handleTick(symbol, price) {
 }
 
 function handleCandleUpdate(symbol, candle) {
+  lastUpdate[symbol] = Date.now();
   if (!historyMap[symbol]) historyMap[symbol] = [];
   const history = historyMap[symbol];
 
@@ -258,6 +261,37 @@ function startTwelveDataPoller(symbol, apiKey, basePollMs = 120000) {
   streams[symbol] = { unsubscribe: () => { stopped = true; } };
 }
 
+// --------------------------------------------------------------------
+//  Feed health monitoring (weekend-aware)
+// --------------------------------------------------------------------
+function isForexOpen(now = new Date()) {
+  const day = now.getUTCDay(); // 0 Sun .. 6 Sat
+  const h = now.getUTCHours();
+  if (day === 6) return false;             // Saturday: closed
+  if (day === 0 && h < 22) return false;   // Sunday before ~22:00 UTC
+  if (day === 5 && h >= 21) return false;  // Friday after ~21:00 UTC
+  return true;
+}
+function feedExpectedLive(symbol) {
+  return symbol === 'BTCUSDT' ? true : isForexOpen();
+}
+const STALE_SECONDS = 20 * 60;
+function checkFeedHealth() {
+  for (const symbol of SYMBOLS) {
+    const last = lastUpdate[symbol];
+    const ageSec = last ? (Date.now() - last) / 1000 : Infinity;
+    const stale = ageSec > STALE_SECONDS && feedExpectedLive(symbol);
+    if (stale && !staleAlerted[symbol]) {
+      staleAlerted[symbol] = true;
+      console.warn(`[FeedHealth] ${symbol} feed stale (${Math.round(ageSec / 60)} min).`);
+      sendTelegramMessage(`⚠️ <b>FEED STALE</b>\n\n<code>${symbol}</code> has not updated in <b>${Math.round(ageSec / 60)} min</b> while its market should be open. Check the data feed / Twelve Data key.`);
+    } else if (!stale && staleAlerted[symbol]) {
+      staleAlerted[symbol] = false;
+      sendTelegramMessage(`✅ <b>FEED RECOVERED</b>\n\n<code>${symbol}</code> is updating again.`);
+    }
+  }
+}
+
 async function startAutopilot() {
   console.log('[Autopilot] Initializing feeds (Twelve Data for keyed forex/metals, Yahoo for the rest)...');
   
@@ -306,6 +340,9 @@ async function startAutopilot() {
   }
 
   console.log(`[Server Autopilot] Startup complete. Timeframe: ${TIMEFRAME}. Autopilot active for: ${AUTOPILOT_SYMBOLS.join(', ')}.`);
+
+  // Monitor feed liveness; alert (weekend-aware) if a feed stalls during market hours.
+  setInterval(checkFeedHealth, 5 * 60 * 1000);
 }
 
 // --------------------------------------------------------------------
@@ -321,6 +358,7 @@ app.get('/api/terminal-state', (req, res) => {
     lastClosedTime: tradeManager.lastClosedTime,
     lastExecutedCandleTime: tradeManager.lastExecutedCandleTime,
     twelveDataActive: false,
+    feeds: Object.fromEntries(SYMBOLS.map(s => [s, lastUpdate[s] ? Math.floor((Date.now() - lastUpdate[s]) / 1000) : null])),
   });
 });
 

src/analysis/exitManager.js

@@ -84,7 +84,7 @@ export function analyzeExit(candles, trade) {
   const pnl = calculatePnL(trade, currentPrice, trade.symbol);
 
   // --- 2. Current R:R ---
-  const riskDistance = Math.abs(trade.entry - trade.sl);
+  const riskDistance = trade.initialRiskDist || Math.abs(trade.entry - trade.sl);
   const moveFromEntry = (currentPrice - trade.entry) * direction;
   
   // Guard against micro-stop division anomalies in older trades
@@ -103,12 +103,33 @@ export function analyzeExit(candles, trade) {
   let newSL = /** @type {number|null} */ (null);
 
   if (trade.partialClosed) {
+    // Trail the stop on the runner toward the most recent confirmed swing (ratchet),
+    // floored at breakeven so the position can never fall back into a loss.
+    try {
+      const struct = detectStructure(candles);
+      const buf = (trade.initialRiskDist || riskDistance) * 0.2;
+      if (trade.type === 'LONG') {
+        const lows = struct.swingLows.filter(sw => sw.price < currentPrice - buf);
+        const ref = lows.length ? lows[lows.length - 1].price - buf : trade.entry;
+        newSL = Math.max(trade.entry, ref);
+      } else {
+        const highs = struct.swingHighs.filter(sw => sw.price > currentPrice + buf);
+        const ref = highs.length ? highs[highs.length - 1].price + buf : trade.entry;
+        newSL = Math.min(trade.entry, ref);
+      }
+    } catch {
+      newSL = trade.entry;
+    }
+
     if (currentRR >= 3.0) {
       suggestion = 'CLOSE';
-      reason = `Remaining 30% reached TP2 target (R:R: ${currentRR.toFixed(2)}). Exit position.`;
+      reason = `Remaining 30% reached the TP2 target (R:R: ${currentRR.toFixed(2)}). Exit the runner.`;
     } else {
-      suggestion = 'HOLD';
-      reason = `70% partial profit secured. Stop Loss trailed to Breakeven. Holding remaining 30% for TP2 target.`;
+      suggestion = 'MOVE_SL';
+      const trailed = (trade.type === 'LONG' && newSL > trade.entry) || (trade.type === 'SHORT' && newSL < trade.entry);
+      reason = trailed
+        ? `70% profit banked. Trailing the stop behind structure to lock in gains on the 30% runner.`
+        : `70% profit banked. Stop held at breakeven; holding the 30% runner for TP2.`;
     }
   } else {
     const tp1Reached = trade.type === 'LONG' ? currentPrice >= trade.tp1 : currentPrice <= trade.tp1;

src/analysis/signalGenerator.js

@@ -517,6 +517,14 @@ function buildSignal(
     if (nextSwingHigh && nextSwingHigh.price >= tp1 && nextSwingHigh.price < tp2) {
       tp1 = nextSwingHigh.price;
     }
+
+    // Structure-based TP2: extend the final target to the next swing high beyond the
+    // 1:3 level (capped at 6R) so we aim for real liquidity, not a fixed multiple.
+    const tp2Cap = entry + risk * 6;
+    const swingHighTP2 = structure.swingHighs
+      .filter(sh => sh.price >= tp2 && sh.price <= tp2Cap)
+      .sort((a, b) => a.price - b.price)[0];
+    if (swingHighTP2) tp2 = swingHighTP2.price;
   } else {
     const techEntry = lastClose;
     let techSl = zoneTop + atrBuffer;
@@ -545,6 +553,13 @@ function buildSignal(
     if (nextSwingLow && nextSwingLow.price <= tp1 && nextSwingLow.price > tp2) {
       tp1 = nextSwingLow.price;
     }
+
+    // Structure-based TP2: extend down to the next swing low beyond the 1:3 level (capped 6R).
+    const tp2Cap = entry - risk * 6;
+    const swingLowTP2 = structure.swingLows
+      .filter(sl => sl.price <= tp2 && sl.price >= tp2Cap)
+      .sort((a, b) => b.price - a.price)[0];
+    if (swingLowTP2) tp2 = swingLowTP2.price;
   }
 
   // Validate R:R ≥ 1:2

src/components/tradeManager.js

@@ -102,6 +102,7 @@ export class TradeManager {
       status: 'active',
       slMoved: false,
       quality: signal.quality || 'A',
+      initialRiskDist: Math.abs(signal.entry - signal.sl),
     };
 
     // Debit commission immediately from the closed balance
@@ -159,7 +160,7 @@ export class TradeManager {
 
       const direction = trade.type === 'LONG' ? 1 : -1;
       const priceDiff = (valuationPrice - trade.entry) * direction;
-      const slDist = Math.abs(trade.entry - trade.sl);
+      const slDist = trade.initialRiskDist || Math.abs(trade.entry - trade.sl);
 
       // Calculate total P&L (realized + remaining)
       const remainingPnL = this._calculatePnL(trade, valuationPrice);
@@ -184,7 +185,7 @@ export class TradeManager {
       // SL/TP level (not an overshooting tick) so realized risk stays bounded.
       if (trade.type === 'LONG') {
         if (valuationPrice <= trade.sl) {
-          const reason = trade.partialClosed ? 'Breakeven Hit' : 'SL Hit';
+          const reason = trade.partialClosed ? 'Trailing Stop' : 'SL Hit';
           this._closeTrade(trade, reason, trade.sl);
         } else if (valuationPrice >= trade.tp2) {
           if (!trade.partialClosed) {
@@ -196,7 +197,7 @@ export class TradeManager {
         }
       } else {
         if (valuationPrice >= trade.sl) {
-          const reason = trade.partialClosed ? 'Breakeven Hit' : 'SL Hit';
+          const reason = trade.partialClosed ? 'Trailing Stop' : 'SL Hit';
           this._closeTrade(trade, reason, trade.sl);
         } else if (valuationPrice <= trade.tp2) {
           if (!trade.partialClosed) {
@@ -232,26 +233,45 @@ export class TradeManager {
       trade.suggestionText = null;
     }
 
+    // Apply a trailed stop on the runner (ratchet only — never loosen, never cross
+    // back to the loss side of breakeven). Authoritative on the server engine.
+    if (analysis.newSL != null && trade.partialClosed && this.isServer) {
+      const better = trade.type === 'LONG'
+        ? (analysis.newSL > trade.sl && analysis.newSL >= trade.entry)
+        : (analysis.newSL < trade.sl && analysis.newSL <= trade.entry);
+      if (better) {
+        trade.sl = analysis.newSL;
+        trade.slMoved = true;
+        this._saveActiveTrades();
+      }
+    }
+
     // Warnings/suggestions are ephemeral display state recomputed every tick, so
     // just re-render — no need to write them to the database on every tick.
     this._render();
   }
 
   _generatePostMortem(trade) {
-    let auditText = '';
     const decs = this._getDecimals(trade.symbol);
+    const lines = [];
+
+    // Factual invalidation summary — no fabricated narrative.
+    lines.push(`• <b>Invalidation:</b> Price hit the Stop Loss at <code>$${trade.sl.toFixed(decs)}</code> (exit <code>$${(trade.exitPrice ?? trade.sl).toFixed(decs)}</code>), invalidating the ${trade.type} setup.`);
+
+    if (trade.partialClosed) {
+      const realized = trade.realizedPnL || 0;
+      lines.push(`• <b>Partial Banked First:</b> TP1 was reached — 70% closed for <code>+$${realized.toFixed(2)}</code> before the runner was stopped, so this was not a full-risk loss.`);
+    }
 
-    if (trade.type === 'LONG') {
-      auditText += `• <b>Liquidity Sweep:</b> The market conducted a deep liquidity sweep below the recent unmitigated demand zone/order block at <code>$${trade.sl.toFixed(decs)}</code>. Price tapped deeper buy orders before potentially stabilizing.\n` +
-        `• <b>Bearish Momentum:</b> Short-term selling pressure spiked on high volume, invalidating our bullish structure.\n` +
-        `• <b>Indicator Divergence Sweep:</b> The RSI was swept into deep oversold regions, causing a temporary exhaustion flush that pierced our Stop Loss.`;
+    // Real warning signals the exit analyser flagged before the stop (from analyzeExit).
+    if (Array.isArray(trade.warnings) && trade.warnings.length > 0) {
+      lines.push(`• <b>Warning signs flagged before the stop:</b>`);
+      for (const w of trade.warnings) lines.push(`   – ${w}`);
     } else {
-      auditText += `• <b>Liquidity Sweep:</b> The market swept above the unmitigated supply zone/order block at <code>$${trade.sl.toFixed(decs)}</code>, hunting buy-stops/liquidity before stabilizing.\n` +
-        `• <b>Bullish Momentum:</b> Buyers pushed price rapidly on institutional volume, causing a short-term momentum crossover that invalidated our bearish zone.\n` +
-        `• <b>Indicator Divergence Sweep:</b> RSI overbought levels peaked above extreme limits, causing a final momentum squeeze that hit our Stop Loss.`;
+      lines.push(`• <b>No reversal warnings were flagged</b> before the stop — price simply traded to the predefined invalidation level.`);
     }
 
-    return auditText;
+    return lines.join('\n');
   }
 
   _closeTrade(trade, reason, exitPriceOverride = null) {