neuroalpha 0.5.31 → 0.5.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neuroalpha",
-  "version": "0.5.31",
+  "version": "0.5.33",
   "description": "НейроАльфа — ИИ-автопилот для рынка акций Мосбиржи: эмбеддинги акций, самообучение правил, коннекторы Т-Банк / БКС / Финам / Алор и боты Telegram / MAX",
   "author": "Roman A. Perepelkin",
   "license": "UNLICENSED",

package/server/brokers/index.js

@@ -1612,7 +1612,7 @@ export async function freezeBrokerBaseline(id) {
 }
 
 // Оценка срабатывания скользящего Take-Profit и защиты заработанной прибыли от отката в минус (по лучшей цене с момента входа peakPx)
-function evaluateProfitLock(sym, side, avgPx, curPx, peakPx, roundTripFeePct = 0.10) {
+function evaluateProfitLock(sym, side, avgPx, curPx, peakPx, roundTripFeePct = 0.10, heldMin = 999) {
   if (!(avgPx > 0 && curPx > 0)) return null;
   const isLong = side === 'long';
   const curGainPct = isLong ? ((curPx - avgPx) / avgPx) * 100 : ((avgPx - curPx) / avgPx) * 100;
@@ -1621,19 +1621,22 @@ function evaluateProfitLock(sym, side, avgPx, curPx, peakPx, roundTripFeePct = 0
     : (isLong ? Math.max(avgPx, curPx) : Math.min(avgPx, curPx));
   const peakGainPct = isLong ? ((effPeakPx - avgPx) / avgPx) * 100 : ((avgPx - effPeakPx) / avgPx) * 100;
   const tierMult = symbolEdgeMult(sym);
-  // 1) Скользящий Take-Profit при сильном перевыполнении цели (от +1.20% на 1-м эшелоне и от +1.44% на 2-м эшелоне):
+  // Минимальный чистый порог фиксации с учётом спреда стакана и двойной комиссии (чтобы выход не закрывался в 0.00% после исполнения лимитки)
+  const minNetFloorPct = Math.max(roundTripFeePct + 0.30, round(0.38 * tierMult, 2));
+  // 1) Скользящий Take-Profit при сильном перевыполнении цели (в первые 15 мин требуем более сильный импульс 1.55×tierMult, далее 1.20×tierMult):
   // фиксируем не менее 70% набранного хода (или при откате на 0.45% с вершины)
-  if (peakGainPct >= 1.20 * tierMult) {
-    const trailFloorPct = Math.max(peakGainPct * 0.70, peakGainPct - 0.45, roundTripFeePct + 0.25);
-    if (curGainPct <= trailFloorPct && curGainPct >= roundTripFeePct + 0.10) {
+  const tpTriggerPct = (heldMin < 15 ? 1.55 : 1.20) * tierMult;
+  if (peakGainPct >= tpTriggerPct) {
+    const trailFloorPct = Math.max(peakGainPct * 0.70, peakGainPct - 0.45, minNetFloorPct);
+    if (curGainPct <= trailFloorPct && curGainPct >= minNetFloorPct) {
       return `Фиксация прибыли (Take-Profit: пик +${round(peakGainPct, 2)}% → +${round(curGainPct, 2)}%)`;
     }
   }
-  // 2) Защита заработанного плюса / безубытка (от +0.75% на 1-м эшелоне и от +0.90% на 2-м эшелоне):
-  // не позволяем плюсовой сделке развернуться обратно в убыток
-  if (peakGainPct >= 0.75 * tierMult) {
-    const breakevenFloorPct = Math.max(roundTripFeePct + 0.18, peakGainPct * 0.40);
-    if (curGainPct <= breakevenFloorPct) {
+  // 2) Защита заработанного плюса / безубытка (после первых 15 минут удержания, от +0.85% на 1-м эшелоне и от +1.02% на 2-м эшелоне):
+  // не позволяем зрелой плюсовой сделке развернуться обратно в убыток, но и не режем позицию стартовым шумом стакана в первые минуты
+  if (heldMin >= 15 && peakGainPct >= 0.85 * tierMult) {
+    const breakevenFloorPct = Math.max(minNetFloorPct, peakGainPct * 0.45);
+    if (curGainPct <= breakevenFloorPct && curGainPct >= roundTripFeePct + 0.22) {
       return `Защита прибыли от отката (пик +${round(peakGainPct, 2)}% → фиксация +${round(curGainPct, 2)}%)`;
     }
   }
@@ -1642,9 +1645,9 @@ function evaluateProfitLock(sym, side, avgPx, curPx, peakPx, roundTripFeePct = 0
 function sessionEdgeWarning(now = Date.now()) {
   const d = new Date(now + MSK);
   const mins = d.getUTCHours() * 60 + d.getUTCMinutes();
-  // открытие утренней сессии 06:50–07:05, открытие основной сессии 09:50–10:10 и закрытие дневной 18:35–18:55 МСК
-  if ((mins >= 6 * 60 + 50 && mins <= 7 * 60 + 5) || (mins >= 9 * 60 + 50 && mins <= 10 * 60 + 10) || (mins >= 18 * 60 + 35 && mins <= 18 * 60 + 55)) {
-    return 'Первые или последние 10 минут сессии (широкий спред в стакане)';
+  // открытие утренней сессии 06:50–07:25 (отыгрыш ночных гэпов и формирование стакана), открытие основной сессии 09:50–10:10 и закрытие дневной 18:35–18:55 МСК
+  if ((mins >= 6 * 60 + 50 && mins <= 7 * 60 + 25) || (mins >= 9 * 60 + 50 && mins <= 10 * 60 + 10) || (mins >= 18 * 60 + 35 && mins <= 18 * 60 + 55)) {
+    return 'Первые минуты утренней/основной сессии или закрытие дневной (широкий спред и утренние гэпы в стакане)';
   }
   return null;
 }
@@ -1656,7 +1659,7 @@ const entryImpulseWatch = new Map(); // `${accId}:${symbol}:${side}` -> { firstT
 
 // Фильтр затухания минутного импульса перед входом (Impulse Exhaustion):
 // не даёт продавать в шорт посередине вертикально растущей минутной свечи (или покупать в полёт падающего ножа),
-// дожидаясь остановки разгона и первого микро-отката от пика/дна (с шагом проверки 20 секунд)
+// дожидаясь остановки разгона и подтверждённого отката от пика/дна (с шагом проверки 20 секунд; без принудительного входа по таймауту)
 async function filterByImpulseExhaustion(acc, cands, side, specs, nowTs = Date.now()) {
   if (!cands.length || acc.broker !== 'tbank' || !acc.token) return { ready: cands, deferred: [] };
   for (const [k, v] of entryImpulseWatch) {
@@ -1674,7 +1677,7 @@ async function filterByImpulseExhaustion(acc, cands, side, specs, nowTs = Date.n
       ready.push(r);
       continue;
     }
-    const bars1m = await fetchTbankCandles(sym, nowTs - 8 * 60000, nowTs, { includeIncomplete: true, intervalMin: 1 }).catch(() => null);
+    const bars1m = await fetchTbankCandles(sym, nowTs - 15 * 60000, nowTs, { includeIncomplete: true, intervalMin: 1 }).catch(() => null);
     if (!bars1m?.length) {
       ready.push(r);
       continue;
@@ -1686,16 +1689,25 @@ async function filterByImpulseExhaustion(acc, cands, side, specs, nowTs = Date.n
     const step = sp.minStep > 0 ? sp.minStep : 0.01;
     const wKey = `${acc.id}:${sym}:${side}`;
     const prevW = entryImpulseWatch.get(wKey) || null;
+    let max1m = curPx, min1m = curPx > 0 ? curPx : Infinity;
+    for (const b of bars1m) {
+      if (b.high > max1m) max1m = b.high;
+      if (b.low > 0 && b.low < min1m) min1m = b.low;
+    }
+    const windowRangePct = (Number.isFinite(min1m) && min1m > 0 && max1m > min1m) ? ((max1m - min1m) / min1m) * 100 : 0;
+    const impulseMagPct = Math.max(Math.abs(Number(r.lastMovePct) || 0), windowRangePct);
+    const minPullbackPct = Math.max(0.15, Math.min(0.55, impulseMagPct * 0.15));
+    const isStrongSurge = impulseMagPct >= 1.5;
 
     if (isShort) {
-      const recentHigh = Math.max(prevW?.extremePx || 0, curPx, last1m?.high || 0, prev1m?.high || 0);
+      const recentHigh = Math.max(prevW?.extremePx || 0, curPx, max1m);
       const pullbackPct = recentHigh > 0 ? ((recentHigh - curPx) / recentHigh) * 100 : 0;
       const pullbackTicks = recentHigh > 0 ? (recentHigh - curPx) / step : 0;
       const barTurnedDown = Boolean(last1m && prev1m && last1m.close <= last1m.open && last1m.high <= prev1m.high + step * 0.5);
-      const peakedAndPulledBack = pullbackPct >= 0.12 && pullbackTicks >= 2;
-      const tickedDownFromPrev = Boolean(prevW && curPx <= prevW.lastPx - step && pullbackTicks >= 1.5);
-      const waitTimeout = Boolean(prevW && nowTs - prevW.firstTs >= 180000);
-      if (peakedAndPulledBack || barTurnedDown || tickedDownFromPrev || waitTimeout) {
+      const peakedAndPulledBack = pullbackPct >= minPullbackPct && pullbackTicks >= 2 && (!last1m || last1m.close <= last1m.open + step * 0.5);
+      const tickedDownFromPrev = Boolean(!isStrongSurge && prevW && curPx <= prevW.lastPx - step && pullbackTicks >= 2 && pullbackPct >= 0.12);
+      const readyShort = isStrongSurge ? (peakedAndPulledBack && barTurnedDown) : (peakedAndPulledBack || barTurnedDown || tickedDownFromPrev);
+      if (readyShort) {
         entryImpulseWatch.delete(wKey);
         r.price = curPx;
         ready.push(r);
@@ -1704,14 +1716,14 @@ async function filterByImpulseExhaustion(acc, cands, side, specs, nowTs = Date.n
         deferred.push({ symbol: sym, side, curPx, extremePx: recentHigh });
       }
     } else {
-      const recentLow = Math.min(prevW?.extremePx || Infinity, curPx > 0 ? curPx : Infinity, last1m?.low > 0 ? last1m.low : Infinity, prev1m?.low > 0 ? prev1m.low : Infinity);
+      const recentLow = Math.min(prevW?.extremePx || Infinity, min1m);
       const bouncePct = Number.isFinite(recentLow) && recentLow > 0 ? ((curPx - recentLow) / recentLow) * 100 : 0;
       const bounceTicks = Number.isFinite(recentLow) && recentLow > 0 ? (curPx - recentLow) / step : 0;
       const barTurnedUp = Boolean(last1m && prev1m && last1m.close >= last1m.open && last1m.low >= prev1m.low - step * 0.5);
-      const bottomedAndBounced = bouncePct >= 0.12 && bounceTicks >= 2;
-      const tickedUpFromPrev = Boolean(prevW && curPx >= prevW.lastPx + step && bounceTicks >= 1.5);
-      const waitTimeout = Boolean(prevW && nowTs - prevW.firstTs >= 180000);
-      if (bottomedAndBounced || barTurnedUp || tickedUpFromPrev || waitTimeout) {
+      const bottomedAndBounced = bouncePct >= minPullbackPct && bounceTicks >= 2 && (!last1m || last1m.close >= last1m.open - step * 0.5);
+      const tickedUpFromPrev = Boolean(!isStrongSurge && prevW && curPx >= prevW.lastPx + step && bounceTicks >= 2 && bouncePct >= 0.12);
+      const readyLong = isStrongSurge ? (bottomedAndBounced && barTurnedUp) : (bottomedAndBounced || barTurnedUp || tickedUpFromPrev);
+      if (readyLong) {
         entryImpulseWatch.delete(wKey);
         r.price = curPx;
         ready.push(r);
@@ -1901,10 +1913,11 @@ export async function prepareBrokerOrders(id, { onlyEntries = false, scheduledBa
   // Дивидендный предохранитель (общие правила с бэктестом, server/model/dividends.js)
   const divGuardOf = (sym, px) => liveDividendGuard(sym, Number(px) || specs[sym]?.lastPrice || 0, nowTs);
   const divBlocked = [];
-  const buyCands = !timeOk ? [] : fc.rows.filter((r) => r.signal && r.expectedPct >= reqBuyEdgeOf(r.symbol) && !isInCooldown(r.symbol) && !quarantined.has(r.symbol) && !nb?.get(r.symbol)?.bad)
+  const entryTimeOk = timeOk && !edgeWarn;
+  const buyCands = !entryTimeOk ? [] : fc.rows.filter((r) => r.signal && r.expectedPct >= reqBuyEdgeOf(r.symbol) && !isInCooldown(r.symbol) && !quarantined.has(r.symbol) && !nb?.get(r.symbol)?.bad)
     .filter((r) => { const g = divGuardOf(r.symbol, r.price); if (g?.blockLong) { divBlocked.push(`${r.symbol} (отсечка ${g.exDate}, ${g.yieldPct}%)`); return false; } return true; })
     .sort((a, b) => b.expectedPct - a.expectedPct).slice(0, K);
-  const allShortSignals = (rawDir !== 'long' && timeOk) ? fc.rows.filter((r) => r.shortSignal && r.expectedPct <= -reqShortEdgeOf(r.symbol) && !isInCooldown(r.symbol) && !quarantined.has(r.symbol) && !nb?.get(r.symbol)?.good)
+  const allShortSignals = (rawDir !== 'long' && entryTimeOk) ? fc.rows.filter((r) => r.shortSignal && r.expectedPct <= -reqShortEdgeOf(r.symbol) && (!autoAdapt || canEnterIntraday(nowTs, H, BAR_INTERVAL, 'short', r.symbol)) && !isInCooldown(r.symbol) && !quarantined.has(r.symbol) && !nb?.get(r.symbol)?.good)
     .filter((r) => { const g = divGuardOf(r.symbol, r.price); if (g?.blockShort) { divBlocked.push(`${r.symbol} (отсечка ${g.exDate}, ${g.yieldPct}%)`); return false; } return true; })
     .sort((a, b) => a.expectedPct - b.expectedPct) : [];
   const nonShortableSkipped = [];
@@ -1967,7 +1980,7 @@ export async function prepareBrokerOrders(id, { onlyEntries = false, scheduledBa
     if (aQty > 0) {
       const lots = Math.floor(aQty / sp.lotSize);
       const curGainPct = avgPx > 0 ? ((curPx - avgPx) / avgPx) * 100 : 0;
-      const profitLockReason = autoAdapt ? evaluateProfitLock(sym, 'long', avgPx, curPx, Number(peakMap[sym]) || 0, roundTripFeePct) : null;
+      const profitLockReason = autoAdapt ? evaluateProfitLock(sym, 'long', avgPx, curPx, Number(peakMap[sym]) || 0, roundTripFeePct, heldMin) : null;
       const hitHardStopLoss = curGainPct <= -5.0 || Boolean(autoAdapt && r.regimeCrash);
       // Если горизонт 2.5 ч ещё не вышел и прогноз смотрит в сторону лонга (> softExitThr), не режем позицию на локальном минутном откате в мелкий минус
       const holdThroughMinorDip = autoAdapt && heldMin < horizonMin && r.liquid && r.expectedPct > softExitThr && curGainPct >= -1.0 && curGainPct < roundTripFeePct + 0.12;
@@ -1997,7 +2010,7 @@ export async function prepareBrokerOrders(id, { onlyEntries = false, scheduledBa
     } else if (aQty < 0) {
       const lots = Math.floor(Math.abs(aQty) / sp.lotSize);
       const curGainPct = avgPx > 0 ? ((avgPx - curPx) / avgPx) * 100 : 0;
-      const profitLockReason = autoAdapt ? evaluateProfitLock(sym, 'short', avgPx, curPx, Number(peakMap[sym]) || 0, roundTripFeePct) : null;
+      const profitLockReason = autoAdapt ? evaluateProfitLock(sym, 'short', avgPx, curPx, Number(peakMap[sym]) || 0, roundTripFeePct, heldMin) : null;
       const hitHardStopLoss = curGainPct <= -4.5 || Boolean(autoAdapt && r.regimeSqueeze);
       // Если горизонт 2.5 ч ещё не вышел и прогноз смотрит в сторону шорта (< -softExitThr), не закрываем шорт на минутном шипе в мелкий минус
       const holdThroughMinorSpike = autoAdapt && heldMin < horizonMin && dir !== 'long' && r.liquid && r.expectedPct < -softExitThr && curGainPct >= -1.0 && curGainPct < roundTripFeePct + 0.12;
@@ -2305,6 +2318,8 @@ export async function prepareBrokerOrders(id, { onlyEntries = false, scheduledBa
   if (!orders.length) {
     if (!timeOk) {
       diagNote = `На свече ${fc.bar} вечернее окно новых входов закрыто: до конца сессии осталось меньше горизонта прогноза (${effHorizon} ч) — внутридневные сделки не переносятся через ночь.`;
+    } else if (edgeWarn) {
+      diagNote = `На свече ${fc.bar} новые входы временно отложены: ${edgeWarn.toLowerCase()}.`;
     } else if ((newBuys.length || newShorts.length) && availRub < 1500) {
       const sigList = [...newBuys.map((r) => `${r.symbol} (+${r.expectedPct}%)`), ...newShorts.map((r) => `${r.symbol} (${r.expectedPct}%)`)].join(', ');
       const cashNow = round(acc.lastSync?.cashRub || 0, 0);
@@ -2319,7 +2334,7 @@ export async function prepareBrokerOrders(id, { onlyEntries = false, scheduledBa
       diagNote = `Сигнал ${deferredByImpulse.map((d) => `${d.symbol} (${d.side === 'short' ? 'шорт' : 'покупка'}, текущая ${d.curPx} ₽)`).join(', ')} взят на прицел: ждём затухания встречного минутного импульса для входа по лучшей цене (проверка каждые 20 сек).`;
     } else if (!newBuys.length && !newShorts.length) {
       const noShortNote = nonShortableSkipped.length ? ` (пропущены немаржинальные бумаги, недоступные для шорта у брокера: ${nonShortableSkipped.map((r) => `${r.symbol} ${r.expectedPct}%`).join(', ')})` : '';
-      const cdNote = cooldownSkipped.length ? ` Сигнал ${cooldownSkipped.map((r) => `${r.symbol} (${r.expectedPct > 0 ? '+' : ''}${r.expectedPct}%)`).join(', ')} временно пропущен: действует 60-минутная пауза после недавнего выхода из позиции, чтобы не платить повторную комиссию.` : '';
+      const cdNote = cooldownSkipped.length ? ` Сигнал ${cooldownSkipped.map((r) => `${r.symbol} (${r.expectedPct > 0 ? '+' : ''}${r.expectedPct}%)`).join(', ')} временно пропущен: действует пауза (30–60 мин) после недавнего выхода из позиции, чтобы не перезаходить в отыгранный импульс и не платить повторную комиссию.` : '';
       const buyThrT2 = round(minBuyEdgePct * symbolEdgeMult('__T2__'), 2);
       const shortThrT2 = round(minShortEdgePct * symbolEdgeMult('__T2__'), 2);
       const thrRangeStr = dir !== 'long'
@@ -2370,7 +2385,7 @@ export async function prepareBrokerOrders(id, { onlyEntries = false, scheduledBa
     results: [],
   };
   saveRawAccounts(list);
-  if (acc.mode === 'auto' && !edgeWarn && acc.token && orders.length) {
+  if (acc.mode === 'auto' && acc.token && orders.length && (!edgeWarn || orders.every((o) => o.action === 'sell' || o.action === 'cover'))) {
     return await executeBrokerOrders(id, { _lockHeld: true });
   }
   if (acc.mode === 'confirm' && orders.length && !isDuplicatePending) {
@@ -2431,6 +2446,10 @@ async function sendOrderToBroker(acc, ord) {
       const jBook = await rBook.json().catch(() => null);
       const bestBid = qVal(jBook?.bids?.[0]?.price);
       const bestAsk = qVal(jBook?.asks?.[0]?.price);
+      if (isEntry && ord.symbol !== 'LQDT' && (!(bestBid > 0) || !(bestAsk > 0))) {
+        logBrokerEvent(acc, 'spread_skip', `${ord.symbol}: пустая сторона стакана (bid ${bestBid || 0} / ask ${bestAsk || 0}, планка или аукцион)`);
+        throw Object.assign(new Error(`В стакане ${ord.symbol} отсутствует ${!(bestAsk > 0) ? 'предложение (верхняя планка / аукцион)' : 'спрос (нижняя планка / аукцион)'} — вход пропущен`), { definitive: true });
+      }
       if (bestBid > 0 && bestAsk >= bestBid) {
         const midPx = (bestBid + bestAsk) / 2;
         const spreadPct = ((bestAsk - bestBid) / midPx) * 100;
@@ -2800,7 +2819,9 @@ export async function executeBrokerOrders(id, { _lockHeld = false } = {}) {
           hadExits = true;
           delete acc.entryTsBySymbol[ord.symbol];
           delete acc.peakPriceBySymbol[ord.symbol];
-          if (ord.isStopLoss) acc.exitCooldownBySymbol[ord.symbol] = execNowTs;
+          if (ord.symbol !== 'LQDT') {
+            acc.exitCooldownBySymbol[ord.symbol] = ord.isStopLoss ? execNowTs : (execNowTs - 30 * 60000);
+          }
         }
       } catch (e) {
         // Брокер явно отклонил заявку — при повторе нужен новый ID. Сетевая ошибка или таймаут — ID сохраняется:
@@ -3216,33 +3237,45 @@ async function reconcileBrokerStopsLocked(list, acc) {
     const aQty = algoQtyFor(acc, sym, Number(pos.qty) || 0);
     if (!aQty) continue;
     const wantCloseDir = aQty > 0 ? 'sell' : 'buy';
+    const wantOpenDir = aQty > 0 ? 'buy' : 'sell';
     if (activeOrders.some((o) => o.symbol === sym && o.direction === wantCloseDir)) continue;
+    const activeOpenOrd = activeOrders.find((o) => o.symbol === sym && o.direction === wantOpenDir);
+    const ordAgeMs = activeOpenOrd ? (Date.now() - (Date.parse(activeOpenOrd.orderDate || 0) || Number(acc.entryTsBySymbol?.[sym]) || 0)) : Infinity;
+    const isFillingNow = Boolean(activeOpenOrd && ordAgeMs < 60000);
     const lots = Math.floor(Math.abs(aQty) / (sp.lotSize || 1));
     const avgPx = Number(pos.avgPrice) || 0;
     if (lots < 1 || avgPx <= 0) continue;
     const side = aQty > 0 ? 'long' : 'short';
     const stopPx = roundToStep(side === 'long' ? avgPx * (1 - BROKER_STOP_LONG_PCT / 100) : avgPx * (1 + BROKER_STOP_SHORT_PCT / 100), sp.minStep, sp.decimals);
-    want.set(sym, { lots, side, stopPx, sp });
+    want.set(sym, { lots, side, stopPx, sp, filling: isFillingNow });
   }
   let changed = false;
   // 1) снять свои стоп-заявки без позиции, сработавшие (их нет среди активных) или с другим объёмом / ценой / стороной
   for (const [sym, t] of Object.entries(acc.brokerStopBySymbol)) {
     const w = want.get(sym);
     const alive = t?.stopOrderId && active.has(t.stopOrderId);
+    if (alive && w?.filling && w.side === t.side) continue;
     const same = alive && w && w.lots === t.lots && w.side === t.side && Math.abs(w.stopPx - t.stopPx) < (w.sp.minStep || 0.01) / 2;
     if (same) continue;
     if (alive) {
       try { await tbankCancelStop(acc, t.stopOrderId); } catch (e) { logBrokerEvent(acc, 'broker_stop_error', `${sym}: ${e.message}`); continue; }
     }
-    logBrokerEvent(acc, alive ? 'broker_stop_cancel' : 'broker_stop_gone', `${sym}: ${!w ? 'позиции стратегии нет' : !alive ? 'стоп-заявка сработала или снята у брокера' : 'объём или цена позиции изменились'}`);
-    // стоп сработал, а позиция в данных ещё видна — не выставляем новый, пока портфель не обновится (иначе возможна повторная продажа)
-    if (!alive) acc.brokerStopCooldown[sym] = Date.now();
+    logBrokerEvent(acc, alive ? 'broker_stop_cancel' : 'broker_stop_gone', `${sym}: ${!alive ? 'стоп-заявка сработала или снята у брокера' : !w ? 'позиции стратегии нет' : 'объём или цена позиции изменились'}`);
+    // стоп сработал у брокера: включаем 60-минутную паузу повторного входа и блокируем перевыставление стопа до обновления портфеля
+    if (!alive) {
+      const nowStopTs = Date.now();
+      acc.brokerStopCooldown[sym] = nowStopTs;
+      acc.exitCooldownBySymbol = acc.exitCooldownBySymbol || {};
+      acc.exitCooldownBySymbol[sym] = nowStopTs;
+      if (acc.entryTsBySymbol) delete acc.entryTsBySymbol[sym];
+      if (acc.peakPriceBySymbol) delete acc.peakPriceBySymbol[sym];
+    }
     delete acc.brokerStopBySymbol[sym];
     changed = true;
   }
   // 2) выставить недостающие
   for (const [sym, w] of want) {
-    if (acc.brokerStopBySymbol[sym]) continue;
+    if (acc.brokerStopBySymbol[sym] || w.filling) continue;
     const cd = acc.brokerStopCooldown[sym];
     if (cd && (Date.now() - cd < 120000 || Number(acc.lastSync?.at || 0) < cd + 30000)) continue;
     if (cd) { delete acc.brokerStopCooldown[sym]; changed = true; }
@@ -3326,12 +3359,14 @@ async function checkIntradayProfitLock(accId) {
     const lastHistEntryOp = histOps.find((op) => op.symbol === sym && op.kind === wantOpenKind && op.date > 0);
     const avgPx = Number(pos.avgPrice) > 0 ? Number(pos.avgPrice) : (Number(lastHistEntryOp?.price) || curPx);
     if (avgPx <= 0) continue;
+    const effEntryTs = Math.max(Number(acc.entryTsBySymbol?.[sym]) || 0, Number(lastHistEntryOp?.date) || 0);
+    const heldMin = effEntryTs > 0 ? Math.max(0, (Date.now() - effEntryTs) / 60000) : 999;
 
     if (aQty > 0) {
       const lots = Math.floor(aQty / sp.lotSize);
       if (lots < 1) continue;
       const curGainPct = ((curPx - avgPx) / avgPx) * 100;
-      const profitLockReason = evaluateProfitLock(sym, 'long', avgPx, curPx, Number(peakMap[sym]) || 0, roundTripFeePct);
+      const profitLockReason = evaluateProfitLock(sym, 'long', avgPx, curPx, Number(peakMap[sym]) || 0, roundTripFeePct, heldMin);
       const hitHardStopLoss = !hasBrokerHardStop && curGainPct <= -BROKER_STOP_LONG_PCT;
       if (hitHardStopLoss || profitLockReason) {
         const limitPrice = sniperLimitPrice(curPx, -1, acc.limitOffsetPct, sp);
@@ -3346,7 +3381,7 @@ async function checkIntradayProfitLock(accId) {
       const lots = Math.floor(Math.abs(aQty) / sp.lotSize);
       if (lots < 1) continue;
       const curGainPct = ((avgPx - curPx) / avgPx) * 100;
-      const profitLockReason = evaluateProfitLock(sym, 'short', avgPx, curPx, Number(peakMap[sym]) || 0, roundTripFeePct);
+      const profitLockReason = evaluateProfitLock(sym, 'short', avgPx, curPx, Number(peakMap[sym]) || 0, roundTripFeePct, heldMin);
       const hitHardStopLoss = !hasBrokerHardStop && curGainPct <= -BROKER_STOP_SHORT_PCT;
       if (hitHardStopLoss || profitLockReason) {
         const limitPrice = sniperLimitPrice(curPx, 1, acc.limitOffsetPct, sp);
@@ -3391,7 +3426,9 @@ async function checkIntradayProfitLock(accId) {
       sentLockOrders.push(ord);
       delete acc.entryTsBySymbol[ord.symbol];
       delete acc.peakPriceBySymbol[ord.symbol];
-      if (ord.isStopLoss) acc.exitCooldownBySymbol[ord.symbol] = execNowTs;
+      if (ord.symbol !== 'LQDT') {
+        acc.exitCooldownBySymbol[ord.symbol] = ord.isStopLoss ? execNowTs : (execNowTs - 30 * 60000);
+      }
     } catch (e) {
       results.push({ symbol: ord.symbol, ok: false, error: e.message });
       logBrokerEvent(acc, 'protective_stop_error', `${ord.symbol}: ${e.message}`);

package/server/model/edge.js

@@ -49,6 +49,12 @@ export function isRegimeShocked(ds, i, t, side = 'long') {
   if (p0 > 0 && p1 > 0 && m0 > 0 && m1 > 0) {
     const ex1d = (p1 / p0 - 1) - (m1 / m0 - 1);
     if (side === 'short' ? ex1d > REGIME_SHOCK_1D : ex1d < -REGIME_SHOCK_1D) return true;
+    // Защита от биржевой планки (верхней/нижней границы ценового коридора Мосбиржи):
+    // если при миллионном обороте за 10-минутную свечу все сделки идут по одной предельной цене (high === low) после сильного сдвига (>5% к индексу),
+    // встречная сторона в стакане отсутствует
+    if (tk.high?.[t] > 0 && tk.high[t] === tk.low[t] && tk.value?.[t] > 1e6) {
+      if (side === 'short' ? ex1d > 0.05 : ex1d < -0.05) return true;
+    }
   }
   if (side === 'long' && t >= 3) {
     const t3 = t - 3;
@@ -93,9 +99,15 @@ const MSK = 3 * 3600000;
 const DAY = 86400000;
 export const SESSION_END_MINS_MSK = 23 * 60 + 40;
 
-export const canEnterIntraday = (ts, horizonBars, barInterval = 10) => {
+export const canEnterIntraday = (ts, horizonBars, barInterval = 10, side = null, symbol = null) => {
   const minsMsk = Math.floor(((ts + MSK) % DAY) / 60000);
-  return minsMsk <= SESSION_END_MINS_MSK - horizonBars * barInterval;
+  if (minsMsk > SESSION_END_MINS_MSK - horizonBars * barInterval) return false;
+  // В первые 20 минут утренней сессии (свечи 07:00 и 07:10 МСК) в бумагах 2-го эшелона стакан ещё пустой,
+  // а ночные корпоративные новости и утренние гэпы искажают часовой остаток z — шорты 2-го эшелона в это окно блокируются
+  if (side === 'short' && minsMsk >= 7 * 60 && minsMsk < 7 * 60 + 20 && (!symbol || !TIER1_LIQUID_SYMBOLS.has(symbol))) {
+    return false;
+  }
+  return true;
 };
 
 export const shouldExitBeforeNight = (ts, entryTs = 0, stepBars = 3, barInterval = 10) => {

package/server/model/forecast.js

@@ -5,7 +5,7 @@ import { loadDataset, barsFromHours, BAR_MS } from './dataset.js';
 import { buildFold, MODELS, HEADS, KINDS, SCALES, BETAS, LIQ_MIN, FEATURE_WARMUP, explainAttention, mapSnapshot } from './models.js';
 import { loadProfiles } from './profiles.js';
 import { isMarketDown } from './research.js';
-import { ENTRY_EDGE_MULT, TIER2_EDGE_MULT, TIER1_LIQUID_SYMBOLS, symbolEdgeMult, computeTokenEdgeMults, REGIME_SHOCK_1D, REGIME_CRASH_30M } from './edge.js';
+import { ENTRY_EDGE_MULT, TIER2_EDGE_MULT, TIER1_LIQUID_SYMBOLS, symbolEdgeMult, computeTokenEdgeMults, REGIME_SHOCK_1D, REGIME_CRASH_30M, canEnterIntraday } from './edge.js';
 export { TIER1_LIQUID_SYMBOLS, symbolEdgeMult, computeTokenEdgeMults };
 import { newsForSymbols, blockingNews } from '../news/index.js';
 import { liveDividendGuard } from './dividends.js';
@@ -403,13 +403,18 @@ function buildPredictionRows(ds, p, idx, f, u, fitted, chosen, H, effMinEdge, au
     const tierMult = edgeMults[i] || symbolEdgeMult(tk.symbol);
     const symNeedL = Math.max(needL * tierMult, 0.0030);
     const symNeedS = Math.max(needS * tierMult, 0.0031);
-    // Аварийный предохранитель экстремальных свечей (±4,5% за одну 10-минутную свечу) и структурного слома режима (≥20% за день или обвал ≥9,5% за 30м):
+    // Аварийный предохранитель экстремальных свечей (±4,5% за одну 10-минутную свечу), биржевых планок и структурного слома режима (≥20% за день или обвал ≥9,5% за 30м):
     // обычные рабочие импульсы 1,5–3,5% НЕ блокируются, так как именно на возврате к среднему после локального выброса модель формирует сигнал!
     const EXTREME_BAR_MOVE_PCT = 4.5;
-    const isRegimeCrash = excess1d < -REGIME_SHOCK_1D || excess30m < -REGIME_CRASH_30M;
-    const isRegimeSqueeze = excess1d > REGIME_SHOCK_1D;
+    const isFlatLimitBar = tk.high?.[idx] > 0 && tk.high[idx] === tk.low[idx] && tk.value?.[idx] > 1e6;
+    const isLimitUpLocked = isFlatLimitBar && excess1d > 0.05;
+    const isLimitDownLocked = isFlatLimitBar && excess1d < -0.05;
+    const barDecisionTs = ds.timeline[idx] || Date.now();
+    const isMorningOpenShortBlocked = autoAdapt && !canEnterIntraday(barDecisionTs, H, 10, 'short', tk.symbol);
+    const isRegimeCrash = excess1d < -REGIME_SHOCK_1D || excess30m < -REGIME_CRASH_30M || isLimitDownLocked;
+    const isRegimeSqueeze = excess1d > REGIME_SHOCK_1D || isLimitUpLocked;
     const isExtremeDip = Boolean(isRegimeCrash || (liveSnap && (lastMovePct < -EXTREME_BAR_MOVE_PCT || rawPriceMovePct < -EXTREME_BAR_MOVE_PCT)));
-    const isExtremeSpike = Boolean(isRegimeSqueeze || (liveSnap && (lastMovePct > EXTREME_BAR_MOVE_PCT || rawPriceMovePct > EXTREME_BAR_MOVE_PCT)));
+    const isExtremeSpike = Boolean(isRegimeSqueeze || isMorningOpenShortBlocked || (liveSnap && (lastMovePct > EXTREME_BAR_MOVE_PCT || rawPriceMovePct > EXTREME_BAR_MOVE_PCT)));
     const liveBuyOk = !isExtremeDip && !buyBlockedByOverheat;
     const liveShortOk = !isExtremeSpike;
     // сигналы — только по бумагам из текущего состава индекса (исторические бумаги остаются в матрице рынка как контекст)

package/server/model/live.js

@@ -461,7 +461,7 @@ class LiveEngine {
       };
       const open = (x) => !s.held.has(x.symbol) && !closing.has(x.symbol);
       const candL = (mktDown || !timeOk) ? [] : r.rows.filter((x) => x.signal && open(x)).sort((a, b) => b.expected - a.expected);
-      const candS = (dir === 'long' || !timeOk) ? [] : r.rows.filter((x) => x.shortSignal && open(x)).sort((a, b) => a.expected - b.expected);
+      const candS = (dir === 'long' || !timeOk) ? [] : r.rows.filter((x) => x.shortSignal && open(x) && (!autoAdapt || canEnterIntraday(ts, H, BAR_INTERVAL, 'short', x.symbol))).sort((a, b) => a.expected - b.expected);
       const usedNow = [...s.held.entries()].filter(([sym]) => !closing.has(sym)).reduce((sum, [, h]) => sum + h.alloc, 0);
       if (autoAdapt && usedNow > s.equity * 0.65 && (candL.length > 0 || candS.length > 0)) {
         const bestNewEdge = Math.max(candL.length ? candL[0].expected : 0, candS.length ? Math.abs(candS[0].expected) : 0);

package/server/model/research.js

@@ -43,7 +43,8 @@ export function isMarketDown(ds, t) {
 // 12: калибровка индивидуальных порогов 2–3 эшелона по ликвидности, защита от шорт-сквизов (≥20% за день) и обвалов (≥9,5% за 30м), отбор доступных шортов до Top-K
 // 13: полная докачка левого края истории свечей (раньше при уже накопленных свечах 2022 год не догружался)
 // 14: фиксация начала датасета современного 17-часового режима Мосбиржи (18.01.2024) и якоря фолдов после редомициляции (13.06.2024)
-const DATA_VERSION = 14;
+// 15: защита от биржевых планок (high === low) и блокировка утренних шортов 2-го эшелона в первые 20 минут сессии (07:00–07:20 МСК)
+const DATA_VERSION = 15;
 
 const AUTO_LOCKED = { modelHorizon: 2.5, modelMinEdge: 2.5, modelExitRatio: 0.95 };
 function reuseParamsKey(params) {
@@ -466,7 +467,7 @@ async function run(runId, p, state) {
       const timeOk = !autoAdapt || canEnterIntraday(barTs, H, BAR_INTERVAL);
       const canOpenAt = (i) => timeOk && !held.has(i) && !closedThisBar.has(i) && stockAllowed(i) && canEnter(i, t);
       const okLong = (i) => !divRule(i, t)?.blockLong && (!needTrade || (tokens[i].has[tIn] && tokens[i].open[tIn] > 0)) && (!autoAdapt || !isRegimeShocked(ds, i, t, 'long'));
-      const okShort = (i) => !divRule(i, t)?.blockShort && (!shortable || shortable.has(tokens[i].symbol)) && (!needTrade || (tokens[i].has[tIn] && tokens[i].open[tIn] > 0)) && (!autoAdapt || !isRegimeShocked(ds, i, t, 'short'));
+      const okShort = (i) => !divRule(i, t)?.blockShort && (!shortable || shortable.has(tokens[i].symbol)) && (!needTrade || (tokens[i].has[tIn] && tokens[i].open[tIn] > 0)) && (!autoAdapt || (!isRegimeShocked(ds, i, t, 'short') && canEnterIntraday(barTs, H, BAR_INTERVAL, 'short', tokens[i].symbol)));
       let order, entries;
       if (dir !== 'long') {
         const edge = (i) => pr[i] * sg[i] * Math.sqrt(H);
@@ -1124,7 +1125,7 @@ async function runStabilityLoop(targetId, runRow, st) {
         const timeOk = !autoAdapt || canEnterIntraday(barTs, H, BAR_INTERVAL);
         const canOpenAt = (i) => timeOk && !held.has(i) && !closedThisBar.has(i) && stockAllowed(i) && canEnter(i, t);
         const okLong = (i) => !divRule(i, t)?.blockLong && (!autoAdapt || !isRegimeShocked(ds, i, t, 'long'));
-        const okShort = (i) => !divRule(i, t)?.blockShort && (!autoAdapt || !isRegimeShocked(ds, i, t, 'short'));
+        const okShort = (i) => !divRule(i, t)?.blockShort && (!autoAdapt || (!isRegimeShocked(ds, i, t, 'short') && canEnterIntraday(barTs, H, BAR_INTERVAL, 'short', tokens[i].symbol)));
         const edge = (i) => pr[i] * sg[i] * Math.sqrt(H);
         const need = effMinEdge * 2 * realCost * ENTRY_EDGE_MULT, exitNeed = need * curExitRatio, earlyExitNeed = need * 0.35;
         let order, entries;