neuroalpha 0.5.24 → 0.5.28

package/package.json

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

package/public/app.js

@@ -1079,20 +1079,36 @@ async function loadForecast(force, silent = false) {
       }
       return reasons.length ? { blocked: true, label, title: reasons.join(' · ') } : { blocked: false, label: '', title: '' };
     };
-    const sigBadge = (r, blk) => {
+    const sigBadge = (r, blk, crossed, pctOfThr, thrText, thrVal) => {
       if (r.signal) return '<span class="tag ok">купить</span>';
       if (r.shortSignal) return '<span class="tag no">шорт</span>';
-      if (blk?.blocked) return `<span class="tag blocked" title="${esc(blk.title)}">${esc(blk.label)}</span>`;
-      return '<span class="muted small">—</span>';
+      if (blk?.blocked && crossed) {
+        return `<span class="tag blocked" title="${esc(`Порог ${thrText} пройден (ожидание ${fmtPct(r.expectedPct, 2)}, ${pctOfThr}% порога), но вход заблокирован: ${blk.title}`)}">${esc(blk.label)}</span>`;
+      }
+      if (blk?.blocked && !crossed) {
+        const shortTag = blk.label.replace(/^⛔\s*/, '');
+        return `<span class="muted small" title="${esc(`Ожидание ${fmtPct(r.expectedPct, 2)} ниже порога ${thrText} (${pctOfThr}% от порога) — сигнала нет. Дополнительно по бумаге активен фильтр: ${blk.title}`)}">ниже порога · ${esc(shortTag)}</span>`;
+      }
+      if (pctOfThr >= 75) {
+        const gap = Math.max(0, (Number(thrVal) || 0) - Math.abs(Number(r.expectedPct) || 0));
+        return `<span class="tag mid" title="${esc(`Почти сигнал: ожидание ${fmtPct(r.expectedPct, 2)} достигло ${pctOfThr}% от порога ${thrText} (не хватает ${fmtNum(gap, 2)}%)`)}">почти (${pctOfThr}%)</span>`;
+      }
+      return `<span class="muted small" title="${esc(`Ожидание ${fmtPct(r.expectedPct, 2)} ниже порога ${thrText} (${pctOfThr}% от порога)`)}">—</span>`;
     };
     const row = (r, side) => {
       const blk = !r.signal && !r.shortSignal ? blockInfoOf(r, side) : { blocked: false };
-      const trCls = (r.signal || r.shortSignal) ? ' class="best"' : blk.blocked ? ` class="fc-blocked" title="${esc(blk.title)}"` : '';
       const isShort = side === 'short' || (side !== 'long' && r.expectedPct < 0);
       const isT1 = r.tier ? r.tier === 1 : TIER1_SET.has(r.symbol);
       const thrVal = isShort
         ? (r.shortThresholdPct ?? (isT1 ? shortThr : shortThrT2))
         : (r.buyThresholdPct ?? (isT1 ? buyThr : buyThrT2));
+      const pctOfThr = thrVal > 0 ? Math.round((Math.abs(Number(r.expectedPct) || 0) / thrVal) * 100) : 0;
+      const crossed = thrVal > 0 && Math.abs(Number(r.expectedPct) || 0) >= thrVal;
+      const trCls = (r.signal || r.shortSignal)
+        ? ' class="best"'
+        : (blk.blocked && crossed)
+          ? ` class="fc-blocked" title="${esc(`Порог пройден, но вход заблокирован: ${blk.title}`)}"`
+          : '';
       const thrFmt = Number(thrVal || 0).toLocaleString('ru-RU', { minimumFractionDigits: 2, maximumFractionDigits: 2 });
       const thrText = isShort ? `−${thrFmt}%` : `+${thrFmt}%`;
       const multStr = r.edgeMult ? `×${fmtNum(r.edgeMult, 2)}` : (isT1 ? '×1,00' : '×1,20');
@@ -1106,7 +1122,7 @@ async function loadForecast(force, silent = false) {
       <td class="num" style="white-space:nowrap">${r.price ? `${fmtNum(r.price, r.price < 1 ? 5 : r.price < 10 ? 3 : 2)} ₽` : '—'}</td>
       <td class="num ${cls(r.expectedPct)}" style="white-space:nowrap"><b>${fmtPct(r.expectedPct, 2)}</b></td>
       <td class="num" style="white-space:nowrap">${arrowOf(r)}</td>
-      <td style="text-align:center;white-space:nowrap">${sigBadge(r, blk)}</td>
+      <td style="text-align:center;white-space:nowrap">${sigBadge(r, blk, crossed, pctOfThr, thrText, thrVal)}</td>
       <td class="muted small" style="white-space:nowrap">${(r.influences || []).slice(0, 3).map((x) => `<span class="sym-link" data-sym="${esc(x.symbol)}" title="Сосед по карте рынка: вклад ${x.contribPct > 0 ? '+' : ''}${x.contribPct}%, близость ${x.closeness}">${esc(x.symbol)}</span>`).join(', ')}</td>
       <td class="num muted small" style="white-space:nowrap" title="${esc(thrTitle)}">${thrText}</td>
     </tr>`;
@@ -1119,9 +1135,41 @@ async function loadForecast(force, silent = false) {
     ].slice(0, 4);
     // общая сетка колонок для обеих таблиц: столбцы выровнены по всей высоте блока
     const fcTable = (title, rows, extraStyle = '', side = 'long') => `<table class="fc-table" style="table-layout:fixed;width:100%${extraStyle}">${colgroup}<thead><tr><th>${title}</th><th class="num">Цена</th><th class="num">Ожидание</th><th class="num">Динамика</th><th style="text-align:center">Сигнал</th><th>Под влиянием</th><th class="num" title="Индивидуальный порог входа с учётом ликвидности бумаги (1-й или 2–3-й эшелон) и тренда индекса">Порог</th></tr></thead><tbody>${rows.map((r) => row(r, side)).join('')}</tbody></table>`;
+    const nearList = Array.isArray(f.nearSignals) ? f.nearSignals : [];
+    const prevNearEl = $('#fc-near-box');
+    const nearOpenAttr = (!prevNearEl || prevNearEl.open) ? ' open' : '';
+    const nearHtml = nearList.length ? `<details id="fc-near-box"${nearOpenAttr} style="margin-top:12px;border-top:1px solid var(--line);padding-top:10px">
+      <summary style="font-weight:500">Журнал сигналов и почти-сигналов за неделю (≥75% порога) · ${nearList.filter((x) => x.status === 'signal').length} сигн., ${nearList.filter((x) => x.status === 'blocked').length} блок., ${nearList.filter((x) => x.status === 'near').length} почти</summary>
+      <div style="overflow-x:auto;margin-top:8px">
+        <table class="fc-table" style="width:100%">
+          <thead><tr><th>Дата · время МСК</th><th>Бумага</th><th>Направление</th><th class="num">Пик ожидания</th><th class="num">Порог</th><th class="num">К порогу</th><th>Статус и причина</th></tr></thead>
+          <tbody>${nearList.slice(0, 18).map((ep) => {
+            const dStr = ep.day ? `${ep.day.slice(8, 10)}.${ep.day.slice(5, 7)}` : '';
+            const tRange = ep.firstBar && ep.lastBar && ep.firstBar !== ep.lastBar ? `${ep.firstBar}–${ep.lastBar} (${ep.barsCount} св.)` : `${ep.peakBar || ep.lastBar || ''}`;
+            const isSh = ep.side === 'short';
+            const thrStr = `${isSh ? '−' : '+'}${fmtNum(ep.thresholdPct, 2)}%`;
+            const stBadge = ep.status === 'signal'
+              ? `<span class="tag ok">${isSh ? '✓ сигнал шорт' : '✓ сигнал купить'}</span>`
+              : ep.status === 'blocked'
+                ? '<span class="tag blocked">⛔ блок входа</span>'
+                : `<span class="tag mid">почти (${ep.peakRatioPct}%)</span>`;
+            const rowCls = ep.status === 'signal' ? ' class="best"' : ep.status === 'blocked' ? ' class="fc-blocked"' : '';
+            return `<tr${rowCls}>
+              <td class="muted small" style="white-space:nowrap">${esc(dStr)} ${esc(tRange)}</td>
+              <td style="white-space:nowrap"><span class="sym-link" data-sym="${esc(ep.symbol)}" title="Открыть досье акции ${esc(ep.symbol)}"><b>${esc(ep.symbol)}</b> <span class="muted small">${esc(ep.name || '')}</span></span></td>
+              <td class="${isSh ? 'neg' : 'pos'} small" style="white-space:nowrap">${isSh ? 'В шорт' : 'В покупку'}</td>
+              <td class="num ${cls(ep.peakExpectedPct)}" style="white-space:nowrap"><b>${fmtPct(ep.peakExpectedPct, 2)}</b></td>
+              <td class="num muted small" style="white-space:nowrap">${thrStr}</td>
+              <td class="num small" style="white-space:nowrap"><b>${ep.peakRatioPct}%</b></td>
+              <td class="small" style="white-space:normal">${stBadge} <span class="muted">${esc(ep.reasonText || '')}</span></td>
+            </tr>`;
+          }).join('')}</tbody>
+        </table>
+      </div>
+    </details>` : '';
     box.innerHTML = `<div style="overflow-x:auto">${fcTable('Сильнее рынка', shownRows.slice(0, 6), '', 'long')}
       ${fcTable('Слабее рынка', shortRows, ';margin-top:14px', 'short')}</div>
-      <p class="muted small">Ожидание — движение относительно рынка в целом (авто-пересчёт каждые 15 сек по живым ценам Мосбиржи). Точный индивидуальный порог каждой акции рассчитывается в колонке <b>«Порог»</b> с учётом её ликвидности (оборота торгов), волатильности свечи и тренда индекса. <span style="color:var(--blocked-fg)">Розовым</span> отмечены строки, по которым вход запрещён (запрет шорта у брокера, отсечка дивидендов, фильтр новостей или экстремальная свеча ±4,5%).</p>`;
+      <p class="muted small">Ожидание — движение относительно рынка в целом (авто-пересчёт каждые 15 сек по живым ценам Мосбиржи). Точный индивидуальный порог каждой акции рассчитывается в колонке <b>«Порог»</b> с учётом её ликвидности (оборота торгов), волатильности свечи и тренда индекса. <span style="color:var(--blocked-fg)">Розовым</span> выделяются только те бумаги, где ожидание <b>уже пробило порог</b>, но сделка остановлена защитным фильтром (если ожидание ещё ниже порога, фильтр указывается справочно рядом с «ниже порога»).</p>${nearHtml}`;
     if (state.brokers?.accounts?.length) renderBrokers();
   } catch (e) {
     if (!silent) box.innerHTML = `<span class="neg">Не получилось: ${esc(e.message)}</span>`;
@@ -2527,8 +2575,10 @@ function renderBrokers() {
     const baseMap = a.baselineQty || {};
     const curSubTab = brokerTabById.get(a.id) || 'assets';
 
+    const isSweepLqdt = (p) => Boolean(a.cashSweep && a.broker === 'tbank' && p.symbol === 'LQDT');
+
     const algoQtyOf = (p) => {
-      if ((p.instrumentType && p.instrumentType !== 'share') || (fcRowMap && !fcRowMap.has(p.symbol))) return 0;
+      if (!isSweepLqdt(p) && ((p.instrumentType && p.instrumentType !== 'share') || (fcRowMap && !fcRowMap.has(p.symbol)))) return 0;
       if (lMode === 'takeover') return p.qty;
       const bq = Number(baseMap[p.symbol] || 0);
       if (p.qty > 0 && bq > 0) return Math.max(0, p.qty - bq);
@@ -2542,6 +2592,16 @@ function renderBrokers() {
       if (isNonTradablePos(p)) {
         return '<span class="tag" title="Бумага снята с торгов, проходит редомициляцию или заблокирована (рыночная оценка 0 ₽). Стратегия её не затрагивает">не торгуется (0 ₽)</span>';
       }
+      if (isSweepLqdt(p)) {
+        const aq = algoQtyOf(p);
+        const bq = Number(baseMap[p.symbol] || 0);
+        if (aq > 0 && bq > 0 && lMode !== 'takeover') {
+          return `<span class="tag ok" title="Рублёвый резерв стратегии в фонде ликвидности LQDT: автоматически продаётся под новые сигналы">старый: ${fmtNum(bq, 0)} шт. · резерв стратегии: ${fmtNum(aq, 0)} шт.</span>`;
+        }
+        if (aq > 0) {
+          return '<span class="tag ok" title="Рублёвый резерв стратегии в фонде ликвидности LQDT: автоматически высвобождается под новые сигналы покупки и шорта">резерв стратегии (кэш в LQDT)</span>';
+        }
+      }
       if (p.instrumentType && p.instrumentType !== 'share') {
         const [kl] = INST_KIND_LABEL[p.instrumentType] || ['Актив', ''];
         return `<span class="tag" title="Драгметаллы, валюта, облигации и БПИФы не затрагиваются стратегией акций">${esc(kl.toLowerCase())} (защищён)</span>`;

package/server/api/routes.js

@@ -783,8 +783,8 @@ export function createRouter() {
       tierLabel: isTier1 ? '1-й эшелон (высокая ликвидность)' : '2-й эшелон',
       edgeMult: fcRow?.edgeMult ?? round(tierMult, 3),
       sigmaPct: fcRow?.sigmaPct ?? null,
-      buyThresholdPct: fcRow?.buyThresholdPct ?? round(Math.max((fc?.buyThresholdPct || 0.413) * tierMult, 0.30), 3),
-      shortThresholdPct: fcRow?.shortThresholdPct ?? round(Math.max((fc?.shortThresholdPct || 0.516) * tierMult, 0.31), 3),
+      buyThresholdPct: fcRow?.buyThresholdPct ?? round(Math.max((fc?.buyThresholdPct || 0.40) * tierMult, 0.30), 3),
+      shortThresholdPct: fcRow?.shortThresholdPct ?? round(Math.max((fc?.shortThresholdPct || 0.50) * tierMult, 0.31), 3),
       shortAllowedByBroker: shortableMap[sym] !== undefined ? Boolean(shortableMap[sym]) : null,
       specs: {
         lotSize: sp.lotSize,

package/server/brokers/index.js

@@ -79,13 +79,29 @@ export const BROKER_META = [
 
 // ---------- справочник лотов и шага цены Мосбиржи (TQBR) ----------
 const SPECS_URL = 'https://iss.moex.com/iss/engines/stock/markets/shares/boards/TQBR/securities.json?iss.meta=off&iss.only=securities,marketdata';
+
+function withWallTimeout(promise, ms, label = 'Превышено время ожидания') {
+  let timer = null;
+  return Promise.race([
+    promise,
+    new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new Error(label)), ms);
+      timer.unref?.();
+    }),
+  ]).finally(() => {
+    if (timer) clearTimeout(timer);
+  });
+}
+
 export async function ensureBoardSpecs() {
   const cached = kvGet('moexSpecs');
   if (cached?.specs && cached?.v === 2 && Date.now() - cached.at < DAY) return cached.specs;
   try {
-    const r = await fetch(SPECS_URL, { signal: AbortSignal.timeout(25000) });
-    if (!r.ok) throw new Error(`HTTP ${r.status}`);
-    const j = await r.json();
+    const j = await withWallTimeout((async () => {
+      const r = await fetch(SPECS_URL, { signal: AbortSignal.timeout(25000) });
+      if (!r.ok) throw new Error(`HTTP ${r.status}`);
+      return r.json();
+    })(), 26000, 'Таймаут загрузки справочника TQBR');
     const sc = j.securities.columns, mc = j.marketdata.columns;
     const is = (k) => sc.indexOf(k), im = (k) => mc.indexOf(k);
     const prices = new Map();
@@ -581,14 +597,16 @@ export function deleteBrokerAccount(id) {
 
 // ---------- адаптеры REST API брокеров (Т-Банк, Финам, Алор, БКС) ----------
 // HTTPS-клиент с поддержкой российских сертификатов НУЦ Минцифры РФ (invest-public-api.tinkoff.ru и др.) и пулом постоянных соединений Keep-Alive
-const BROKER_HTTPS_AGENT = new https.Agent({ keepAlive: true, maxSockets: 6, ca: TRUSTED_CA });
+const BROKER_HTTPS_AGENT = new https.Agent({ keepAlive: true, keepAliveInitialDelay: 10000, maxSockets: 6, timeout: 20000, ca: TRUSTED_CA });
 
 function brokerFetch(url, { method = 'GET', headers = {}, body = null, timeoutMs = 15000 } = {}) {
   return new Promise((resolve, reject) => {
     let settled = false;
+    let wallTimer = null;
     const done = (fn, val) => {
       if (settled) return;
       settled = true;
+      if (wallTimer) clearTimeout(wallTimer);
       fn(val);
     };
     const u = new URL(url);
@@ -623,6 +641,12 @@ function brokerFetch(url, { method = 'GET', headers = {}, body = null, timeoutMs
       res.on('error', (err) => done(reject, err));
       res.on('close', () => done(reject, new Error('Соединение закрыто до завершения ответа')));
     });
+    wallTimer = setTimeout(() => {
+      const err = new Error('Превышено время ожидания ответа от брокера');
+      req.destroy(err);
+      done(reject, err);
+    }, Math.max(1500, timeoutMs));
+    wallTimer.unref?.();
     req.on('timeout', () => { req.destroy(new Error('Превышено время ожидания ответа от брокера')); });
     req.on('error', (err) => done(reject, err));
     req.on('close', () => done(reject, new Error('Запрос закрыт до получения ответа')));
@@ -759,17 +783,18 @@ export async function fetchTbankCandles(symbol, fromTs, tillTs = Date.now(), { i
     // Для CANDLE_INTERVAL_10_MIN максимальный диапазон одного запроса в T-Invest API — 3 суток
     const safeFrom = Math.max(fromTs, tillTs - 3 * 86400000 + 60000);
     if (safeFrom >= tillTs) return null;
-    const r = await brokerFetch(`${base}/tinkoff.public.invest.api.contract.v1.MarketDataService/GetCandles`, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify({
-        instrumentId: uid,
-        from: new Date(safeFrom).toISOString(),
-        to: new Date(tillTs).toISOString(),
-        interval: 'CANDLE_INTERVAL_10_MIN',
-      }),
-      timeoutMs: 5000,
+    const url = `${base}/tinkoff.public.invest.api.contract.v1.MarketDataService/GetCandles`;
+    const body = JSON.stringify({
+      instrumentId: uid,
+      from: new Date(safeFrom).toISOString(),
+      to: new Date(tillTs).toISOString(),
+      interval: 'CANDLE_INTERVAL_10_MIN',
     });
+    let r = await brokerFetch(url, { method: 'POST', headers, body, timeoutMs: 5000 });
+    if (r.status === 429 || r.status >= 500) {
+      await new Promise((res) => setTimeout(res, 350 + Math.floor(Math.random() * 400)));
+      r = await brokerFetch(url, { method: 'POST', headers, body, timeoutMs: 5000 });
+    }
     if (!r.ok) return null;
     const j = await r.json();
     const out = [];
@@ -1565,11 +1590,36 @@ function sessionEdgeWarning(now = Date.now()) {
 }
 
 // ---------- формирование и исполнение пакета лимитных заявок ----------
-const accountBusyLocks = new Set();
+const ACCOUNT_LOCK_TTL_MS = 75000;
+const accountBusyLocks = new Map(); // id -> { since, token }
 
-export async function prepareBrokerOrders(id, { onlyEntries = false } = {}) {
-  if (accountBusyLocks.has(id)) return brokersState();
-  accountBusyLocks.add(id);
+function isAccountBusy(id) {
+  const cur = accountBusyLocks.get(id);
+  if (!cur) return false;
+  if (Date.now() - cur.since >= ACCOUNT_LOCK_TTL_MS) {
+    accountBusyLocks.delete(id);
+    return false;
+  }
+  return true;
+}
+
+function acquireAccountLock(id) {
+  if (isAccountBusy(id)) return null;
+  const token = Symbol(id);
+  accountBusyLocks.set(id, { since: Date.now(), token });
+  return token;
+}
+
+function releaseAccountLock(id, token) {
+  const cur = accountBusyLocks.get(id);
+  if (cur && (!token || cur.token === token)) {
+    accountBusyLocks.delete(id);
+  }
+}
+
+export async function prepareBrokerOrders(id, { onlyEntries = false, scheduledBarTs = 0 } = {}) {
+  const lockToken = acquireAccountLock(id);
+  if (!lockToken) return brokersState();
   try {
   let list = loadRawAccounts();
   let acc = list.find((x) => x.id === id);
@@ -1593,11 +1643,11 @@ export async function prepareBrokerOrders(id, { onlyEntries = false } = {}) {
     acc = list.find((x) => x.id === id) || acc;
   }
   const params = normalizeParams(getSettings());
-  const [fc, rawSpecs, shortableMap] = await Promise.all([
+  const [fc, rawSpecs, shortableMap] = await withWallTimeout(Promise.all([
     forecastNow(params),
     ensureBoardSpecs(),
     ensureTbankShortableMap(acc),
-  ]);
+  ]), 55000, 'Превышено время ожидания расчёта прогноза');
   const specs = { ...rawSpecs };
   if (acc.broker === 'tbank') {
     const tbSpecs = kvGet('tbankShortableMap')?.specMap || {};
@@ -1774,7 +1824,7 @@ export async function prepareBrokerOrders(id, { onlyEntries = false } = {}) {
     if (aQty > 0) {
       const lots = Math.floor(aQty / sp.lotSize);
       const curGainPct = avgPx > 0 ? ((curPx - avgPx) / avgPx) * 100 : 0;
-      const hitHardStopLoss = curGainPct <= -5.0 || Boolean(autoAdapt && r.buyBlockedByDip);
+      const hitHardStopLoss = curGainPct <= -5.0 || Boolean(autoAdapt && r.regimeCrash);
       const keepByForecast = onlyEntries ? (r.liquid && r.expectedPct > -needPct) : (r.liquid && r.expectedPct > curExitThr);
       const dg = divGuardOf(sym, curPx);
       const divExit = Boolean(dg?.exitLong);
@@ -1799,7 +1849,7 @@ export async function prepareBrokerOrders(id, { onlyEntries = false } = {}) {
     } else if (aQty < 0) {
       const lots = Math.floor(Math.abs(aQty) / sp.lotSize);
       const curGainPct = avgPx > 0 ? ((avgPx - curPx) / avgPx) * 100 : 0;
-      const hitHardStopLoss = curGainPct <= -4.5 || Boolean(autoAdapt && r.shortBlockedBySqueeze);
+      const hitHardStopLoss = curGainPct <= -4.5 || Boolean(autoAdapt && r.regimeSqueeze);
       const keepByForecast = onlyEntries ? (dir !== 'long' && r.liquid && r.expectedPct < needPct) : (dir !== 'long' && r.liquid && r.expectedPct < -curExitThr);
       const dg = divGuardOf(sym, curPx);
       const divExit = Boolean(dg?.exitShort);
@@ -2121,6 +2171,7 @@ export async function prepareBrokerOrders(id, { onlyEntries = false } = {}) {
   const batchNowTs = Date.now();
   if (!onlyEntries) {
     acc.lastFullStepWallTs = batchNowTs;
+    if (scheduledBarTs > 0) acc.lastScheduledBarTs = scheduledBarTs;
   }
   acc.pendingBatch = {
     id: `batch_${batchNowTs}`,
@@ -2149,7 +2200,7 @@ export async function prepareBrokerOrders(id, { onlyEntries = false } = {}) {
   hub.emit({ type: 'trading:pulse', kind: 'broker_done', ts: Date.now(), accountId: acc.id, name: acc.name, ordersCount: orders.length });
   return st;
   } finally {
-    accountBusyLocks.delete(id);
+    releaseAccountLock(id, lockToken);
   }
 }
 
@@ -2465,12 +2516,13 @@ async function sendOrderToBroker(acc, ord) {
 }
 
 export async function executeBrokerOrders(id, { _lockHeld = false } = {}) {
+  let lockToken = null;
   if (!_lockHeld) {
     // Счёт может быть занят пересчётом заявок (после перезапуска — обучением прогноза): ждём до 15 с, а не молча пропускаем
     const waitUntil = Date.now() + 15000;
-    while (accountBusyLocks.has(id) && Date.now() < waitUntil) await new Promise((r) => setTimeout(r, 300));
-    if (accountBusyLocks.has(id)) throw new Error('Счёт сейчас занят пересчётом заявок — повторите через минуту');
-    accountBusyLocks.add(id);
+    while (isAccountBusy(id) && Date.now() < waitUntil) await new Promise((r) => setTimeout(r, 300));
+    lockToken = acquireAccountLock(id);
+    if (!lockToken) throw new Error('Счёт сейчас занят пересчётом заявок — повторите через минуту');
   }
   try {
     const list = loadRawAccounts();
@@ -2554,7 +2606,7 @@ export async function executeBrokerOrders(id, { _lockHeld = false } = {}) {
     hub.emit({ type: 'brokers:update', state: st });
     return st;
   } finally {
-    if (!_lockHeld) accountBusyLocks.delete(id);
+    if (!_lockHeld && lockToken) releaseAccountLock(id, lockToken);
   }
 }
 
@@ -2749,15 +2801,17 @@ registerBrokerHandlers({ execute: executeBrokerOrders, reject: rejectBrokerOrder
 // ---------- авто-расписание расчёта заявок по закрытию свечи (раз в горизонт прогноза) ----------
 let lastSeenBar = null;
 let schedulerBusy = false;
+let schedulerBusySince = 0;
 
 async function tickBrokerSchedule() {
-  if (schedulerBusy) return;
+  if (schedulerBusy && Date.now() - schedulerBusySince < 90000) return;
   if (!tradingGate().allowNew) 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 + 50 || mins > 23 * 60 + 55) return;
   schedulerBusy = true;
+  schedulerBusySince = Date.now();
   try {
     const latest = await latestBarTs('IMOEX', BAR_INTERVAL).catch(() => null);
     const isNewBar = Boolean(latest && latest !== lastSeenBar);
@@ -2778,24 +2832,27 @@ async function tickBrokerSchedule() {
           // Внутричасовой перехват H/5 (каждые 30 мин) активен в режимах VIP и Хозяин; на тарифах Инвестор и Профи шаг равен полному горизонту H
           const stepBars = ((plan.allowVipBoost || plan.isOwner) && autoAdapt) ? Math.max(3, Math.floor(H / 5)) : H;
           const minStepMs = stepBars * BAR_MS;
-          const lastFullWallTs = acc.lastFullStepWallTs || 0;
-          const lastAnyWallTs = acc.pendingBatch?.executedAt || acc.pendingBatch?.createdAt || 0;
+          const rawLastFullWallTs = acc.lastFullStepWallTs || 0;
+          const batchCreatedTs = acc.pendingBatch?.createdAt || 0;
+          const lastAnyWallTs = acc.pendingBatch?.executedAt || batchCreatedTs || 0;
+          // Если отметка шага была записана без фактического обновления pendingBatch, не считаем такой шаг состоявшимся
+          const lastFullWallTs = batchCreatedTs >= rawLastFullWallTs - 60000 ? rawLastFullWallTs : batchCreatedTs;
+          const lastSchedBarTs = batchCreatedTs >= rawLastFullWallTs - 60000 ? (acc.lastScheduledBarTs || 0) : 0;
           const hasOpenAlgoPos = (acc.lastSync?.positions || []).some((p) => p.qty && p.symbol !== 'LQDT' && p.symbol !== 'TMON@' && p.symbol !== 'TMON' && p.symbol !== 'SBMM' && algoQtyFor(acc, p.symbol, p.qty) !== 0);
           const nowTs = Date.now();
           const nightExitDue = autoAdapt && hasOpenAlgoPos && shouldExitBeforeNight(nowTs, 0, 3, BAR_INTERVAL) && (!lastFullWallTs || !shouldExitBeforeNight(lastFullWallTs, 0, 3, BAR_INTERVAL) || (nowTs - lastFullWallTs >= 15 * 60000));
           const dueFullStep = Boolean(
             nightExitDue || (
               latest &&
-              (latest - (acc.lastScheduledBarTs || 0) >= minStepMs) &&
+              (latest - lastSchedBarTs >= minStepMs) &&
               !(lastFullWallTs > 0 && nowTs - lastFullWallTs < minStepMs - 5 * 60000)
             ),
           );
           if (dueFullStep) {
-            acc.lastScheduledBarTs = latest || acc.lastScheduledBarTs || nowTs;
-            acc.lastFullStepWallTs = nowTs;
-            saveRawAccounts(list);
+            if (isAccountBusy(acc.id)) continue;
+            const stepBarTs = latest || acc.lastScheduledBarTs || nowTs;
             if (acc.token) await syncBrokerAccount(acc.id).catch(() => {});
-            await prepareBrokerOrders(acc.id).catch(() => {});
+            await prepareBrokerOrders(acc.id, { scheduledBarTs: stepBarTs }).catch(() => {});
             continue;
           }
           // Мгновенный перехват новых сигналов «купить» / «шорт» при наличии свободных рублей или резерва в LQDT (каждые 20 секунд, не дожидаясь конца 30-минутного шага!):
@@ -2909,12 +2966,12 @@ async function reconcileBrokerStops(accId) {
     return;
   }
   if (!acc.lastSync?.ok) return;
-  if (accountBusyLocks.has(accId)) return; // идёт исполнение пакета — сверимся в следующий раз
-  accountBusyLocks.add(accId);
+  const lockToken = acquireAccountLock(accId);
+  if (!lockToken) return; // идёт исполнение пакета — сверимся в следующий раз
   try {
-    await reconcileBrokerStopsLocked(list, acc);
+    await withWallTimeout(reconcileBrokerStopsLocked(list, acc), 35000, 'Превышено время сверки стоп-заявок');
   } finally {
-    accountBusyLocks.delete(accId);
+    releaseAccountLock(accId, lockToken);
   }
 }
 
@@ -3121,9 +3178,12 @@ async function checkIntradayProfitLock(accId) {
 
 // Автоматическое периодическое фоновое обновление портфеля и контроль фиксации прибыли (раз в 25 секунд; история операций — раз в 2 минуты)
 let autoRefreshBusy = false;
+let autoRefreshBusySince = 0;
 async function tickBrokerAutoRefresh() {
-  if (autoRefreshBusy || schedulerBusy) return;
+  const now = Date.now();
+  if ((autoRefreshBusy && now - autoRefreshBusySince < 90000) || (schedulerBusy && now - schedulerBusySince < 45000)) return;
   autoRefreshBusy = true;
+  autoRefreshBusySince = now;
   try {
     const curYear = new Date(Date.now() + MSK).getUTCFullYear();
     const users = db.prepare('SELECT * FROM users').all();

package/server/model/dataset.js

@@ -1,5 +1,5 @@
 // Copyright (c) 2026 Roman A. Perepelkin. All rights reserved. Proprietary software.
-import { ensureCandles, ensureDividends, exDate, mskToTs, tsToDate } from '../data/moex.js';
+import { ensureCandles, ensureDividends, exDate, mskToTs, tsToDate, barMs } from '../data/moex.js';
 import { ensureVocab, ensureIndexHistory } from './vocab.js';
 import { kvGet, kvSet } from '../db.js';
 
@@ -221,13 +221,25 @@ export async function loadAlignedOpen(ds, symbol, { fromTs, tillTs, signal } = {
 // цены с переносом последнего значения, обороты, доходности, рынок (IMOEX).
 // Цены акций скорректированы на дивиденды (полная доходность; useDividends=false — без этого), макро — только при useMacro.
 export async function loadDataset({ interval = BAR_INTERVAL, fromTs, tillTs, useMacro = false, useDividends = true, localOnly = false, onProgress = () => {}, signal }) {
+  const now = Date.now();
+  const mskDate = new Date(now + MSK);
+  const mskDow = mskDate.getUTCDay();
+  const mskMins = mskDate.getUTCHours() * 60 + mskDate.getUTCMinutes();
+  const isTradingNow = !localOnly && mskDow >= 1 && mskDow <= 5 && mskMins >= 7 * 60 && mskMins <= 23 * 60 + 50 && tillTs >= now - 2 * 60000;
+  const bMs = barMs(interval);
+  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;
+  };
   const key = cacheKey(interval, fromTs, tillTs, useMacro, useDividends, localOnly);
   const hit = datasetCache.get(key);
-  if (hit && Date.now() - hit.at < 4 * 60000) return hit.ds;
+  if (hit && now - hit.at < 4 * 60000 && isCacheFreshForSlot(hit)) return hit.ds;
   // Если в памяти уже есть более широкий датасет (не localOnly), который полностью покрывает запрошенный диапазон [fromTs … tillTs], возвращаем его
   const modeKey = JSON.stringify([interval, useMacro ? 1 : 0, useDividends ? (process.env.DIVIDENDS_MODE || 1) : 0]);
   for (const v of datasetCache.values()) {
-    if (v.modeKey === modeKey && (!v.localOnly || localOnly) && Date.now() - v.at < 4 * 60000 && v.fromTs <= fromTs + DAY && Math.abs(v.tillTs - tillTs) < 10 * 60000) {
+    if (v.modeKey === modeKey && (!v.localOnly || localOnly) && now - v.at < 4 * 60000 && Math.abs(v.fromTs - fromTs) < 2 * DAY && Math.abs(v.tillTs - tillTs) < 10 * 60000 && isCacheFreshForSlot(v)) {
       return v.ds;
     }
   }
@@ -255,19 +267,30 @@ export async function loadDataset({ interval = BAR_INTERVAL, fromTs, tillTs, use
     if (signal?.aborted) throw new Error('Отменено');
     const symCtrl = new AbortController();
     const effSignal = signal ? AbortSignal.any([signal, symCtrl.signal]) : symCtrl.signal;
-    const killer = setTimeout(() => symCtrl.abort(), WITHIN);
+    let killer = null;
     try {
-      // акциям подгружаем дивиденды и сразу корректируем цены на полную доходность
-      const divs = useDividends && symbols.includes(s) ? await ensureDividends(s, { signal: effSignal, localOnly }) : null;
-      const rows = await ensureCandles(s, interval, fromTs, tillTs, { signal: effSignal, localOnly });
-      // объекты свечей отпускаются сразу, а не копятся до конца загрузки всех акций
-      raw[s] = compact(rows);
-      if (divs?.length) {
-        // DIVIDENDS_MODE=raw — прежняя корректировка без сверки с ценой (только для сравнения результатов)
-        const st = adjustDividends(raw[s], divs, { verify: process.env.DIVIDENDS_MODE !== 'raw' });
-        divStat.applied += st.applied;
-        divStat.skipped += st.skipped;
-      }
+      await Promise.race([
+        (async () => {
+          // акциям подгружаем дивиденды и сразу корректируем цены на полную доходность
+          const divs = useDividends && symbols.includes(s) ? await ensureDividends(s, { signal: effSignal, localOnly }) : null;
+          const rows = await ensureCandles(s, interval, fromTs, tillTs, { signal: effSignal, localOnly });
+          // объекты свечей отпускаются сразу, а не копятся до конца загрузки всех акций
+          raw[s] = compact(rows);
+          if (divs?.length) {
+            // DIVIDENDS_MODE=raw — прежняя корректировка без сверки с ценой (только для сравнения результатов)
+            const st = adjustDividends(raw[s], divs, { verify: process.env.DIVIDENDS_MODE !== 'raw' });
+            divStat.applied += st.applied;
+            divStat.skipped += st.skipped;
+          }
+        })(),
+        new Promise((_, rej) => {
+          killer = setTimeout(() => {
+            symCtrl.abort();
+            rej(new Error('Превышено время ожидания загрузки'));
+          }, WITHIN);
+          killer.unref?.();
+        }),
+      ]);
     } catch (e) {
       if (signal?.aborted) throw new Error('Отменено');
       raw[s] = EMPTY();
@@ -419,18 +442,47 @@ export async function loadDataset({ interval = BAR_INTERVAL, fromTs, tillTs, use
   }
   // макро-ряды: лог-доходности с переносом цены (вне торгов — 0)
   const macro = macroRaw.map((m) => ({ id: m.id, label: m.label, ret: lret(m.s.close), has: m.s.has }));
-  const days = new Set(timeline.map(dayKey)).size;
-  // ликвидность: в скольких из последних 20 свечей были сделки
+  const modernTimeline = timeline.filter((t) => t >= 1705104000000);
+  const effTl = modernTimeline.length >= 1000 ? modernTimeline : timeline;
+  const days = new Set(effTl.map(dayKey)).size;
+  // ликвидность: в скольких из последних 20 свечей ОСНОВНОЙ сессии (10:00–18:50 МСК) были сделки.
+  // 1) Утренняя (до 10:00 МСК) и вечерняя (с 19:00 МСК) дополнительные сессии не списывают очки ликвидности за пустые 10-минутки
+  //    (если на доп. сессии сделки есть — засчитываем 1 в окно, если нет — окно основной сессии не сдвигается и не штрафуется).
+  // 2) На самых свежих 4 свечах правого края шкалы (последние 40 минут), где возможен рассинхрон между мгновенными свечами T-Invest API
+  //    и 20–30-минутной задержкой бесплатного MOEX ISS (или локального кэша SQLite), не штрафуем бумаги, у которых свеча ещё не подтянулась с биржи.
+  const isMainSessionBar = new Uint8Array(T);
+  for (let i = 0; i < T; i++) {
+    const h = hourMsk[i];
+    isMainSessionBar[i] = (h >= 10 && h < 19) ? 1 : 0;
+  }
+  const tailGraceStart = Math.max(0, T - 4);
   for (const tk of tokens) {
     tk.liq = new Uint8Array(T);
-    let n = 0;
+    let lastRealIdx = -1;
+    for (let i = T - 1; i >= 0; i--) {
+      if (tk.has[i]) { lastRealIdx = i; break; }
+    }
+    // Если бумага торговалась сегодня/вчера и отстаёт от правого края шкалы не более чем на 12 свечей (2 часа рассинхрона кэша/MOEX ISS),
+    // считаем хвостовые свечи после её последнего полученного бара ожидающими догрузки, а не отсутствием ликвидности:
+    const tailPendingFrom = (lastRealIdx >= 0 && T - 1 - lastRealIdx <= 12) ? Math.max(lastRealIdx + 1, tailGraceStart) : T;
+    const win = new Uint8Array(20);
+    let wLen = 0, wPtr = 0, n = 0;
     for (let i = 0; i < T; i++) {
-      n += tk.has[i];
-      if (i >= 20) n -= tk.has[i - 20];
+      const h = tk.has[i] || (i >= tailPendingFrom ? 1 : 0);
+      if (isMainSessionBar[i] || h) {
+        if (wLen < 20) {
+          win[wLen++] = h;
+          n += h;
+        } else {
+          n += h - win[wPtr];
+          win[wPtr] = h;
+          wPtr = (wPtr + 1) % 20;
+        }
+      }
       tk.liq[i] = n;
     }
   }
-  const ds = { tokens, symbols: tokens.map((t) => t.symbol), timeline, hourMsk, dowMsk, T, index, mret, mclose: mk.close, mopen: mk.open, macro, barsPerDay: days ? Math.round(T / days) : 54 };
+  const ds = { tokens, symbols: tokens.map((t) => t.symbol), timeline, hourMsk, dowMsk, T, index, mret, mclose: mk.close, mopen: mk.open, macro, barsPerDay: days ? Math.round(effTl.length / days) : 54 };
   datasetCache.set(key, { ds, at: Date.now(), modeKey, fromTs, tillTs, localOnly: Boolean(localOnly) });
   if (datasetCache.size > 4) datasetCache.delete(datasetCache.keys().next().value);
   return ds;

package/server/model/forecast.js

@@ -16,6 +16,8 @@ import { hub } from '../hub.js';
 const trainedModelCache = new Map(); // fitKey -> { dayMsk, trainedAt, fTrain, fitted, snap }
 let baseState = null; // { key, trainedAt, ds, last, r, snap, prevExpMap, prevRankMap, lastTickResult, lastTickAt }
 const inflight = new Map();
+const inflightStartedAt = new Map();
+let nearSignalsCache = { key: null, scannedBarTs: 0, episodesMap: new Map(), list: [] };
 
 // Синхронная живая доходность индекса относительно закрытия свечи idx-1:
 // если есть живые котировки акций индекса (из Т-Банка с 0 сек задержки или из MOEX ISS),
@@ -161,42 +163,53 @@ export const isModelTrainedToday = (p, now = Date.now()) => {
 // в первую очередь берёт секундные цены реального времени из T-Invest API (GetLastPrices, 0 секунд задержки!),
 // а недостающие тикеры и индекс IMOEX дополняет из MOEX ISS
 async function fetchLiveMoexSnapshot() {
+  let timer = null;
   try {
-    const [tbPrices, rShares, rIdx] = await Promise.all([
-      fetchTbankRealtimePrices().catch(() => null),
-      fetch('https://iss.moex.com/iss/engines/stock/markets/shares/boards/TQBR/securities.json?iss.meta=off&iss.only=marketdata&marketdata.columns=SECID,LAST,MARKETPRICE,LCURRENTPRICE,VALTODAY', { signal: AbortSignal.timeout(6000) }).catch(() => null),
-      fetch('https://iss.moex.com/iss/engines/stock/markets/index/boards/SNDX/securities/IMOEX.json?iss.meta=off&iss.only=marketdata&marketdata.columns=SECID,CURRENTVALUE,LASTVALUE', { signal: AbortSignal.timeout(6000) }).catch(() => null),
+    return await Promise.race([
+      (async () => {
+        const [tbPrices, rShares, rIdx] = await Promise.all([
+          fetchTbankRealtimePrices().catch(() => null),
+          fetch('https://iss.moex.com/iss/engines/stock/markets/shares/boards/TQBR/securities.json?iss.meta=off&iss.only=marketdata&marketdata.columns=SECID,LAST,MARKETPRICE,LCURRENTPRICE,VALTODAY', { signal: AbortSignal.timeout(6000) }).catch(() => null),
+          fetch('https://iss.moex.com/iss/engines/stock/markets/index/boards/SNDX/securities/IMOEX.json?iss.meta=off&iss.only=marketdata&marketdata.columns=SECID,CURRENTVALUE,LASTVALUE', { signal: AbortSignal.timeout(6000) }).catch(() => null),
+        ]);
+        const prices = new Map();
+        if (rShares?.ok) {
+          const j = await rShares.json().catch(() => null);
+          const cols = j?.marketdata?.columns || [];
+          const iSec = cols.indexOf('SECID');
+          const iLast = cols.indexOf('LAST');
+          const iMkt = cols.indexOf('MARKETPRICE');
+          const iCur = cols.indexOf('LCURRENTPRICE');
+          for (const row of j?.marketdata?.data || []) {
+            const sym = row[iSec];
+            const px = Number(row[iLast] || row[iMkt] || row[iCur] || 0);
+            if (sym && px > 0) prices.set(sym, px);
+          }
+        }
+        if (tbPrices?.size) {
+          for (const [sym, px] of tbPrices) {
+            if (px > 0) prices.set(sym, px);
+          }
+        }
+        if (!prices.size) return null;
+        let imoexPrice = 0;
+        if (rIdx?.ok) {
+          const ji = await rIdx.json().catch(() => null);
+          const ic = ji?.marketdata?.columns || [];
+          const ir = ji?.marketdata?.data?.[0];
+          if (ir) imoexPrice = Number(ir[ic.indexOf('CURRENTVALUE')] || ir[ic.indexOf('LASTVALUE')] || 0);
+        }
+        return { prices, imoexPrice, ts: Date.now(), realtime: Boolean(tbPrices?.size) };
+      })(),
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve(null), 7000);
+        timer.unref?.();
+      }),
     ]);
-    const prices = new Map();
-    if (rShares?.ok) {
-      const j = await rShares.json().catch(() => null);
-      const cols = j?.marketdata?.columns || [];
-      const iSec = cols.indexOf('SECID');
-      const iLast = cols.indexOf('LAST');
-      const iMkt = cols.indexOf('MARKETPRICE');
-      const iCur = cols.indexOf('LCURRENTPRICE');
-      for (const row of j?.marketdata?.data || []) {
-        const sym = row[iSec];
-        const px = Number(row[iLast] || row[iMkt] || row[iCur] || 0);
-        if (sym && px > 0) prices.set(sym, px);
-      }
-    }
-    if (tbPrices?.size) {
-      for (const [sym, px] of tbPrices) {
-        if (px > 0) prices.set(sym, px);
-      }
-    }
-    if (!prices.size) return null;
-    let imoexPrice = 0;
-    if (rIdx?.ok) {
-      const ji = await rIdx.json().catch(() => null);
-      const ic = ji?.marketdata?.columns || [];
-      const ir = ji?.marketdata?.data?.[0];
-      if (ir) imoexPrice = Number(ir[ic.indexOf('CURRENTVALUE')] || ir[ic.indexOf('LASTVALUE')] || 0);
-    }
-    return { prices, imoexPrice, ts: Date.now(), realtime: Boolean(tbPrices?.size) };
   } catch {
     return null;
+  } finally {
+    if (timer) clearTimeout(timer);
   }
 }
 
@@ -415,6 +428,8 @@ function buildPredictionRows(ds, p, idx, f, u, fitted, chosen, H, effMinEdge, au
       weight: round(weight, 3),
       signal: inIdx && tk.liq[idx] >= LIQ_MIN && exp > symNeedL && liveBuyOk,
       ...(shortAllowed !== null ? { shortAllowed } : {}),
+      ...(isRegimeCrash ? { regimeCrash: true } : {}),
+      ...(isRegimeSqueeze ? { regimeSqueeze: true } : {}),
       ...(buyBlockedByDip ? { buyBlockedByDip: true } : {}),
       ...(buyBlockedByOverheat ? { buyBlockedByOverheat } : {}),
       ...(inIdx ? {} : { inIndex: false }),
@@ -439,8 +454,8 @@ function withNews(result, p) {
   const nb = p.newsFilter ? blockingNews(6) : null;
   const shortableMap = kvGet('tbankShortableMap')?.map || null;
   const nowTs = Date.now();
-  const baseBuyThr = result.buyThresholdPct ?? result.thresholdPct ?? 0.413;
-  const baseShortThr = result.shortThresholdPct ?? result.thresholdPct ?? 0.516;
+  const baseBuyThr = result.buyThresholdPct ?? result.thresholdPct ?? 0.40;
+  const baseShortThr = result.shortThresholdPct ?? result.thresholdPct ?? 0.50;
   if (result.buyThresholdTier2Pct === undefined) result.buyThresholdTier2Pct = round(Math.max(baseBuyThr * TIER2_EDGE_MULT, 0.30), 3);
   if (result.shortThresholdTier2Pct === undefined) result.shortThresholdTier2Pct = round(Math.max(baseShortThr * TIER2_EDGE_MULT, 0.31), 3);
   for (const r of result.rows) {
@@ -461,13 +476,13 @@ function withNews(result, p) {
     } else if (r.expectedPct >= 0) {
       delete r.shortBlockedByBroker;
     }
-    if (r.expectedPct < 0 && (r.lastMovePct ?? 0) > 4.5) {
+    if (r.expectedPct < 0 && (r.shortBlockedBySqueeze || r.regimeSqueeze || (r.lastMovePct ?? 0) > 4.5)) {
       r.shortBlockedBySqueeze = true;
       r.shortSignal = false;
     } else {
       delete r.shortBlockedBySqueeze;
     }
-    if (r.expectedPct > 0 && (r.lastMovePct ?? 0) < -4.5) {
+    if (r.expectedPct > 0 && (r.buyBlockedByDip || r.regimeCrash || (r.lastMovePct ?? 0) < -4.5)) {
       r.buyBlockedByDip = true;
       r.signal = false;
     } else {
@@ -501,10 +516,156 @@ function withNews(result, p) {
     } else {
       delete r.shortBlockedByNews;
     }
+
+    const effThr = r.expectedPct < 0 ? (r.shortThresholdPct || baseShortThr) : (r.buyThresholdPct || baseBuyThr);
+    const ratio = effThr > 0 ? Math.abs(Number(r.expectedPct) || 0) / effThr : 0;
+    r.thresholdRatioPct = Math.round(ratio * 100);
+    r.crossedThreshold = ratio >= 1;
+  }
+  if (!Array.isArray(result.nearSignals) || !result.nearSignals.length) {
+    const savedNear = nearSignalsCache.list?.length ? nearSignalsCache.list : (kvGet('nearSignalsLog')?.list || []);
+    result.nearSignals = savedNear;
   }
   return result;
 }
 
+// Формирует и инкрементально обновляет 5-дневный журнал сигналов, заблокированных входов (≥100% порога) и почти-сигналов (75–99% порога)
+async function updateNearSignalsJournal(ds, p, last, key) {
+  if (!ds?.timeline?.length || last < 0) return [];
+  const lastBarTs = ds.timeline[last] || Date.now();
+  const minTs = lastBarTs - 7 * DAY;
+  let startIdx = ds.timeline.findIndex((t) => t >= minTs);
+  if (startIdx < 0) startIdx = Math.max(0, last - 480);
+
+  if (nearSignalsCache.key !== key || nearSignalsCache.scannedBarTs < ds.timeline[startIdx]) {
+    const saved = kvGet('nearSignalsLog');
+    if (saved?.key === key && saved.scannedBarTs >= ds.timeline[startIdx] && Array.isArray(saved.entries)) {
+      nearSignalsCache = {
+        key,
+        scannedBarTs: saved.scannedBarTs,
+        episodesMap: new Map(saved.entries),
+        list: saved.list || [],
+      };
+    } else {
+      nearSignalsCache = { key, scannedBarTs: 0, episodesMap: new Map(), list: [] };
+    }
+  }
+
+  for (const [epKey, ep] of nearSignalsCache.episodesMap) {
+    if (ep.lastBarTs < minTs) nearSignalsCache.episodesMap.delete(epKey);
+  }
+
+  let updated = false;
+  for (let idx = startIdx; idx <= last; idx++) {
+    const barTs = ds.timeline[idx];
+    if (barTs <= nearSignalsCache.scannedBarTs) continue;
+    const r = await predictAt(ds, p, idx, { explain: false, liveSnap: null });
+    const nb = p.newsFilter ? blockingNews(6, barTs) : null;
+    const barMskIso = new Date(barTs + MSK).toISOString();
+    const dayStr = barMskIso.slice(0, 10);
+    const timeStr = barMskIso.slice(11, 16);
+
+    for (const row of r.rows) {
+      if (row.inIndex === false) continue;
+      const side = row.expectedPct < 0 ? 'short' : 'long';
+      const thr = side === 'short' ? row.shortThresholdPct : row.buyThresholdPct;
+      const absExp = Math.abs(row.expectedPct || 0);
+      const ratio = thr > 0 ? absExp / thr : 0;
+      if (ratio < 0.75) continue;
+
+      const crossed = absExp >= thr;
+      const dg = p.modelUseDividends !== false ? liveDividendGuard(row.symbol, row.price, barTs) : null;
+      const bNews = nb?.get(row.symbol);
+      const reasons = [];
+      if (side === 'short') {
+        if (p.modelDirection === 'long') reasons.push('режим «только в рост»');
+        if (row.shortBlockedBySqueeze || row.regimeSqueeze || (row.lastMovePct ?? 0) > 4.5) 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})`);
+      } else {
+        if (row.buyBlockedByDip || row.regimeCrash || (row.lastMovePct ?? 0) < -4.5) reasons.push('защита от обвала свечи');
+        if (row.buyBlockedByOverheat) reasons.push(`перегрев +${row.buyBlockedByOverheat}%`);
+        if (dg?.blockLong) reasons.push(`отсечка дивидендов ${dg.exDate}`);
+        if (bNews?.bad) reasons.push(`фильтр новостей (${bNews.bad.gist})`);
+      }
+      if (row.liquid === false) reasons.push('низкая ликвидность');
+
+      const isSignal = crossed && reasons.length === 0 && Boolean(side === 'long' ? row.signal : row.shortSignal);
+      const status = isSignal ? 'signal' : crossed ? 'blocked' : 'near';
+      const rankOf = (st) => (st === 'signal' ? 3 : st === 'blocked' ? 2 : 1);
+
+      const epKey = `${dayStr}:${row.symbol}:${side}`;
+      const prev = nearSignalsCache.episodesMap.get(epKey);
+      if (!prev) {
+        nearSignalsCache.episodesMap.set(epKey, {
+          day: dayStr,
+          firstBar: timeStr,
+          lastBar: timeStr,
+          firstBarTs: barTs,
+          lastBarTs: barTs,
+          peakBar: timeStr,
+          barsCount: 1,
+          symbol: row.symbol,
+          name: row.name,
+          side,
+          price: row.price,
+          peakExpectedPct: row.expectedPct,
+          thresholdPct: thr,
+          peakRatioPct: Math.round(ratio * 100),
+          status,
+          reasons,
+        });
+      } else {
+        prev.lastBar = timeStr;
+        prev.lastBarTs = barTs;
+        prev.barsCount += 1;
+        const pctNow = Math.round(ratio * 100);
+        if (rankOf(status) > rankOf(prev.status) || (rankOf(status) === rankOf(prev.status) && pctNow >= prev.peakRatioPct)) {
+          prev.peakExpectedPct = row.expectedPct;
+          prev.thresholdPct = thr;
+          prev.peakRatioPct = Math.max(prev.peakRatioPct, pctNow);
+          prev.peakBar = timeStr;
+          prev.price = row.price;
+          prev.status = status;
+          if (reasons.length) prev.reasons = reasons;
+        } else if (pctNow > prev.peakRatioPct) {
+          prev.peakExpectedPct = row.expectedPct;
+          prev.thresholdPct = thr;
+          prev.peakRatioPct = pctNow;
+          prev.peakBar = timeStr;
+        }
+        if (reasons.length && !prev.reasons?.length) prev.reasons = reasons;
+      }
+    }
+    nearSignalsCache.scannedBarTs = barTs;
+    updated = true;
+  }
+
+  if (updated || !nearSignalsCache.list.length) {
+    const list = [...nearSignalsCache.episodesMap.values()]
+      .sort((a, b) => (b.lastBarTs - a.lastBarTs) || (b.peakRatioPct - a.peakRatioPct))
+      .slice(0, 40)
+      .map((ep) => {
+        const gapPct = round(Math.max(0, ep.thresholdPct - Math.abs(ep.peakExpectedPct)), 2);
+        const reasonText = ep.status === 'signal'
+          ? 'Порог пройден — сигнал сформирован'
+          : ep.status === 'blocked'
+            ? `Порог пройден, но вход закрыт: ${(ep.reasons || []).join(' · ') || 'защитный фильтр'}`
+            : `Ниже порога на ${gapPct}%${ep.reasons?.length ? ` (также активен фильтр: ${ep.reasons.join(' · ')})` : ''}`;
+        return { ...ep, gapPct, reasonText };
+      });
+    nearSignalsCache.list = list;
+    kvSet('nearSignalsLog', {
+      key,
+      scannedBarTs: nearSignalsCache.scannedBarTs,
+      entries: [...nearSignalsCache.episodesMap.entries()],
+      list,
+    });
+  }
+  return nearSignalsCache.list;
+}
+
 // Добавляет к каждой строке дельту ожидания (deltaPct) и смещение в рейтинге (rankDelta) относительно предыдущего замера
 function attachDeltas(rows, stateObj) {
   const prevExp = stateObj.prevExpMap;
@@ -590,7 +751,15 @@ export async function forecastNow(input, { force = false, onProgress } = {}) {
   //    ВСЕГДА выполняем быстрый живой пересчёт по секундным котировкам Т-Банка/Мосбиржи (~80 мс, никогда не блокируя UI),
   //    а если с момента последнего обновления 10-минутных свечей прошло больше 10 минут — запускаем догрузку свечей параллельно в фоне!
   if (!force && baseState && baseState.key === key) {
-    if (now - baseState.dsLoadedAt >= 4 * 60000 && !inflight.has(key)) {
+    const inflightAge = now - (inflightStartedAt.get(key) || 0);
+    if (inflight.has(key) && inflightAge > 90000) {
+      inflight.delete(key);
+      inflightStartedAt.delete(key);
+    }
+    const latestClosedSlotTs = Math.floor((now - BAR_MS) / BAR_MS) * BAR_MS;
+    const curBarTs = baseState.ds?.timeline?.[baseState.last] || 0;
+    const barStale = curBarTs > 0 && curBarTs < latestClosedSlotTs && (now - baseState.dsLoadedAt >= 60000);
+    if ((now - baseState.dsLoadedAt >= 4 * 60000 || barStale) && !inflight.has(key)) {
       setImmediate(() => {
         refreshDatasetStateInBackground(p, key).catch(() => {});
       });
@@ -615,8 +784,8 @@ export async function forecastNow(input, { force = false, onProgress } = {}) {
       }
       const liveSnap = await fetchLiveMoexSnapshot().catch(() => null);
       const liveTs = liveSnap?.ts || now;
-      const baseBuyThr = saved.result.buyThresholdPct ?? saved.result.thresholdPct ?? 0.413;
-      const baseShortThr = saved.result.shortThresholdPct ?? saved.result.thresholdPct ?? 0.516;
+      const baseBuyThr = saved.result.buyThresholdPct ?? saved.result.thresholdPct ?? 0.40;
+      const baseShortThr = saved.result.shortThresholdPct ?? saved.result.thresholdPct ?? 0.50;
       const rows = (saved.result.rows || []).map((r) => {
         const px = liveSnap?.prices?.get(r.symbol);
         const mult = symbolEdgeMult(r.symbol);
@@ -646,11 +815,15 @@ export async function forecastNow(input, { force = false, onProgress } = {}) {
 
 // Фоновая догрузка свежих 10-минутных свечей и пересборка контекста u (не блокирует живой тик котировок)
 function refreshDatasetStateInBackground(p, key, { force = false, onProgress } = {}) {
-  if (!force && inflight.has(key)) return inflight.get(key);
+  const now = Date.now();
+  if (!force && inflight.has(key)) {
+    if (now - (inflightStartedAt.get(key) || 0) < 90000) return inflight.get(key);
+    inflight.delete(key);
+    inflightStartedAt.delete(key);
+  }
   const autoAdapt = p.modelAutoAdapt !== false;
   const effHorizon = autoAdapt ? 2.5 : p.modelHorizon;
   const effMinEdge = autoAdapt ? 2.5 : p.modelMinEdge;
-  const now = Date.now();
   const task = (async () => {
     hub.emit({ type: 'trading:pulse', kind: 'train', ts: now, text: 'Обновление котировок и расчёт прогноза…' });
     // Всегда держим полный горизонт окна обучения (например, 160 дн. при modelTrainDays=90):
@@ -666,6 +839,7 @@ function refreshDatasetStateInBackground(p, key, { force = false, onProgress } =
     ]);
     const last = lastClosedIndex(ds, now);
     const r = await predictAt(ds, p, last, { explain: true, liveSnap, forceTrain: Boolean(force) });
+    const nearSignals = await updateNearSignalsJournal(ds, p, last, key).catch(() => []);
     const snap = r.snap || mapSnapshot(r.f);
     const sortedRows = r.rows.map(({ i, expected, ...x }) => ({ ...x, cluster: snap.clusters[i] })).sort((a, b) => b.expectedPct - a.expectedPct);
     const stateObj = baseState && baseState.key === key ? baseState : { prevExpMap: null, prevRankMap: null };
@@ -686,6 +860,7 @@ function refreshDatasetStateInBackground(p, key, { force = false, onProgress } =
       shortThresholdTier2Pct: round(Math.max((r.needS ?? r.threshold) * TIER2_EDGE_MULT * 100, 0.31), 3),
       marketDown: r.marketDown,
       rows: sortedRows,
+      nearSignals,
       map: { symbols: ds.tokens.map((t) => t.symbol), names: ds.tokens.map((t) => t.name), pts: snap.pts.map(([x, y]) => [round(x, 3), round(y, 3)]), cl: snap.clusters },
       heads: HEADS.map((h, i) => ({ label: h.label, coef: round(r.fitted.attention.coef[i], 4) })),
     };
@@ -708,8 +883,21 @@ function refreshDatasetStateInBackground(p, key, { force = false, onProgress } =
     };
     kvSet('lastForecastSnap', { key, result });
     hub.emit({ type: 'trading:pulse', kind: 'radar', ts: finishNow, bar: result.bar, signals: sortedRows.filter((x) => x.signal || x.shortSignal).length });
+    if (coldLocalFirst) {
+      setTimeout(() => {
+        if (!inflight.has(key)) {
+          refreshDatasetStateInBackground(p, key, { force: false }).catch(() => {});
+        }
+      }, 2000);
+    }
     return result;
-  })().finally(() => inflight.delete(key));
+  })().finally(() => {
+    if (inflight.get(key) === task) {
+      inflight.delete(key);
+      inflightStartedAt.delete(key);
+    }
+  });
   inflight.set(key, task);
+  inflightStartedAt.set(key, now);
   return task;
 }

package/server/model/live.js

@@ -6,7 +6,7 @@ import { hub } from '../hub.js';
 import { latestBarTs } from '../data/moex.js';
 import { loadDataset, barsFromHours, BAR_MS, BAR_INTERVAL } from './dataset.js';
 import { predictAt, lastClosedIndex } from './forecast.js';
-import { symbolEdgeMult, QUARANTINE_DECAY, isStockQuarantined, canEnterIntraday, shouldExitBeforeNight, isRegimeShocked } from './edge.js';
+import { ENTRY_EDGE_MULT, symbolEdgeMult, QUARANTINE_DECAY, isStockQuarantined, canEnterIntraday, shouldExitBeforeNight, isRegimeShocked } from './edge.js';
 import { computeReport, downsample } from './metrics.js';
 import { MODELS } from './models.js';
 import { blockingNews } from '../news/index.js';
@@ -336,7 +336,7 @@ class LiveEngine {
     const maxSlotWeight = dir === 'long' ? Math.min(0.58, Math.max(1 / K, 1.8 / K)) : Math.min(0.75, 3.0 / (2 * K));
     const invVol = s.params.modelAllocMode === 'invvol';
     const effMinEdge = autoAdapt ? 2.5 : s.params.modelMinEdge;
-    const needPct = effMinEdge * 2 * (s.params.commissionPct + s.params.slippagePct);
+    const needPct = effMinEdge * 2 * (s.params.commissionPct + s.params.slippagePct) * ENTRY_EDGE_MULT;
     const buyOrders = s.pending.filter((x) => x.action === 'buy' || x.action === 'short');
     if (autoAdapt && buyOrders.length > 1) {
       buyOrders.sort((a, b) => Math.abs(b.expectedPct || 0) - Math.abs(a.expectedPct || 0));

package/server/model/research.js

@@ -42,7 +42,8 @@ export function isMarketDown(ds, t) {
 // 11: индивидуальный расчёт порога каждой акции по её фактическому рублёвому обороту и остаточной волатильности
 // 12: калибровка индивидуальных порогов 2–3 эшелона по ликвидности, защита от шорт-сквизов (≥20% за день) и обвалов (≥9,5% за 30м), отбор доступных шортов до Top-K
 // 13: полная докачка левого края истории свечей (раньше при уже накопленных свечах 2022 год не догружался)
-const DATA_VERSION = 13;
+// 14: фиксация начала датасета современного 17-часового режима Мосбиржи (18.01.2024) и якоря фолдов после редомициляции (13.06.2024)
+const DATA_VERSION = 14;
 
 const AUTO_LOCKED = { modelHorizon: 2.5, modelMinEdge: 2.5, modelExitRatio: 0.95 };
 function reuseParamsKey(params) {
@@ -160,13 +161,14 @@ async function run(runId, p, state) {
   // НИКОГДА не сдвигала fromTs и не вызывала повторную загрузку котировок!
   const todayStartMsk = Math.floor((tillTs + MSK) / DAY) * DAY - MSK;
   const rawResearchFrom = todayStartMsk - p.modelHistoryDays * DAY;
-  // Стабильная привязка сетки 20-дневных окон переобучения к эпохе (1706165400000 = 25.01.2024):
-  // начало первого фолда выравнивается по 20-дневной сетке, чтобы смена календарного дня запуска НЕ перекраивала всю прошлую 3-летнюю историю фолдов,
-  // а новые торговые дни честно дописывались в правый край последнего фолда!
-  const EPOCH_ANCHOR_TS = 1706165400000;
+  // Стабильная привязка к современному режиму торгов Мосбиржи (утренняя + основная + вечерняя сессии, 94 свечи/день с 18.01.2024)
+  // и якорю сетки 20-дневных окон после завершения волны редомициляции ключевых эмитентов (1718272800000 = 13.06.2024 13:00 МСК):
+  // смена календарного дня запуска или наличие в SQLite архивных свечей 2022–2023 гг. НИКОГДА не сдвигает сетку фолдов и не искажает barsPerDay!
+  const MODERN_REGIME_START_TS = 1705560600000;
+  const EPOCH_ANCHOR_TS = 1718272800000;
   const gridBlockMs = 20 * DAY;
-  const researchFrom = EPOCH_ANCHOR_TS + Math.round((rawResearchFrom - EPOCH_ANCHOR_TS) / gridBlockMs) * gridBlockMs;
-  const fromTs = EPOCH_ANCHOR_TS - 660 * DAY;
+  const researchFrom = Math.max(EPOCH_ANCHOR_TS, EPOCH_ANCHOR_TS + Math.round((rawResearchFrom - EPOCH_ANCHOR_TS) / gridBlockMs) * gridBlockMs);
+  const fromTs = MODERN_REGIME_START_TS;
 
   emit({ stage: 'data', pct: 0, text: 'Загружаем словарь рынка (состав индекса широкого рынка)…' });
   const ds = await loadDataset({
@@ -179,7 +181,7 @@ async function run(runId, p, state) {
   const bpd = ds.barsPerDay;
   const trainLen = Math.round(p.modelTrainDays * bpd);
   const testLen = Math.round(20 * bpd);
-  let testStart = Math.max(timeline.findIndex((t) => t >= researchFrom), trainLen + 10);
+  let testStart = Math.max(timeline.findIndex((t) => t >= researchFrom), FEATURE_WARMUP + maxH + 100);
   if (testStart < 0 || testStart >= T - H - 10) throw new Error('Недостаточно истории: увеличьте период исследования или уменьшите окно обучения');
   const firstTest = testStart;
 
@@ -999,8 +1001,7 @@ async function runStabilityLoop(targetId, runRow, st) {
     const effHorizon = autoAdapt ? 2.5 : p.modelHorizon;
     const H = barsFromHours(effHorizon);
     const tillTs = Date.now();
-    const todayStartMsk = Math.floor((tillTs + MSK) / DAY) * DAY - MSK;
-    const fromTs = todayStartMsk - 1650 * DAY;
+    const fromTs = 1705560600000;
     const periodTill = runRow.metrics?.period?.till || tillTs;
     const emitStab = (m) => { if (!st.cancelled) hub.emit({ type: 'stability:progress', runId: targetId, ...m }); };
     emitStab({ pct: 2, text: 'Проверка устойчивости: чтение локальных цен…' });

package/server/news/index.js

@@ -280,9 +280,9 @@ export function newsForSymbols(hours = 24) {
 
 // Для живой проверки с newsFilter: самые важные свежие новости (важность ≥ 0.6, |тон| ≥ 0.4)
 // по тикерам: symbol → { bad: { gist, imp, tone, ts }, good: {…} }
-export function blockingNews(hours = 6) {
+export function blockingNews(hours = 6, atTs = Date.now()) {
   const rows = db.prepare(`SELECT ts, title, gist, imp, tags FROM news
-    WHERE marked = 1 AND imp >= 0.6 AND tags IS NOT NULL AND tags != '[]' AND ts >= ?`).all(Date.now() - hours * 3600000);
+    WHERE marked = 1 AND imp >= 0.6 AND tags IS NOT NULL AND tags != '[]' AND ts >= ? AND ts <= ?`).all(atTs - hours * 3600000, atTs);
   const m = new Map();
   for (const r of rows) {
     for (const [sym, tone] of parseTags(r)) {

package/server/strategist/index.js

@@ -205,9 +205,9 @@ function systemPrompt() {
 - **Карта рынка и авто-эмбеддинг (modelEmbedDim = 0 Авто):** окно обучения фиксировано на 90 торговых днях. На каждом шаге размерность карты рынка автоматически определяется по спектральному порогу Марченко–Пастура (отсечение рыночного шума от истинных факторов).
 - **12 голов внимания и мульти-горизонт (1,5–3,5 часа):** модель смотрит на 3 масштаба времени (1ч, 3ч, день), цену и денежный поток, узких и широких соседей по карте, предсказывая чистое остаточное движение каждой акции относительно индекса Мосбиржи.
 - **Пороги входа и удержания (индивидуальные по эшелонам ликвидности):**
-  - Базовый порог выгоды на вход = 2,5 × (удвоенная сумма комиссии и проскальзывания) × 1,65 (запас над реальными издержками по стресс-тесту и фактическим сделкам). Для высоколиквидных голубых фишек 1-го эшелона (SBER, LKOH, GAZP, T, YDEX, GMKN, FLOT и др.) при издержках 0,05% за сделку это +0,413% (в таблице отображается как +0,41%).
-  - Для акций 2–3-го эшелона с более широким спредом в стакане (MRKU, LSRG, SFIN, SOFL, FIXR, NKNCP, SVAV, PIKK, SMLT и др.) порог автоматически повышается в 1,20× — до +0,495% (+0,50%).
-  - Авто-балансировка по тренду индекса: на растущем рынке (индекс выше 20-дневной средней) покупки открываются от +0,41% (1-й эшелон) и +0,50% (2–3-й эшелон), а контртрендовые шорты ужесточаются в 1,25× (до −0,52% для 1-го эшелона и −0,62% для 2–3-го эшелона). На падающем рынке — наоборот. Всегда называй пользователю именно индивидуальный порог конкретной бумаги (\`порог_покупки_проц\` / \`порог_шорта_проц\`).
+  - Базовый порог выгоды на вход = 2,5 × (удвоенная сумма комиссии и проскальзывания) × 1,60 (запас над реальными издержками по стресс-тесту и фактическим сделкам). Для высоколиквидных голубых фишек 1-го эшелона (SBER, LKOH, GAZP, T, YDEX, GMKN, FLOT и др.) при издержках 0,05% за сделку это +0,40% (с индивидуальной подстройкой под оборот и волатильность бумаги).
+  - Для акций 2–3-го эшелона с более широким спредом в стакане (MRKU, LSRG, SFIN, SOFL, FIXR, NKNCP, SVAV, PIKK, SMLT и др.) порог автоматически повышается в 1,20× — до ~+0,48% (с индивидуальной поправкой на рублёвую ликвидность стакана).
+  - Авто-балансировка по тренду индекса: на растущем рынке (индекс выше 20-дневной средней) покупки открываются от базового порога (+0,40% 1-й эшелон и +0,48% 2–3-й эшелон), а контртрендовые шорты ужесточаются в 1,25× (до −0,50% для 1-го эшелона и −0,60% для 2–3-го эшелона). На падающем рынке — наоборот. Всегда называй пользователю именно индивидуальный порог конкретной бумаги (\`порог_покупки_проц\` / \`порог_шорта_проц\`).
   - Удержание позиции: первые 65 минут после входа действует мягкий порог удержания (0,35× от порога входа), затем — плотный порог фиксации прибыли.
   - Реальные издержки на счёте Т-Банка (по фактическим сделкам): комиссия ~0,04% + отклонение цены исполнения от цены сигнала ~0,03–0,08% на сторону.
 - **Dynamic Top-K (modelTopK = 0 Авто) и Conviction Sizing:** фиксированного числа акций нет — робот держит от 0 до 4 лонгов и до 4 шортов в зависимости от силы сигналов и концентрирует слот в лучших лидерах.

package/server/strategist/tools.js

@@ -279,6 +279,8 @@ export const TOOLS = {
           ожидание_проц: x.expectedPct,
           порог_покупки_проц: symBuyThr,
           ...(x.shortSignal !== undefined ? { порог_шорта_проц: -symShortThr } : {}),
+          доля_порога_проц: x.thresholdRatioPct ?? 0,
+          порог_пройден: Boolean(x.crossedThreshold),
           импульс_текущей_свечи_проц: x.lastMovePct ?? 0,
           динамика_проц: x.deltaPct || 0,
           сигнал_покупки: !!x.signal,
@@ -310,6 +312,7 @@ export const TOOLS = {
           ...(targetRow ? { выбранная_акция: pick(targetRow) } : {}),
           сильнее_рынка: r.rows.slice(0, top).map(pick),
           слабее_рынка: r.rows.slice(-Math.min(6, top)).reverse().map(pick),
+          журнал_почти_сигналов_за_неделю: (r.nearSignals || []).slice(0, 12),
         },
         summary: `Прогноз на свече ${r.bar}: сигналов покупки ${r.rows.filter((x) => x.signal).length}, шорта ${r.rows.filter((x) => x.shortSignal).length}`,
       };