neuroalpha 0.6.2 → 0.6.4

package/package.json

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

package/public/app.js

@@ -1076,6 +1076,10 @@ async function loadForecast(force, silent = false) {
           reasons.push(`Фильтр новостей (сильный позитив): ${r.shortBlockedByNews}`);
           if (!label) label = '⛔ новости';
         }
+        if (r.shortBlockedByTime) {
+          reasons.push('Вне внутридневного окна открытия новых шортов (утренний старт или конец сессии)');
+          if (!label) label = '⛔ вне окна';
+        }
       } else {
         const dip = Boolean(r.buyBlockedByDip || (r.expectedPct > 0 && (r.lastMovePct ?? 0) < -4.5));
         if (dip) {
@@ -4226,6 +4230,8 @@ function buildStockModalHeaderHtml(d) {
         ? '<span class="tag blocked" title="Аварийная защита от сквиза: бумага взлетела на текущей свече (> +4,5%)">⛔ защита от сквиза</span>'
         : fc?.shortBlockedByBroker
           ? '<span class="tag blocked" title="Брокер запрещает короткие продажи по этой бумаге">⛔ шорт запрещён брокером</span>'
+          : fc?.shortBlockedByTime
+            ? '<span class="tag blocked" title="Вне внутридневного окна открытия новых шортов">⛔ вне окна шорта</span>'
           : fc?.buyBlockedByDip
             ? '<span class="tag blocked" title="Аварийная защита от обвала: бумага падает на текущей свече (< −4,5%)">⛔ защита от провала свечи</span>'
             : fc?.buyBlockedByOverheat

package/server/brokers/index.js

@@ -1706,11 +1706,20 @@ const entryImpulseWatch = new Map(); // `${accId}:${symbol}:${side}` -> { firstT
 // Фильтр затухания минутного импульса перед входом (Impulse Exhaustion):
 // не даёт продавать в шорт посередине вертикально растущей минутной свечи (или покупать в полёт падающего ножа),
 // дожидаясь остановки разгона и подтверждённого отката от пика/дна (с шагом проверки 20 секунд; без принудительного входа по таймауту)
+// Порог удержания уже взятого на прицел сигнала в entryImpulseWatch: пока ждём минутного отката,
+// само ожидание возврата к среднему неизбежно немного снижается — не теряем сигнал, пока он держится >= 90% порога (до 6 минут)
+const IMPULSE_WATCH_HOLD_RATIO = 0.90;
+const IMPULSE_WATCH_TTL_MS = 6 * 60000;
+const isOnImpulseWatch = (accId, sym, side, nowTs = Date.now()) => {
+  const w = entryImpulseWatch.get(`${accId}:${sym}:${side}`);
+  return Boolean(w && nowTs - w.firstTs <= IMPULSE_WATCH_TTL_MS && nowTs - w.lastTs <= IMPULSE_WATCH_TTL_MS);
+};
+
 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) {
-    if (nowTs - v.lastTs > 15 * 60000) entryImpulseWatch.delete(k);
+    if (nowTs - v.lastTs > IMPULSE_WATCH_TTL_MS || nowTs - v.firstTs > IMPULSE_WATCH_TTL_MS) entryImpulseWatch.delete(k);
   }
+  if (!cands.length || acc.broker !== 'tbank' || !acc.token) return { ready: cands, deferred: [] };
   const ready = [];
   const deferred = [];
   for (const r of cands) {
@@ -1750,9 +1759,12 @@ async function filterByImpulseExhaustion(acc, cands, side, specs, nowTs = Date.n
       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);
+      // Если внутри самой минутной свечи цена уже взлетела до recentHigh и откатилась от пика на >= 1,4× порога отката (и >= 0,55%),
+      // разворот с вершины уже состоялся — не ждём следующей минутной свечи!
+      const intrabarReversalDown = Boolean(last1m && pullbackPct >= Math.max(0.55, minPullbackPct * 1.4) && pullbackTicks >= 4 && curPx <= last1m.high - step * 3);
       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);
+      const readyShort = isStrongSurge ? (peakedAndPulledBack && (barTurnedDown || intrabarReversalDown)) : (peakedAndPulledBack || barTurnedDown || tickedDownFromPrev);
       if (readyShort) {
         entryImpulseWatch.delete(wKey);
         r.price = curPx;
@@ -1765,10 +1777,11 @@ async function filterByImpulseExhaustion(acc, cands, side, specs, nowTs = Date.n
       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 barTurnedUp = Boolean(last1m && prev1m && last1m.low >= prev1m.low - step * 0.5 && last1m.close >= last1m.open);
+      const intrabarReversalUp = Boolean(last1m && bouncePct >= Math.max(0.55, minPullbackPct * 1.4) && bounceTicks >= 4 && curPx >= last1m.low + step * 3);
       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);
+      const readyLong = isStrongSurge ? (bottomedAndBounced && (barTurnedUp || intrabarReversalUp)) : (bottomedAndBounced || barTurnedUp || tickedUpFromPrev);
       if (readyLong) {
         entryImpulseWatch.delete(wKey);
         r.price = curPx;
@@ -1813,7 +1826,7 @@ export async function prepareBrokerOrders(id, { onlyEntries = false, scheduledBa
   let list = loadRawAccounts();
   let acc = list.find((x) => x.id === id);
   if (!acc) throw new Error('Счёт не найден');
-  const exitsOnly = isDailyStopHalt(acc);
+  let exitsOnly = isDailyStopHalt(acc);
   if (acc.haltedReason && !exitsOnly) throw new Error(acc.haltedReason);
   const edgeWarn = acc.skipEdgeMinutes ? sessionEdgeWarning() : null;
   if (onlyEntries && (edgeWarn || exitsOnly)) {
@@ -1835,6 +1848,9 @@ export async function prepareBrokerOrders(id, { onlyEntries = false, scheduledBa
     list = loadRawAccounts();
     acc = list.find((x) => x.id === id) || acc;
   }
+  exitsOnly = isDailyStopHalt(acc);
+  if (acc.haltedReason && !exitsOnly) throw new Error(acc.haltedReason);
+  if (onlyEntries && exitsOnly) return brokersState();
   const params = normalizeParams(getSettings());
   const [fc, rawSpecs, shortableMap] = await withWallTimeout(Promise.all([
     forecastNow(params),
@@ -1972,10 +1988,14 @@ export async function prepareBrokerOrders(id, { onlyEntries = false, scheduledBa
   const divGuardOf = (sym, px) => liveDividendGuard(sym, Number(px) || specs[sym]?.lastPrice || 0, nowTs);
   const divBlocked = [];
   const entryTimeOk = timeOk && !edgeWarn && !exitsOnly;
-  const buyCands = !entryTimeOk ? [] : fc.rows.filter((r) => r.signal && r.expectedPct >= reqBuyEdgeOf(r.symbol) && !isInCooldown(r.symbol) && !isDayBlocked(r.symbol, 'buy') && !quarantined.has(r.symbol) && !nb?.get(r.symbol)?.bad)
+  const canBuyRow = (r) => (r.signal && r.expectedPct >= reqBuyEdgeOf(r.symbol))
+    || (isOnImpulseWatch(acc.id, r.symbol, 'buy', nowTs) && r.liquid && r.inIndex !== false && !r.buyBlockedByDip && !r.buyBlockedByOverheat && !r.buyBlockedByDiv && !r.buyBlockedByNews && r.expectedPct >= reqBuyEdgeOf(r.symbol) * IMPULSE_WATCH_HOLD_RATIO);
+  const canShortRow = (r) => (r.shortSignal && r.expectedPct <= -reqShortEdgeOf(r.symbol))
+    || (isOnImpulseWatch(acc.id, r.symbol, 'short', nowTs) && r.liquid && r.inIndex !== false && r.shortAllowed !== false && !r.shortBlockedBySqueeze && !r.shortBlockedByDiv && !r.shortBlockedByNews && r.expectedPct <= -reqShortEdgeOf(r.symbol) * IMPULSE_WATCH_HOLD_RATIO);
+  const buyCands = !entryTimeOk ? [] : fc.rows.filter((r) => canBuyRow(r) && !isInCooldown(r.symbol) && !isDayBlocked(r.symbol, 'buy') && !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' && entryTimeOk) ? fc.rows.filter((r) => r.shortSignal && r.expectedPct <= -reqShortEdgeOf(r.symbol) && (!autoAdapt || canEnterIntraday(nowTs, H, BAR_INTERVAL, 'short', r.symbol)) && !isInCooldown(r.symbol) && !isDayBlocked(r.symbol, 'short') && !quarantined.has(r.symbol) && !nb?.get(r.symbol)?.good)
+  const allShortSignals = (rawDir !== 'long' && entryTimeOk) ? fc.rows.filter((r) => canShortRow(r) && (!autoAdapt || canEnterIntraday(nowTs, H, BAR_INTERVAL, 'short', r.symbol)) && !isInCooldown(r.symbol) && !isDayBlocked(r.symbol, 'short') && !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 = [];
@@ -2849,23 +2869,25 @@ export async function executeBrokerOrders(id, { _lockHeld = false } = {}) {
     if (!acc) throw new Error('Счёт не найден');
     if (acc.mode === 'readonly') throw new Error('Счёт в режиме «Только чтение» — отправка заявок отключена');
     const gate = tradingGate();
-    if (!gate.allowNew) throw new Error(gate.reason);
+    if (!gate.allowNew && !gate.allowProtective) throw new Error(gate.reason);
     const batch = acc.pendingBatch;
     if (!batch || !batch.orders?.length) throw new Error('Нет подготовленных заявок для отправки');
     if (batch.status === 'executed' || batch.status === 'executing') return brokersState();
-    if (acc.haltedReason && !(isDailyStopHalt(acc) && batch.orders.every(isExitOrder))) throw new Error(acc.haltedReason);
-    // Пакет мог ждать подтверждения в Telegram/MAX: входы по устаревшему сигналу, вне окна входов или в окне начала сессии не отправляем
+    if (acc.haltedReason && !isDailyStopHalt(acc)) throw new Error(acc.haltedReason);
+    // Пакет мог ждать подтверждения в Telegram/MAX: входы по устаревшему сигналу, вне окна входов, при дневном стопе или в окне начала сессии не отправляем (выходы сохраняются!)
     const execCheckTs = Date.now();
     const staleWhy = (() => {
+      if (!gate.allowNew) return gate.reason;
+      if (isDailyStopHalt(acc)) return acc.haltedReason;
       if (execCheckTs - (batch.createdAt || 0) > 10 * 60000) return `сигнал устарел (пакет сформирован ${Math.round((execCheckTs - (batch.createdAt || 0)) / 60000)} мин назад)`;
       if (!canEnterIntraday(execCheckTs, barsFromHours(2.5), BAR_INTERVAL)) return 'окно новых входов уже закрыто';
       if (acc.skipEdgeMinutes && sessionEdgeWarning(execCheckTs)) return 'начало/конец сессии';
-      if (isDailyStopHalt(acc)) return acc.haltedReason;
       return null;
     })();
     if (staleWhy && batch.orders.some((o) => !isExitOrder(o) && o.symbol !== 'LQDT')) {
-      const dropped = batch.orders.filter((o) => !isExitOrder(o) && o.symbol !== 'LQDT');
-      batch.orders = batch.orders.filter((o) => isExitOrder(o) || o.symbol === 'LQDT');
+      const keepLqdt = !isDailyStopHalt(acc) && gate.allowNew;
+      const dropped = batch.orders.filter((o) => !isExitOrder(o) && !(keepLqdt && o.symbol === 'LQDT'));
+      batch.orders = batch.orders.filter((o) => isExitOrder(o) || (keepLqdt && o.symbol === 'LQDT'));
       logBrokerEvent(acc, 'order_skip', `входы не отправлены (${staleWhy}): ${dropped.map((o) => `${o.action} ${o.symbol}`).join(', ')}`);
       if (!batch.orders.length) {
         batch.status = 'expired';
@@ -2875,6 +2897,7 @@ export async function executeBrokerOrders(id, { _lockHeld = false } = {}) {
         throw new Error(`Входы не отправлены: ${staleWhy}`);
       }
     }
+    if (acc.haltedReason && !(isDailyStopHalt(acc) && batch.orders.every(isExitOrder))) throw new Error(acc.haltedReason);
     // Идемпотентность: у каждой заявки постоянный clientOrderId (для Т-Банка — orderId в PostOrder, брокер не исполнит его дважды).
     // ID закрепляется и сохраняется ДО отправки; при повторе пакета «partial» уже принятые брокером заявки не отправляются снова.
     for (const ord of batch.orders) {
@@ -2927,8 +2950,12 @@ export async function executeBrokerOrders(id, { _lockHeld = false } = {}) {
         results.push({ symbol: ord.symbol, ok: true, orderId: r.orderId, clientOrderId: ord.clientOrderId });
         newlySentOrders.push(ord);
         if (ord.action === 'buy' || ord.action === 'short') {
-          acc.entryTsBySymbol[ord.symbol] = execNowTs;
-          acc.peakPriceBySymbol[ord.symbol] = Number(ord.limitPrice || ord.refPrice) || 0;
+          if (!acc.entryTsBySymbol[ord.symbol]) acc.entryTsBySymbol[ord.symbol] = execNowTs;
+          const ordPx = Number(ord.limitPrice || ord.refPrice) || 0;
+          const prevPeak = Number(acc.peakPriceBySymbol[ord.symbol]) || 0;
+          acc.peakPriceBySymbol[ord.symbol] = prevPeak > 0 && ordPx > 0
+            ? (ord.action === 'buy' ? Math.max(prevPeak, ordPx) : Math.min(prevPeak, ordPx))
+            : (ordPx || prevPeak);
           delete acc.exitCooldownBySymbol[ord.symbol];
           delete acc.entryFailCooldownBySymbol[ord.symbol];
           delete acc.entryFailReasonBySymbol[ord.symbol];
@@ -3231,7 +3258,8 @@ async function tickBrokerSchedule() {
           const lqdtBaseQty = Number(acc.baselineQty?.LQDT || 0);
           const lqdtAvailRub = lqdtPos ? Math.max(0, (lqdtPos.qty - (acc.legacyMode === 'takeover' ? 0 : Math.max(0, lqdtBaseQty))) * (lqdtPos.price || 0)) : 0;
           const freeCashRub = Number(acc.lastSync?.cashRub ?? acc.maxCapitalRub ?? 0) + lqdtAvailRub;
-          if (acc.mode === 'auto' && acc.token && !acc.haltedReason && !(acc.skipEdgeMinutes && sessionEdgeWarning(nowTs)) && freeCashRub >= 15000 && nowTs - Math.max(lastFullWallTs, lastAnyWallTs) >= 20000) {
+          const marketActiveNow = Boolean(latest && nowTs - latest <= 25 * 60000);
+          if (marketActiveNow && acc.mode === 'auto' && acc.token && !acc.haltedReason && !(acc.skipEdgeMinutes && sessionEdgeWarning(nowTs)) && freeCashRub >= 15000 && nowTs - Math.max(lastFullWallTs, lastAnyWallTs) >= 20000) {
             await prepareBrokerOrders(acc.id, { onlyEntries: true }).catch(() => {});
           }
         }
@@ -3355,6 +3383,7 @@ async function reconcileBrokerStopsLocked(list, acc) {
   const headers = tbankHeaders(acc);
   const want = new Map();
   const activeOrders = acc.lastSync?.activeOrders || [];
+  const histOps = Array.isArray(acc.lastHistory?.operations) ? acc.lastHistory.operations : [];
   for (const pos of acc.lastSync.positions || []) {
     const sym = pos.symbol;
     if (!sym || pos.instrumentType === 'etf' || pos.instrumentType === 'bond' || sym === 'LQDT' || sym === 'TMON@' || sym === 'TMON' || sym === 'SBMM') continue;
@@ -3369,7 +3398,8 @@ async function reconcileBrokerStopsLocked(list, acc) {
     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;
+    const lastHistEntryOp = histOps.find((op) => op.symbol === sym && op.kind === wantOpenDir && op.date > 0);
+    const avgPx = Number(pos.avgPrice) > 0 ? Number(pos.avgPrice) : (Number(lastHistEntryOp?.price) || Number(pos.price) || 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);
@@ -3435,16 +3465,19 @@ async function reconcileBrokerStopsLocked(list, acc) {
   }
 }
 
-// Быстрая проверка и автоматическая фиксация прибыли (Take-Profit / защита безубытка от отката) каждые 2 минуты между шагами расписания
+// Быстрая проверка и автоматическая фиксация прибыли (Take-Profit / защита безубытка от отката) каждые 25 секунд между шагами расписания
 async function checkIntradayProfitLock(accId) {
-  const list = loadRawAccounts();
-  const acc = list.find((x) => x.id === accId);
-  if (!acc || acc.mode !== 'auto' || !acc.token || (acc.haltedReason && !isDailyStopHalt(acc))) return;
   if (!tradingGate().allowProtective) return;
   const nowMsk = new Date(Date.now() + MSK);
   const dow = nowMsk.getUTCDay();
   const mins = nowMsk.getUTCHours() * 60 + nowMsk.getUTCMinutes();
   if (dow === 0 || dow === 6 || mins < 6 * 60 + 55 || mins > 23 * 60 + 48) return;
+  const lockToken = acquireAccountLock(accId);
+  if (!lockToken) return;
+  try {
+  const list = loadRawAccounts();
+  const acc = list.find((x) => x.id === accId);
+  if (!acc || acc.mode !== 'auto' || !acc.token || (acc.haltedReason && !isDailyStopHalt(acc))) return;
   // В окнах начала/конца сессии (широкий спред) фиксация прибыли не срабатывает на шуме стакана, а стопы работают всегда
   const edgeNow = Boolean(acc.skipEdgeMinutes && sessionEdgeWarning());
 
@@ -3561,7 +3594,7 @@ async function checkIntradayProfitLock(accId) {
       logBrokerEvent(acc, 'protective_stop_error', `${ord.symbol}: ${e.message}`);
     }
   }
-  acc.pendingBatch = {
+  const stopBatchObj = {
     ...(acc.pendingBatch || {}),
     id: `batch_stop_${execNowTs}`,
     createdAt: execNowTs,
@@ -3571,13 +3604,19 @@ async function checkIntradayProfitLock(accId) {
     status: results.every((r) => r.ok) ? 'executed' : 'partial',
     results,
   };
+  if (acc.pendingBatch?.status !== 'pending' && acc.pendingBatch?.status !== 'executing') {
+    acc.pendingBatch = stopBatchObj;
+  }
   saveRawAccounts(list);
   if (sentLockOrders.length > 0) {
-    notifyBrokerBatch(currentUserId(), acc, { ...acc.pendingBatch, orders: sentLockOrders }).catch(() => {});
+    notifyBrokerBatch(currentUserId(), acc, { ...stopBatchObj, orders: sentLockOrders }).catch(() => {});
   }
   await syncBrokerAccount(accId).catch(() => {});
   const st = brokersState();
   hub.emit({ type: 'brokers:update', state: st });
+  } finally {
+    releaseAccountLock(accId, lockToken);
+  }
 }
 
 // Автоматическое периодическое фоновое обновление портфеля и контроль фиксации прибыли (раз в 25 секунд; история операций — раз в 2 минуты)

package/server/model/dataset.js

@@ -230,8 +230,14 @@ export async function loadDataset({ interval = BAR_INTERVAL, fromTs, tillTs, use
   const latestClosedSlotTs = Math.floor((Math.min(tillTs, now) - bMs) / bMs) * bMs;
   const isCacheFreshForSlot = (entry) => {
     if (!isTradingNow || now - entry.at < 50000) return true;
-    const lastBar = entry.ds?.timeline?.[entry.ds.T - 1] || 0;
-    return lastBar >= latestClosedSlotTs;
+    if (entry.at < latestClosedSlotTs + bMs) return false;
+    const tl = entry.ds?.timeline;
+    if (!tl?.length) return false;
+    let lastClosedBar = 0;
+    for (let i = tl.length - 1; i >= 0; i--) {
+      if (tl[i] + bMs <= now) { lastClosedBar = tl[i]; break; }
+    }
+    return lastClosedBar >= latestClosedSlotTs;
   };
   const key = cacheKey(interval, fromTs, tillTs, useMacro, useDividends, localOnly);
   const hit = datasetCache.get(key);

package/server/model/forecast.js

@@ -19,17 +19,29 @@ const inflight = new Map();
 const inflightStartedAt = new Map();
 let nearSignalsCache = { key: null, scannedBarTs: 0, episodesMap: new Map(), list: [] };
 
-// Синхронная живая доходность индекса относительно закрытия свечи idx-1:
-// если есть живые котировки акций индекса (из Т-Банка с 0 сек задержки или из MOEX ISS),
-// считаем средневзвешенную лог-доходность по весам индекса, чтобы не сравнивать секундные цены акций Т-Банка
-// с отстающим на 15–20 минут значением IMOEX из бесплатного контура MOEX ISS!
+// Синхронная живая доходность индекса относительно базовой закрытой свечи baseIdx:
+// если последняя закрытая 10-минутная свеча idx уже закончилась (liveSnap.ts >= barTs + BAR_MS), живая цена относится к НОВОЙ
+// формирующейся свече после idx — поэтому базой служит tk.close[idx], а не tk.close[idx - 1]. Иначе два подряд растущих бара
+// складывались в одну точку и упирались в потолок 8σ одной свечи!
+const liveBaseIndexOf = (ds, idx, liveSnap) => {
+  const barTs = ds.timeline?.[idx] || 0;
+  return (liveSnap?.ts && barTs > 0 && liveSnap.ts >= barTs + BAR_MS) ? idx : Math.max(0, idx - 1);
+};
+const liveElapsedBarsOf = (ds, idx, liveSnap) => {
+  const barTs = ds.timeline?.[idx] || 0;
+  if (!(liveSnap?.ts && barTs > 0)) return 1;
+  const startTs = liveSnap.ts >= barTs + BAR_MS ? barTs + BAR_MS : barTs;
+  return Math.max(1, (liveSnap.ts - startTs) / BAR_MS);
+};
+
 function computeLiveMarketReturn(ds, idx, liveSnap) {
   if (idx < 1 || idx >= ds.T) return 0;
   if (liveSnap?.prices?.size > 0) {
+    const baseIdx = liveBaseIndexOf(ds, idx, liveSnap);
     let wSum = 0, rSum = 0, cnt = 0;
     for (const tk of ds.tokens) {
       if (tk.inIndex && !tk.inIndex[idx]) continue;
-      const prevPx = tk.close[idx - 1];
+      const prevPx = tk.close[baseIdx];
       const livePx = liveSnap.prices.get(tk.symbol);
       if (livePx > 0 && prevPx > 0) {
         const w = tk.weight > 0 ? tk.weight : 1;
@@ -39,44 +51,52 @@ function computeLiveMarketReturn(ds, idx, liveSnap) {
       }
     }
     if (cnt >= 15 && wSum > 0) return rSum / wSum;
-    const mPrev = ds.mclose?.[idx - 1] || 0;
+    const mPrev = ds.mclose?.[baseIdx] || 0;
     if (liveSnap.imoexPrice > 0 && mPrev > 0) return Math.log(liveSnap.imoexPrice / mPrev);
   }
   return ds.mret[idx] || 0;
 }
 
-// Быстрый расчёт признаков контекста в одной точке idx без переобучения матрицы внимания и весов (за ~1-2 мс)
+// Быстрый расчёт признаков контекста в одной точке idx без переобучения матрицы внимания и весов (за ~1-2 мс).
+// Выделяется дополнительный живой слот u+1, чтобы при формировании новой свечи (после закрытия idx) не затирать закрытую свечу idx!
 function buildInferenceFoldAt(ds, idx, fTrain, fitted, liveSnap = null) {
   const { tokens, mret } = ds;
   const N = fTrain.N;
   const { beta, sigma, cos } = fTrain;
   const lo = Math.max(1, idx - FEATURE_WARMUP - 2);
-  const u = idx - lo;
-  const W = u + 1;
+  const uClosed = idx - lo;
+  const barTs = ds.timeline[idx] || 0;
+  const hasNewLiveBar = Boolean(liveSnap?.prices?.size > 0 && liveSnap.ts && barTs > 0 && liveSnap.ts >= barTs + BAR_MS);
+  const u = hasNewLiveBar ? uClosed + 1 : uClosed;
+  const W = uClosed + 2;
 
   const z = new Float64Array(W * N);
   const vr = new Float64Array(W * N);
-  const barTs = ds.timeline[idx] || 0;
-  const elapsedBars = liveSnap?.ts && barTs > 0 ? Math.max(1, (liveSnap.ts - barTs) / BAR_MS) : 1;
-  const liveScale = 1 / Math.sqrt(elapsedBars);
-  const mLive = liveSnap?.prices?.size > 0 ? computeLiveMarketReturn(ds, idx, liveSnap) : (mret[idx] || 0);
-  for (let uk = 0; uk < W; uk++) {
+  for (let uk = 0; uk <= uClosed; uk++) {
     const t = lo + uk;
-    const isLast = uk === u && liveSnap?.prices?.size > 0;
-    const mt = isLast ? mLive : mret[t];
+    const mt = mret[t];
     for (let i = 0; i < N; i++) {
       const tk = tokens[i];
-      let rt = tk.ret[t];
-      if (isLast) {
-        const prevPx = tk.close[t - 1];
-        const livePx = liveSnap.prices.get(tk.symbol);
-        if (livePx > 0 && prevPx > 0) rt = Math.log(livePx / prevPx);
-      }
-      const e = (rt - beta[i] * mt) * (isLast ? liveScale : 1);
+      const e = tk.ret[t] - beta[i] * mt;
       z[uk * N + i] = Math.max(-8, Math.min(8, e / sigma[i]));
       vr[uk * N + i] = Math.min(4, tk.valRatio[t]);
     }
   }
+  for (let i = 0; i < N; i++) vr[(uClosed + 1) * N + i] = Math.min(4, tokens[i].valRatio[idx]);
+
+  if (liveSnap?.prices?.size > 0) {
+    const baseIdx = liveBaseIndexOf(ds, idx, liveSnap);
+    const liveScale = 1 / Math.sqrt(liveElapsedBarsOf(ds, idx, liveSnap));
+    const mLive = computeLiveMarketReturn(ds, idx, liveSnap);
+    for (let i = 0; i < N; i++) {
+      const tk = tokens[i];
+      const prevPx = tk.close[baseIdx];
+      const livePx = liveSnap.prices.get(tk.symbol);
+      const rt = (livePx > 0 && prevPx > 0) ? Math.log(livePx / prevPx) : (hasNewLiveBar ? 0 : tk.ret[idx]);
+      const e = (rt - beta[i] * mLive) * liveScale;
+      z[u * N + i] = Math.max(-8, Math.min(8, e / sigma[i]));
+    }
+  }
 
   const X = KINDS.map(() => SCALES.map(() => new Float32Array(W * N)));
   SCALES.forEach((sc, si) => {
@@ -101,17 +121,20 @@ function buildInferenceFoldAt(ds, idx, fTrain, fitted, liveSnap = null) {
     const list = fTrain.macro.list.map((mTrain) => {
       const dm = ds.macro.find((x) => x.id === mTrain.id);
       const zs = new Float32Array(SCALES.length * W);
-      if (dm) {
-        const msig = mTrain.msig || 1e-3;
-        SCALES.forEach((sc, si) => {
-          let sum = 0;
-          for (let k = 0; k < sc.len; k++) {
-            const t = idx - sc.from - k;
-            if (t >= 0) sum += Math.max(-8, Math.min(8, dm.ret[t] / msig));
+        if (dm) {
+          const msig = mTrain.msig || 1e-3;
+          for (const uk of [uClosed, uClosed + 1]) {
+            const baseT = Math.min(idx, lo + uk);
+            SCALES.forEach((sc, si) => {
+              let sum = 0;
+              for (let k = 0; k < sc.len; k++) {
+                const t = baseT - sc.from - k;
+                if (t >= 0) sum += Math.max(-8, Math.min(8, dm.ret[t] / msig));
+              }
+              zs[si * W + uk] = sum / Math.sqrt(sc.len);
+            });
           }
-          zs[si * W + u] = sum / Math.sqrt(sc.len);
-        });
-      }
+        }
       return { id: mTrain.id, label: mTrain.label, b: mTrain.b, zs };
     });
     macro = { list };
@@ -213,27 +236,33 @@ async function fetchLiveMoexSnapshot() {
   }
 }
 
-// Мгновенное обновление последней точки контекста u в уже обученной модели по живым котировкам (за ~2 мс)
-function applyLivePricesToFold(ds, f, u, fitted, liveSnap) {
-  if (!liveSnap?.prices?.size) return;
-  const idx = f.lo + u;
-  if (idx < 1 || idx >= ds.T) return;
+// Мгновенное обновление живой точки контекста в уже обученной модели по живым котировкам (за ~2 мс).
+// Возвращает индекс активной точки u (uClosed или uClosed+1, если после закрытия свечи idx уже идёт новая свеча).
+function applyLivePricesToFold(ds, f, idx, fitted, liveSnap) {
+  const uClosed = idx - f.lo;
+  if (!liveSnap?.prices?.size || idx < 1 || idx >= ds.T) return uClosed;
   const N = f.N;
-  const mLive = computeLiveMarketReturn(ds, idx, liveSnap);
   const barTs = ds.timeline[idx] || 0;
-  const elapsedBars = liveSnap.ts && barTs > 0 ? Math.max(1, (liveSnap.ts - barTs) / BAR_MS) : 1;
-  const liveScale = 1 / Math.sqrt(elapsedBars);
+  const hasNewLiveBar = Boolean(liveSnap.ts && barTs > 0 && liveSnap.ts >= barTs + BAR_MS && uClosed + 1 < f.W);
+  const u = hasNewLiveBar ? uClosed + 1 : uClosed;
+  // восстанавливаем чистую закрытую свечу idx на случай, если на предыдущем тике она обновлялась внутри свечи
+  for (let i = 0; i < N; i++) {
+    const tk = ds.tokens[i];
+    const e0 = tk.ret[idx] - f.beta[i] * ds.mret[idx];
+    f.z[uClosed * N + i] = Math.max(-8, Math.min(8, e0 / f.sigma[i]));
+  }
+  const baseIdx = liveBaseIndexOf(ds, idx, liveSnap);
+  const mLive = computeLiveMarketReturn(ds, idx, liveSnap);
+  const liveScale = 1 / Math.sqrt(liveElapsedBarsOf(ds, idx, liveSnap));
 
-  // 1) пересчитываем z[u*N + i] по живой цене акции с нормировкой к масштабу одной 10-минутной свечи
+  // 1) пересчитываем z[u*N + i] по живой цене акции относительно закрытия базовой свечи
   for (let i = 0; i < N; i++) {
     const tk = ds.tokens[i];
-    const prevPx = tk.close[idx - 1];
+    const prevPx = tk.close[baseIdx];
     const livePx = liveSnap.prices.get(tk.symbol);
-    if (livePx > 0 && prevPx > 0) {
-      const ret = Math.log(livePx / prevPx);
-      const e = (ret - f.beta[i] * mLive) * liveScale;
-      f.z[u * N + i] = Math.max(-8, Math.min(8, e / f.sigma[i]));
-    }
+    const ret = (livePx > 0 && prevPx > 0) ? Math.log(livePx / prevPx) : (hasNewLiveBar ? 0 : tk.ret[idx]);
+    const e = (ret - f.beta[i] * mLive) * liveScale;
+    f.z[u * N + i] = Math.max(-8, Math.min(8, e / f.sigma[i]));
   }
 
   // 2) пересчитываем все масштабы SCALES в точке u (как в buildInferenceFoldAt)
@@ -246,8 +275,9 @@ function applyLivePricesToFold(ds, f, u, fitted, liveSnap) {
         const uk = u - sc.from - k;
         if (uk < 0) break;
         const zk = f.z[uk * N + i];
+        const t = Math.min(idx, f.lo + uk);
         sp += zk;
-        sf += zk * Math.min(4, ds.tokens[i].valRatio[f.lo + uk]);
+        sf += zk * Math.min(4, ds.tokens[i].valRatio[t]);
       }
       Xp[u * N + i] = sp * invP;
       Xf[u * N + i] = sf * invF;
@@ -272,6 +302,7 @@ function applyLivePricesToFold(ds, f, u, fitted, liveSnap) {
       }
     }
   }
+  return u;
 }
 
 // Обучение ядра модели (карта рынка + веса внимания) выполняется не чаще 1 раза в торговый день для каждого набора параметров.
@@ -285,8 +316,9 @@ export async function predictAt(ds, p, idx, { explain = true, liveSnap = null, f
   const chosen = p.modelType in MODELS ? p.modelType : 'attention';
   const fitKey = JSON.stringify([autoAdapt, chosen, effHorizon, p.modelTrainDays, p.modelEmbedDim, p.modelUseMacro, p.modelUseDividends, p.modelTextWeight, ds.tokens.length]);
   const barDayMsk = new Date((ds.timeline[idx] || Date.now()) + MSK).toISOString().slice(0, 10);
+  const dayFitKey = `${fitKey}:${barDayMsk}`;
 
-  const cached = trainedModelCache.get(fitKey);
+  const cached = trainedModelCache.get(dayFitKey);
   if (!forceTrain && cached && cached.dayMsk === barDayMsk && cached.fTrain.N === ds.tokens.length) {
     const inf = buildInferenceFoldAt(ds, idx, cached.fTrain, cached.fitted, liveSnap);
     return {
@@ -300,7 +332,6 @@ export async function predictAt(ds, p, idx, { explain = true, liveSnap = null, f
   const trainStart = Math.max(FEATURE_WARMUP + maxH + 2, idx - trainLen);
   const profiles = p.modelTextWeight > 0 ? loadProfiles() : null;
   const f = buildFold(ds, { trainStart, testStart: idx, testEnd: idx + 1, H, embedDim: p.modelEmbedDim, textWeight: p.modelTextWeight, profiles, multiHorizon: autoAdapt });
-  const u = idx - f.lo;
   // Обучаем только выбранную модель (и attention для объяснения соседей и весов голов),
   // не тратя 15 секунд на холостое обучение матрицы leadlag, которая в прогнозе и живой торговле не используется!
   const list = [...new Set(['attention', chosen])];
@@ -325,7 +356,11 @@ export async function predictAt(ds, p, idx, { explain = true, liveSnap = null, f
     ...(fitted.attention ? { attention: { ...fitted.attention, F: null } } : {}),
   };
   const trainedAt = Date.now();
-  trainedModelCache.set(fitKey, { dayMsk: barDayMsk, trainedAt, fTrain, fitted: lightFitted, snap });
+  if (trainedModelCache.size >= 16) {
+    const firstKey = trainedModelCache.keys().next().value;
+    if (firstKey) trainedModelCache.delete(firstKey);
+  }
+  trainedModelCache.set(dayFitKey, { dayMsk: barDayMsk, trainedAt, fTrain, fitted: lightFitted, snap });
 
   const inf = buildInferenceFoldAt(ds, idx, fTrain, lightFitted, liveSnap);
   return {
@@ -357,7 +392,9 @@ function buildPredictionRows(ds, p, idx, f, u, fitted, chosen, H, effMinEdge, au
   const idx30m = Math.max(0, idx - 3);
   const idx1d = Math.max(0, idx - bpd);
   const idx3d = Math.max(0, idx - 3 * bpd);
-  const mPrevBar = idx > 0 ? (ds.mclose?.[idx - 1] || 0) : 0;
+  const baseIdx = liveBaseIndexOf(ds, idx, liveSnap);
+  const liveScale = liveSnap?.prices?.size > 0 ? (1 / Math.sqrt(liveElapsedBarsOf(ds, idx, liveSnap))) : 1;
+  const mPrevBar = idx > 0 ? (ds.mclose?.[baseIdx] || 0) : 0;
   const mLiveRet = computeLiveMarketReturn(ds, idx, liveSnap);
   const mNow = liveSnap?.prices?.size > 0 && mPrevBar > 0
     ? mPrevBar * Math.exp(mLiveRet)
@@ -368,11 +405,11 @@ function buildPredictionRows(ds, p, idx, f, u, fitted, chosen, H, effMinEdge, au
   const rows = ds.tokens.map((tk, i) => {
     let exp = preds[chosen][i] * f.sigma[i] * Math.sqrt(H);
     const weight = avgInv > 0 && f.sigma[i] > 0 ? Math.max(0.4, Math.min(1.8, (1 / f.sigma[i]) / avgInv)) : 1;
-    const prevPx = idx > 0 ? (tk.close[idx - 1] || 0) : 0;
+    const prevPx = idx > 0 ? (tk.close[baseIdx] || 0) : 0;
     const livePx = liveSnap?.prices?.get(tk.symbol) || tk.close[idx] || 0;
     const rawBarRet = (livePx > 0 && prevPx > 0) ? Math.log(livePx / prevPx) : (tk.ret?.[idx] || 0);
-    const rawResPct = (rawBarRet - f.beta[i] * mLiveRet) * 100;
-    const rawPriceMovePct = (livePx > 0 && prevPx > 0) ? ((livePx / prevPx - 1) * 100) : (rawBarRet * 100);
+    const rawResPct = (rawBarRet - f.beta[i] * mLiveRet) * liveScale * 100;
+    const rawPriceMovePct = ((livePx > 0 && prevPx > 0) ? ((livePx / prevPx - 1) * 100) : (rawBarRet * 100)) * liveScale;
     const lastMovePct = round(rawResPct, 3);
     // Контроль перегрева (защита от покупки на вершине уже состоявшегося пампа и ложного «отскока на откате»):
     const p30m = tk.close[idx30m] || 0;
@@ -414,15 +451,16 @@ function buildPredictionRows(ds, p, idx, f, u, fitted, chosen, H, effMinEdge, au
     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 || isMorningOpenShortBlocked || (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 liveBuyOk = !isExtremeDip && !buyBlockedByOverheat;
-    const liveShortOk = !isExtremeSpike;
+    const liveShortOk = !isExtremeSpike && !isMorningOpenShortBlocked;
     // сигналы — только по бумагам из текущего состава индекса (исторические бумаги остаются в матрице рынка как контекст)
     const inIdx = !tk.inIndex || tk.inIndex[idx] === 1;
     const shortAllowed = shortableMap && tk.symbol in shortableMap ? Boolean(shortableMap[tk.symbol]) : null;
     const rawShortHit = inIdx && dir !== 'long' && tk.liq[idx] >= LIQ_MIN && exp < -symNeedS && liveShortOk;
     const shortBlockedByBroker = Boolean(exp < 0 && shortAllowed === false);
     const shortBlockedBySqueeze = Boolean(exp < 0 && isExtremeSpike);
+    const shortBlockedByTime = Boolean(exp < 0 && !isExtremeSpike && isMorningOpenShortBlocked);
     const buyBlockedByDip = Boolean(exp > 0 && isExtremeDip);
     const row = {
       i, symbol: tk.symbol, name: tk.name,
@@ -449,6 +487,7 @@ function buildPredictionRows(ds, p, idx, f, u, fitted, chosen, H, effMinEdge, au
       row.shortSignal = rawShortHit && !shortBlockedByBroker;
       if (shortBlockedByBroker) row.shortBlockedByBroker = true;
       if (shortBlockedBySqueeze) row.shortBlockedBySqueeze = true;
+      if (shortBlockedByTime) row.shortBlockedByTime = true;
     }
     // контекст торгового дня (экстремумы, движение к закрытию прошлого дня) — для фильтра входа против события, стопа и журнала решений
     const dc = dayContext(ds, i, idx, f.sigma[i] * 100, livePx);
@@ -499,6 +538,11 @@ function withNews(result, p) {
     } else {
       delete r.shortBlockedBySqueeze;
     }
+    if (r.expectedPct < 0 && r.shortBlockedByTime) {
+      r.shortSignal = false;
+    } else if (r.expectedPct >= 0) {
+      delete r.shortBlockedByTime;
+    }
     if (r.expectedPct > 0 && (r.buyBlockedByDip || r.regimeCrash || (r.lastMovePct ?? 0) < -4.5)) {
       r.buyBlockedByDip = true;
       r.signal = false;
@@ -616,6 +660,7 @@ async function updateNearSignalsJournal(ds, p, last, key) {
       if (side === 'short') {
         if (p.modelDirection === 'long') reasons.push('режим «только в рост»');
         if (row.shortBlockedBySqueeze || row.regimeSqueeze || (row.lastMovePct ?? 0) > 4.5) reasons.push('защита от сквиза');
+        if (row.shortBlockedByTime) reasons.push('вне окна шорта по времени сессии');
         if (row.shortBlockedByBroker || row.shortAllowed === false) reasons.push('запрет шорта у брокера');
         if (dg?.blockShort) reasons.push(`отсечка дивидендов ${dg.exDate}`);
         if (bNews?.good) reasons.push(`фильтр новостей (${bNews.good.gist})`);
@@ -742,11 +787,12 @@ const fmtLiveBarLabel = (barTs, liveSnapTs) => {
 // Мгновенный пересчёт последнего среза прогноза по живым секундным котировкам (без обращения к истории свечей)
 async function tickLiveForecastState(p, now = Date.now()) {
   const liveSnap = await fetchLiveMoexSnapshot();
-  if (liveSnap) applyLivePricesToFold(baseState.ds, baseState.f, baseState.u, baseState.fitted, liveSnap);
+  const uActive = liveSnap ? applyLivePricesToFold(baseState.ds, baseState.f, baseState.last, baseState.fitted, liveSnap) : baseState.u;
+  baseState.u = uActive;
   const effHorizon = p.modelAutoAdapt !== false ? 2.5 : p.modelHorizon;
   const effMinEdge = p.modelAutoAdapt !== false ? 2.5 : p.modelMinEdge;
   const H = barsFromHours(effHorizon);
-  const r = buildPredictionRows(baseState.ds, p, baseState.last, baseState.f, baseState.u, baseState.fitted, baseState.chosen, H, effMinEdge, p.modelAutoAdapt !== false, true, liveSnap);
+  const r = buildPredictionRows(baseState.ds, p, baseState.last, baseState.f, uActive, baseState.fitted, baseState.chosen, H, effMinEdge, p.modelAutoAdapt !== false, true, liveSnap);
   const sortedRows = r.rows.map(({ i, expected, ...x }) => ({ ...x, cluster: baseState.snap.clusters[i] })).sort((a, b) => b.expectedPct - a.expectedPct);
   attachDeltas(sortedRows, baseState);
   const liveTs = liveSnap?.ts || now;

package/server/model/policy.js

@@ -89,10 +89,10 @@ export function protectiveStopPct(side, { sigmaBarPct = 0, realizedBarPct = 0, h
   if (st.mode === 'vol' && sigmaBarPct > 0) {
     const vol = Math.max(sigmaBarPct, st.useRealized ? realizedBarPct : 0);
     const raw = st.k * vol * Math.sqrt(horizonBars);
-    const maxPct = side === 'long' ? (st.maxLongPct ?? 5.0) : (st.maxShortPct ?? 4.5);
+    const maxPct = side === 'long' ? (st.maxLongPct ?? 7.0) : (st.maxShortPct ?? 7.0);
     return Math.max(st.minPct ?? 1.0, Math.min(maxPct, raw));
   }
-  return side === 'long' ? (st.longPct ?? 5.0) : (st.shortPct ?? 4.5);
+  return side === 'long' ? (st.longPct ?? 7.0) : (st.shortPct ?? 7.0);
 }
 
 // ---------- плечо и множители размера по эшелонам ----------

package/server/model/simulator.js

@@ -17,7 +17,7 @@ import {
   isStockQuarantined, canEnterIntraday, shouldExitBeforeNight, isMarketDown,
 } from './edge.js';
 import { nextDividendAt, dividendRules } from './dividends.js';
-import { STRATEGY_POLICY, sessionEdgeWarning, profitLockLevels, protectiveStopPct, targetPositionRub, counterTrendBlocked, thesisStopPx, dayContext } from './policy.js';
+import { STRATEGY_POLICY, MAX_LEVERAGE, sessionEdgeWarning, profitLockLevels, protectiveStopPct, targetPositionRub, counterTrendBlocked, thesisStopPx, dayContext } from './policy.js';
 
 // Выравнивание внешнего ряда (свечи IMOEXF, дневные цены LQDT) по шкале датасета с переносом последней цены
 export function alignSeries(timeline, rows) {
@@ -52,7 +52,7 @@ export function simulateStrategy({ ds, wf, p, policy = STRATEGY_POLICY, capital
   const slotW = policy.slotPct ?? (plan === 'owner' ? 0.45 : plan === 'vip' ? 0.40 : plan === 'pro' ? Math.min(0.28, 1.15 / 8) : Math.min(0.24, 1.05 / 5));
   const convMax = plan === 'owner' ? 1.65 : plan === 'vip' ? 1.30 : 1;
   const convK = plan === 'owner' ? 0.30 : 0.25;
-  const lev = Math.max(1, Number(leverage) || 1);
+  const lev = Math.max(1, Math.min(MAX_LEVERAGE, Number(leverage) || 1));
   const maxGross = policy.maxGross ?? 0.99 * lev;
   const capScale = policy.capScale ?? 1;
   const tierScale = (i) => (isT1(i) ? (policy.edgeScaleT1 ?? 1) : (policy.edgeScaleT2 ?? 1));
@@ -106,7 +106,7 @@ export function simulateStrategy({ ds, wf, p, policy = STRATEGY_POLICY, capital
     }
     held.delete(i);
     cooldownUntil[i] = exitT + (kind === 'stop' || kind === 'thesis' ? stopCooldownBars : cooldownBars);
-    stockPnl[i] = stockPnl[i] * 0.90 + (g - 2 * realCost);
+    stockPnl[i] = stockPnl[i] * 0.90 + (g - 2 * c);
     stockCnt[i] += 1;
   };
   const mtmUnreal = (t) => {
@@ -124,13 +124,26 @@ export function simulateStrategy({ ds, wf, p, policy = STRATEGY_POLICY, capital
   if (firstK < 0) firstK = wf.testTs.length;
   let lastT = -1;
   let prevT = -1;
+  const maxDailyDdPct = policy.maxDailyDrawdownPct ?? 3.0;
+  let curDayMsk = -1;
+  let dayStartTotalRub = capital;
+  let dayDdBreachCount = 0;
+  let dayHalted = false;
   for (let k = firstK; k < wf.testTs.length; k++) {
     const t = wf.testTs[k];
     if (timeline[t] > tillTs || t + 1 >= T) break;
     lastT = t;
     const fo = wf.foldOf[k];
     const pr = wf.pred[k], sg = wf.foldSigma[fo], mult = wf.foldMult[fo], beta = wf.foldBeta[fo];
+    if (!pr || !sg || !mult || !beta) continue;
     const decTs = timeline[t] + BAR_MS;
+    const barDayMsk = Math.floor((timeline[t] + 3 * 3600000) / 86400000);
+    if (barDayMsk !== curDayMsk) {
+      curDayMsk = barDayMsk;
+      dayStartTotalRub = Math.max(1, equity + mtmUnreal(t));
+      dayDdBreachCount = 0;
+      dayHalted = false;
+    }
     const isStep = (k - firstK) % stepBars === 0;
     if (isStep) {
       for (let i = 0; i < N; i++) { stockPnl[i] *= QUARANTINE_DECAY; stockCnt[i] *= QUARANTINE_DECAY; }
@@ -149,7 +162,7 @@ export function simulateStrategy({ ds, wf, p, policy = STRATEGY_POLICY, capital
     }
     prevT = t;
 
-    // 1) внутри свечи t: фиксация прибыли, стоп отмены идеи и защитный стоп
+    // 1) внутри свечи t: сначала проверяем защитный стоп и стоп отмены идеи (консервативный приоритет неблагоприятного движения), затем фиксацию прибыли
     for (const [i, pos] of [...held]) {
       if (pos.entryT > t) continue;
       const tk = tokens[i];
@@ -159,19 +172,11 @@ export function simulateStrategy({ ds, wf, p, policy = STRATEGY_POLICY, capital
       const favorable = pos.side === 'long' ? h : l;
       const heldMinStart = (t - pos.entryT) * BAR_INTERVAL;
       let done = false;
-      if (policy.profitLock) {
-        const lv = profitLockLevels(tk.symbol, pos.peakGain * 100, heldMinStart, roundTripFeePct);
-        if (lv) {
-          const gO = gainOf(pos, o) * 100;
-          if (gO <= lv.floorPct && gO >= lv.minExitPct) { closePos(i, pos, t, o, 'Фиксация прибыли', 'lock'); stats.locks++; done = true; }
-          else if (gO > lv.floorPct && gainOf(pos, adverse) * 100 <= lv.floorPct) { closePos(i, pos, t, pxOfGain(pos, lv.floorPct / 100), 'Фиксация прибыли', 'lock'); stats.locks++; done = true; }
-        }
-      }
-      if (done) continue;
       const stopPx = pxOfGain(pos, -pos.stopPct / 100);
       const levels = [[stopPx, 'stop']];
       if (pos.thesisPx > 0) levels.push([pos.thesisPx, 'thesis']);
-      levels.sort((a, b) => (pos.side === 'long' ? b[0] - a[0] : a[0] - b[0]));
+      // При одновременном пробое нескольких стоп-уровней внутри свечи исполняем по более невыгодному (консервативно)
+      levels.sort((a, b) => (pos.side === 'long' ? a[0] - b[0] : b[0] - a[0]));
       for (const [lvPx, kind] of levels) {
         const hit = pos.side === 'long' ? adverse <= lvPx : adverse >= lvPx;
         if (!hit) continue;
@@ -182,6 +187,15 @@ export function simulateStrategy({ ds, wf, p, policy = STRATEGY_POLICY, capital
         break;
       }
       if (done) continue;
+      if (policy.profitLock) {
+        const lv = profitLockLevels(tk.symbol, pos.peakGain * 100, heldMinStart, roundTripFeePct);
+        if (lv) {
+          const gO = gainOf(pos, o) * 100;
+          if (gO <= lv.floorPct && gO >= lv.minExitPct) { closePos(i, pos, t, o, 'Фиксация прибыли', 'lock'); stats.locks++; done = true; }
+          else if (gO > lv.floorPct && gainOf(pos, adverse) * 100 <= lv.floorPct) { closePos(i, pos, t, pxOfGain(pos, lv.floorPct / 100), 'Фиксация прибыли', 'lock'); stats.locks++; done = true; }
+        }
+      }
+      if (done) continue;
       pos.peakGain = Math.max(pos.peakGain, gainOf(pos, favorable));
       if (policy.profitLock) {
         const lv = profitLockLevels(tk.symbol, pos.peakGain * 100, heldMinStart + BAR_INTERVAL, roundTripFeePct);
@@ -248,8 +262,18 @@ export function simulateStrategy({ ds, wf, p, policy = STRATEGY_POLICY, capital
       if (kind === 'night') stats.night++; else if (kind === 'signal') stats.signalExits++; else if (kind === 'time') stats.timeExits++; else if (kind === 'regime') stats.regime++; else stats.div++;
     }
 
-    // 3) входы
-    const timeOk = canEnterIntraday(decTs, H, BAR_INTERVAL) && !sessionEdgeWarning(decTs) && !nightNow && (policy.entryEveryBar !== false || isStep);
+    // 3) входы (блокируются до конца дня при срабатывании дневного стопа просадки, как в живом контуре)
+    if (maxDailyDdPct > 0 && !dayHalted && isStep) {
+      const curTotalRub = equity + mtmUnreal(t);
+      const dayDdPct = ((dayStartTotalRub - curTotalRub) / dayStartTotalRub) * 100;
+      if (dayDdPct >= maxDailyDdPct) {
+        dayDdBreachCount += 1;
+        if (dayDdBreachCount >= 2) dayHalted = true;
+      } else {
+        dayDdBreachCount = 0;
+      }
+    }
+    const timeOk = !dayHalted && canEnterIntraday(decTs, H, BAR_INTERVAL) && !sessionEdgeWarning(decTs) && !nightNow && (policy.entryEveryBar !== false || isStep);
     if (timeOk) {
       const baseOk = (i) => !held.has(i) && cooldownUntil[i] <= t && liquid(i) && (!tokens[i].inIndex || tokens[i].inIndex[t] === 1) && !isStockQuarantined(stockCnt[i], stockPnl[i]) && (policy.tier2 !== false || isT1(i));
       const candL = [];

package/server/model/walkforward.js

@@ -5,6 +5,7 @@
 import { buildFold, MODELS, FEATURE_WARMUP } from './models.js';
 import { computeTokenEdgeMults } from './edge.js';
 import { barsFromHours } from './dataset.js';
+import { loadProfiles } from './profiles.js';
 
 const DAY = 86400000;
 const MSK = 3 * 3600000;
@@ -33,6 +34,7 @@ export async function computeWalkForward(ds, p, { model = 'attention', tillTs =
   const foldSigma = [];
   const foldBeta = [];
   const foldMult = [];
+  const profiles = p.modelTextWeight > 0 ? loadProfiles() : null;
   let fi = 0;
   while (testStart < T - maxH - 2) {
     if (signal?.aborted) throw new Error('Отменено');
@@ -40,7 +42,7 @@ export async function computeWalkForward(ds, p, { model = 'attention', tillTs =
     const trainStart = Math.max(FEATURE_WARMUP + maxH + 2, testStart - trainLen);
     onProgress({ fold: fi + 1, folds, from: timeline[testStart], till: timeline[testEnd - 1] });
     await tick();
-    const f = buildFold(ds, { trainStart, testStart, testEnd, H, embedDim: p.modelEmbedDim, textWeight: 0, profiles: null, multiHorizon: autoAdapt });
+    const f = buildFold(ds, { trainStart, testStart, testEnd, H, embedDim: p.modelEmbedDim, textWeight: p.modelTextWeight || 0, profiles, multiHorizon: autoAdapt });
     foldSigma.push(Float64Array.from(f.sigma));
     foldBeta.push(Float64Array.from(f.beta));
     foldMult.push(computeTokenEdgeMults(tokens, f.sigma, trainStart, testStart));