neuroalpha 0.5.22 → 0.5.27

package/server/model/dataset.js

@@ -227,7 +227,7 @@ export async function loadDataset({ interval = BAR_INTERVAL, fromTs, tillTs, use
   // Если в памяти уже есть более широкий датасет (не 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) && Date.now() - v.at < 4 * 60000 && Math.abs(v.fromTs - fromTs) < 2 * DAY && Math.abs(v.tillTs - tillTs) < 10 * 60000) {
       return v.ds;
     }
   }
@@ -255,19 +255,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 +430,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/edge.js

@@ -5,7 +5,7 @@
 // По фактическим сделкам счёта Т-Банка (111 сделок) и стресс-тесту:
 //   • бумаги 1-го эшелона (SBER, T, GAZP, LKOH, YDEX и др.): реальное проскальзывание ~0,01–0,03% + комиссия 0,04% → порог ×2 (от 0,50%);
 //   • бумаги 2–3 эшелона (MRKC, NKHP, AQUA и др.): широкий спред в стакане, проскальзывание до 0,10–0,25% → порог ещё в 1,35× выше (от 0,675%).
-export const ENTRY_EDGE_MULT = 1.65;
+export const ENTRY_EDGE_MULT = 1.60;
 export const TIER2_EDGE_MULT = 1.20;
 
 // Голубые фишки и наиболее ликвидные акции 1-го эшелона Мосбиржи (глубокий стакан, минимальный спред):
@@ -20,13 +20,45 @@ export function symbolEdgeMult(symbol, { sigma = 0, avgSigma = 0, avgBarValRub =
   const isT1 = TIER1_LIQUID_SYMBOLS.has(symbol);
   const base = isT1 ? 1.0 : TIER2_EDGE_MULT;
   if (!(sigma > 0 || avgBarValRub > 0)) return base;
-  const refVal = isT1 ? 15e6 : 1.5e6;
-  const liqAdj = avgBarValRub > 0
-    ? Math.max(-0.07, Math.min(0.10, -0.05 * Math.log10(Math.max(5e4, avgBarValRub) / refVal)))
+  if (isT1) {
+    const refVal = 15e6;
+    const liqAdj = avgBarValRub > 0
+      ? Math.max(-0.07, Math.min(0.10, -0.05 * Math.log10(Math.max(5e4, avgBarValRub) / refVal)))
+      : 0;
+    const sigRatio = (sigma > 0 && avgSigma > 0) ? (sigma / avgSigma) : 1;
+    const volAdj = Math.max(-0.05, Math.min(0.10, 0.12 * (sigRatio - 1)));
+    return Math.max(0.88, Math.min(1.45, base * (1 + liqAdj + volAdj)));
+  }
+  const liqAdj2 = avgBarValRub > 0
+    ? Math.max(-0.015, Math.min(0.025, -0.012 * Math.log10(Math.max(1e5, avgBarValRub) / 1.5e6)))
     : 0;
-  const sigRatio = (sigma > 0 && avgSigma > 0) ? (sigma / avgSigma) : 1;
-  const volAdj = Math.max(-0.05, Math.min(0.10, 0.12 * (sigRatio - 1)));
-  return Math.max(0.88, Math.min(1.45, base * (1 + liqAdj + volAdj)));
+  return Math.round(base * (1 + liqAdj2) * 1000) / 1000;
+}
+
+// Пороги защиты от структурного слома режима (взрывного шорт-сквиза ≥20% за торговый день или отвесного обвала ≥9,5% за 30 минут):
+export const REGIME_SHOCK_1D = 0.20;
+export const REGIME_CRASH_30M = 0.095;
+
+export function isRegimeShocked(ds, i, t, side = 'long') {
+  const tk = ds?.tokens?.[i];
+  if (!tk || t < 1) return false;
+  const bpd = Math.max(1, Math.round(ds.barsPerDay || 54));
+  const t1d = Math.max(0, t - bpd);
+  const p0 = tk.close[t1d], p1 = tk.close[t];
+  const m0 = ds.mclose?.[t1d], m1 = ds.mclose?.[t];
+  if (p0 > 0 && p1 > 0 && m0 > 0 && m1 > 0) {
+    const ex1d = (p1 / p0 - 1) - (m1 / m0 - 1);
+    if (side === 'short' ? ex1d > REGIME_SHOCK_1D : ex1d < -REGIME_SHOCK_1D) return true;
+  }
+  if (side === 'long' && t >= 3) {
+    const t3 = t - 3;
+    const pa = tk.close[t3], ma = ds.mclose?.[t3];
+    if (pa > 0 && p1 > 0 && ma > 0 && m1 > 0) {
+      const ex30m = (p1 / pa - 1) - (m1 / ma - 1);
+      if (ex30m < -REGIME_CRASH_30M) return true;
+    }
+  }
+  return false;
 }
 
 export function computeTokenEdgeMults(tokens, sigma, fromIdx = 0, tillIdx = 0) {

package/server/model/forecast.js

@@ -5,7 +5,7 @@ import { loadDataset, barsFromHours, BAR_MS } from './dataset.js';
 import { buildFold, MODELS, HEADS, KINDS, SCALES, BETAS, LIQ_MIN, FEATURE_WARMUP, explainAttention, mapSnapshot } from './models.js';
 import { loadProfiles } from './profiles.js';
 import { isMarketDown } from './research.js';
-import { ENTRY_EDGE_MULT, TIER2_EDGE_MULT, TIER1_LIQUID_SYMBOLS, symbolEdgeMult, computeTokenEdgeMults } from './edge.js';
+import { ENTRY_EDGE_MULT, TIER2_EDGE_MULT, TIER1_LIQUID_SYMBOLS, symbolEdgeMult, computeTokenEdgeMults, REGIME_SHOCK_1D, REGIME_CRASH_30M } from './edge.js';
 export { TIER1_LIQUID_SYMBOLS, symbolEdgeMult, computeTokenEdgeMults };
 import { newsForSymbols, blockingNews } from '../news/index.js';
 import { liveDividendGuard } from './dividends.js';
@@ -16,10 +16,38 @@ 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),
+// считаем средневзвешенную лог-доходность по весам индекса, чтобы не сравнивать секундные цены акций Т-Банка
+// с отстающим на 15–20 минут значением IMOEX из бесплатного контура MOEX ISS!
+function computeLiveMarketReturn(ds, idx, liveSnap) {
+  if (idx < 1 || idx >= ds.T) return 0;
+  if (liveSnap?.prices?.size > 0) {
+    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 livePx = liveSnap.prices.get(tk.symbol);
+      if (livePx > 0 && prevPx > 0) {
+        const w = tk.weight > 0 ? tk.weight : 1;
+        rSum += w * Math.log(livePx / prevPx);
+        wSum += w;
+        cnt++;
+      }
+    }
+    if (cnt >= 15 && wSum > 0) return rSum / wSum;
+    const mPrev = ds.mclose?.[idx - 1] || 0;
+    if (liveSnap.imoexPrice > 0 && mPrev > 0) return Math.log(liveSnap.imoexPrice / mPrev);
+  }
+  return ds.mret[idx] || 0;
+}
 
 // Быстрый расчёт признаков контекста в одной точке idx без переобучения матрицы внимания и весов (за ~1-2 мс)
 function buildInferenceFoldAt(ds, idx, fTrain, fitted, liveSnap = null) {
-  const { tokens, mret, mclose } = ds;
+  const { tokens, mret } = ds;
   const N = fTrain.N;
   const { beta, sigma, cos } = fTrain;
   const lo = Math.max(1, idx - FEATURE_WARMUP - 2);
@@ -31,11 +59,11 @@ function buildInferenceFoldAt(ds, idx, fTrain, fitted, liveSnap = null) {
   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++) {
     const t = lo + uk;
     const isLast = uk === u && liveSnap?.prices?.size > 0;
-    const mPrev = mclose?.[t - 1] || 0;
-    const mt = isLast && liveSnap.imoexPrice > 0 && mPrev > 0 ? Math.log(liveSnap.imoexPrice / mPrev) : mret[t];
+    const mt = isLast ? mLive : mret[t];
     for (let i = 0; i < N; i++) {
       const tk = tokens[i];
       let rt = tk.ret[t];
@@ -180,8 +208,7 @@ function applyLivePricesToFold(ds, f, u, fitted, liveSnap) {
   const idx = f.lo + u;
   if (idx < 1 || idx >= ds.T) return;
   const N = f.N;
-  const mPrev = ds.mclose?.[idx - 1] || 0;
-  const mLive = liveSnap.imoexPrice > 0 && mPrev > 0 ? Math.log(liveSnap.imoexPrice / mPrev) : ds.mret[idx];
+  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);
@@ -280,7 +307,7 @@ export async function predictAt(ds, p, idx, { explain = true, liveSnap = null, f
     emb: f.emb,
     embN: f.embN,
     eigenvalues: f.eigenvalues,
-    macro: f.macro ? { list: f.macro.list.map((m) => ({ id: m.id, label: m.label, b: m.b })) } : null,
+    macro: f.macro ? { list: f.macro.list.map((m) => ({ id: m.id, label: m.label, b: m.b, msig: m.msig })) } : null,
   };
   const lightFitted = {
     ...fitted,
@@ -289,9 +316,9 @@ export async function predictAt(ds, p, idx, { explain = true, liveSnap = null, f
   const trainedAt = Date.now();
   trainedModelCache.set(fitKey, { dayMsk: barDayMsk, trainedAt, fTrain, fitted: lightFitted, snap });
 
-  if (liveSnap) applyLivePricesToFold(ds, f, u, fitted, liveSnap);
+  const inf = buildInferenceFoldAt(ds, idx, fTrain, lightFitted, liveSnap);
   return {
-    ...buildPredictionRows(ds, p, idx, f, u, fitted, chosen, H, effMinEdge, autoAdapt, explain, liveSnap),
+    ...buildPredictionRows(ds, p, idx, inf.f, inf.u, inf.fitted, chosen, H, effMinEdge, autoAdapt, explain, liveSnap),
     snap,
     trainedAt,
   };
@@ -316,19 +343,31 @@ function buildPredictionRows(ds, p, idx, f, u, fitted, chosen, H, effMinEdge, au
   const trainSpan = Math.round(90 * (ds.barsPerDay || 54));
   const edgeMults = computeTokenEdgeMults(ds.tokens, f.sigma, Math.max(0, idx - trainSpan), idx);
   const bpd = ds.barsPerDay || 54;
+  const idx30m = Math.max(0, idx - 3);
   const idx1d = Math.max(0, idx - bpd);
   const idx3d = Math.max(0, idx - 3 * bpd);
-  const mNow = liveSnap?.imoexPrice > 0 ? liveSnap.imoexPrice : (ds.mclose?.[idx] || 0);
+  const mPrevBar = idx > 0 ? (ds.mclose?.[idx - 1] || 0) : 0;
+  const mLiveRet = computeLiveMarketReturn(ds, idx, liveSnap);
+  const mNow = liveSnap?.prices?.size > 0 && mPrevBar > 0
+    ? mPrevBar * Math.exp(mLiveRet)
+    : (liveSnap?.imoexPrice > 0 ? liveSnap.imoexPrice : (ds.mclose?.[idx] || 0));
+  const m30m = ds.mclose?.[idx30m] > 0 && mNow > 0 ? (mNow / ds.mclose[idx30m] - 1) : 0;
   const m1d = ds.mclose?.[idx1d] > 0 && mNow > 0 ? (mNow / ds.mclose[idx1d] - 1) : 0;
   const m3d = ds.mclose?.[idx3d] > 0 && mNow > 0 ? (mNow / ds.mclose[idx3d] - 1) : 0;
   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 livePx = liveSnap?.prices?.get(tk.symbol) || tk.close[idx] || 0;
-    const lastMovePct = round(f.z[u * f.N + i] * f.sigma[i] * 100, 3);
+    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 lastMovePct = round(rawResPct, 3);
     // Контроль перегрева (защита от покупки на вершине уже состоявшегося пампа и ложного «отскока на откате»):
+    const p30m = tk.close[idx30m] || 0;
     const p1d = tk.close[idx1d] || 0;
     const p3d = tk.close[idx3d] || 0;
+    const excess30m = (p30m > 0 && livePx > 0 ? (livePx / p30m - 1) : 0) - m30m;
     const excess1d = (p1d > 0 && livePx > 0 ? (livePx / p1d - 1) : 0) - m1d;
     const excess3d = (p3d > 0 && livePx > 0 ? (livePx / p3d - 1) : 0) - m3d;
     const isOverheated = excess1d >= 0.045 || excess3d >= 0.09;
@@ -336,8 +375,8 @@ function buildPredictionRows(ds, p, idx, f, u, fitted, chosen, H, effMinEdge, au
     let selfRaw = ex ? ex.self * f.sigma[i] * Math.sqrt(H) : 0;
     if (isOverheated && selfRaw > 0) {
       // Если акция уже взлетела за день/3 дня (памп) и начала откатываться вниз, линейный «возврат к среднему»
-      // ошибочно трактует начало обвала с пика как «перепроданность к отскоку вверх» — обнуляем ложный отскок вверх:
-      exp -= selfRaw;
+      // ошибочно трактует начало обвала с пика как «перепроданность к отскоку вверх» — гасим ложный отскок вверх, не переворачивая в искусственный шорт:
+      if (exp > 0) exp = Math.max(0, exp - selfRaw);
       selfRaw = 0;
     }
     const buyBlockedByOverheat = (exp > 0 && (excess1d >= 0.06 || excess3d >= 0.12))
@@ -347,18 +386,22 @@ function buildPredictionRows(ds, p, idx, f, u, fitted, chosen, H, effMinEdge, au
     const tierMult = edgeMults[i] || symbolEdgeMult(tk.symbol);
     const symNeedL = Math.max(needL * tierMult, 0.0030);
     const symNeedS = Math.max(needS * tierMult, 0.0031);
-    // Аварийный предохранитель экстремальных свечей (±4,5% за одну 10-минутную свечу — планка / остановка торгов / обвал):
+    // Аварийный предохранитель экстремальных свечей (±4,5% за одну 10-минутную свечу) и структурного слома режима (≥20% за день или обвал ≥9,5% за 30м):
     // обычные рабочие импульсы 1,5–3,5% НЕ блокируются, так как именно на возврате к среднему после локального выброса модель формирует сигнал!
     const EXTREME_BAR_MOVE_PCT = 4.5;
-    const liveBuyOk = !(liveSnap && lastMovePct < -EXTREME_BAR_MOVE_PCT) && !buyBlockedByOverheat;
-    const liveShortOk = !(liveSnap && lastMovePct > EXTREME_BAR_MOVE_PCT);
+    const isRegimeCrash = excess1d < -REGIME_SHOCK_1D || excess30m < -REGIME_CRASH_30M;
+    const isRegimeSqueeze = excess1d > REGIME_SHOCK_1D;
+    const isExtremeDip = Boolean(isRegimeCrash || (liveSnap && (lastMovePct < -EXTREME_BAR_MOVE_PCT || rawPriceMovePct < -EXTREME_BAR_MOVE_PCT)));
+    const isExtremeSpike = Boolean(isRegimeSqueeze || (liveSnap && (lastMovePct > EXTREME_BAR_MOVE_PCT || rawPriceMovePct > EXTREME_BAR_MOVE_PCT)));
+    const liveBuyOk = !isExtremeDip && !buyBlockedByOverheat;
+    const liveShortOk = !isExtremeSpike;
     // сигналы — только по бумагам из текущего состава индекса (исторические бумаги остаются в матрице рынка как контекст)
     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(liveSnap && exp < 0 && lastMovePct > EXTREME_BAR_MOVE_PCT);
-    const buyBlockedByDip = Boolean(liveSnap && exp > 0 && lastMovePct < -EXTREME_BAR_MOVE_PCT);
+    const shortBlockedBySqueeze = Boolean(exp < 0 && isExtremeSpike);
+    const buyBlockedByDip = Boolean(exp > 0 && isExtremeDip);
     const row = {
       i, symbol: tk.symbol, name: tk.name,
       tier: TIER1_LIQUID_SYMBOLS.has(tk.symbol) ? 1 : 2,
@@ -374,6 +417,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 }),
@@ -398,8 +443,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) {
@@ -420,13 +465,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 {
@@ -460,10 +505,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;
@@ -549,7 +740,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(() => {});
       });
@@ -574,8 +773,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);
@@ -605,11 +804,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):
@@ -625,6 +828,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 };
@@ -645,6 +849,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) })),
     };
@@ -667,8 +872,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;
 }