neuroalpha 0.5.16 → 0.5.19

package/server/model/dataset.js

@@ -19,10 +19,10 @@ export const BAR_MS = BAR_INTERVAL * 60000;
 // горизонт в часах → число свечей (минимум одна свеча)
 export const barsFromHours = (h) => Math.max(1, Math.round(Number(h) * (60 / BAR_INTERVAL)));
 
-function cacheKey(interval, fromTs, tillTs, useMacro, useDividends) {
+function cacheKey(interval, fromTs, tillTs, useMacro, useDividends, localOnly = false) {
   const day = Math.floor(fromTs / DAY);
-  const hour = Math.floor(tillTs / 3600000);
-  return JSON.stringify([interval, day, hour, useMacro ? 1 : 0, useDividends ? (process.env.DIVIDENDS_MODE || 1) : 0]);
+  const slot = Math.floor(tillTs / BAR_MS);
+  return JSON.stringify([interval, day, slot, useMacro ? 1 : 0, useDividends ? (process.env.DIVIDENDS_MODE || 1) : 0, localOnly ? 1 : 0]);
 }
 
 async function pool(items, limit, fn) {
@@ -219,14 +219,13 @@ 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 key = cacheKey(interval, fromTs, tillTs, useMacro, useDividends);
+  const key = cacheKey(interval, fromTs, tillTs, useMacro, useDividends, localOnly);
   const hit = datasetCache.get(key);
-  if (hit && Date.now() - hit.at < 30 * 60000) return hit.ds;
-  // Если в памяти уже есть более широкий датасет (например, при изменении Окна обучения modelTrainDays),
-  // который полностью покрывает запрошенный диапазон [fromTs … tillTs], возвращаем его мгновенно без пересборки!
+  if (hit && Date.now() - hit.at < 4 * 60000) 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 && Date.now() - v.at < 30 * 60000 && v.fromTs <= fromTs + DAY && Math.abs(v.tillTs - tillTs) < 3600000) {
+    if (v.modeKey === modeKey && (!v.localOnly || localOnly) && Date.now() - v.at < 4 * 60000 && v.fromTs <= fromTs + DAY && Math.abs(v.tillTs - tillTs) < 10 * 60000) {
       return v.ds;
     }
   }
@@ -412,7 +411,7 @@ export async function loadDataset({ interval = BAR_INTERVAL, fromTs, tillTs, use
     }
   }
   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 };
-  datasetCache.set(key, { ds, at: Date.now(), modeKey, fromTs, tillTs });
+  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

@@ -1,19 +1,41 @@
-// Copyright (c) 2026 Roman A. Perepelkin. All rights reserved. Proprietary software.
-// Множители порога входа и выхода стратегии и классификация 1-го эшелона ликвидности Мосбиржи.
-// Базовый порог = 2,5 × (комиссия + проскальзывание) × 2 стороны; множители поднимают его так,
-// чтобы ожидаемое движение покрывало РЕАЛЬНЫЕ издержки с запасом.
-// По фактическим сделкам счёта Т-Банка (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 TIER2_EDGE_MULT = 1.20;
-
-// Голубые фишки и наиболее ликвидные акции 1-го эшелона Мосбиржи (глубокий стакан, минимальный спред):
-export const TIER1_LIQUID_SYMBOLS = new Set([
-  'SBER', 'SBERP', 'LKOH', 'GAZP', 'T', 'YDEX', 'ROSN', 'NVTK', 'GMKN', 'PLZL',
-  'VTBR', 'TATN', 'TATNP', 'SNGS', 'SNGSP', 'ALRS', 'CHMF', 'NLMK', 'MAGN', 'MOEX',
-  'OZON', 'HEAD', 'PHOR', 'AFLT', 'VKCO', 'MTSS', 'IRAO', 'TRNFP', 'RUAL', 'AFKS',
-  'PIKK', 'SMLT', 'POSI', 'BSPB', 'SVCB', 'SOVCOM', 'CBOM', 'FLOT', 'X5',
-]);
-
-export const symbolEdgeMult = (symbol) => (TIER1_LIQUID_SYMBOLS.has(symbol) ? 1 : TIER2_EDGE_MULT);
+// Copyright (c) 2026 Roman A. Perepelkin. All rights reserved. Proprietary software.
+// Множители порога входа и выхода стратегии и классификация 1-го эшелона ликвидности Мосбиржи.
+// Базовый порог = 2,5 × (комиссия + проскальзывание) × 2 стороны; множители поднимают его так,
+// чтобы ожидаемое движение покрывало РЕАЛЬНЫЕ издержки с запасом.
+// По фактическим сделкам счёта Т-Банка (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 TIER2_EDGE_MULT = 1.20;
+
+// Голубые фишки и наиболее ликвидные акции 1-го эшелона Мосбиржи (глубокий стакан, минимальный спред):
+// высоковолатильные бумаги со спредом 2-го эшелона (SMLT, PIKK, POSI, AFKS, VKCO, CBOM, BSPB, SVCB) идут по порогу TIER2_EDGE_MULT.
+export const TIER1_LIQUID_SYMBOLS = new Set([
+  'SBER', 'SBERP', 'LKOH', 'GAZP', 'T', 'YDEX', 'ROSN', 'NVTK', 'GMKN', 'PLZL',
+  'VTBR', 'TATN', 'TATNP', 'SNGS', 'SNGSP', 'ALRS', 'CHMF', 'NLMK', 'MAGN', 'MOEX',
+  'OZON', 'HEAD', 'PHOR', 'AFLT', 'MTSS', 'IRAO', 'TRNFP', 'RUAL', 'FLOT', 'X5',
+]);
+
+export const symbolEdgeMult = (symbol) => (TIER1_LIQUID_SYMBOLS.has(symbol) ? 1 : TIER2_EDGE_MULT);
+
+// Затухание штрафных счётчиков карантина на 30-минутном шаге (период полураспада ~15 торговых дней: 0,9985^(15×33) ≈ 0,48)
+export const QUARANTINE_DECAY = 0.9985;
+export const isStockQuarantined = (cnt, pnl) => (cnt >= 2 && pnl < -0.012) || pnl < -0.025;
+
+// Граница вечерней сессии Мосбиржи (последняя 10-минутная свеча 23:40–23:50 МСК):
+// не открываем новые внутридневные позиции, когда до конца торгов остаётся меньше горизонта H, и закрываем позиции перед ночью
+const MSK = 3 * 3600000;
+const DAY = 86400000;
+export const SESSION_END_MINS_MSK = 23 * 60 + 40;
+
+export const canEnterIntraday = (ts, horizonBars, barInterval = 10) => {
+  const minsMsk = Math.floor(((ts + MSK) % DAY) / 60000);
+  return minsMsk <= SESSION_END_MINS_MSK - horizonBars * barInterval;
+};
+
+export const shouldExitBeforeNight = (ts, entryTs = 0, stepBars = 3, barInterval = 10) => {
+  const minsMsk = Math.floor(((ts + MSK) % DAY) / 60000);
+  if (minsMsk >= SESSION_END_MINS_MSK - stepBars * barInterval) return true;
+  if (entryTs > 0 && Math.floor((ts + MSK) / DAY) > Math.floor((entryTs + MSK) / DAY)) return true;
+  return false;
+};

package/server/model/forecast.js

@@ -5,9 +5,10 @@ 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, TIER1_LIQUID_SYMBOLS, symbolEdgeMult } from './edge.js';
-export { TIER1_LIQUID_SYMBOLS };
-import { newsForSymbols } from '../news/index.js';
+import { ENTRY_EDGE_MULT, TIER2_EDGE_MULT, TIER1_LIQUID_SYMBOLS, symbolEdgeMult } from './edge.js';
+export { TIER1_LIQUID_SYMBOLS, symbolEdgeMult };
+import { newsForSymbols, blockingNews } from '../news/index.js';
+import { liveDividendGuard } from './dividends.js';
 import { fetchTbankRealtimePrices } from '../brokers/index.js';
 import { kvGet, kvSet } from '../db.js';
 import { hub } from '../hub.js';
@@ -27,6 +28,9 @@ function buildInferenceFoldAt(ds, idx, fTrain, fitted, liveSnap = null) {
 
   const z = new Float64Array(W * N);
   const vr = new Float64Array(W * N);
+  const barTs = ds.timeline[idx] || 0;
+  const elapsedBars = liveSnap?.ts && barTs > 0 ? Math.max(1, (liveSnap.ts - barTs) / BAR_MS) : 1;
+  const liveScale = 1 / Math.sqrt(elapsedBars);
   for (let uk = 0; uk < W; uk++) {
     const t = lo + uk;
     const isLast = uk === u && liveSnap?.prices?.size > 0;
@@ -40,7 +44,7 @@ function buildInferenceFoldAt(ds, idx, fTrain, fitted, liveSnap = null) {
         const livePx = liveSnap.prices.get(tk.symbol);
         if (livePx > 0 && prevPx > 0) rt = Math.log(livePx / prevPx);
       }
-      const e = rt - beta[i] * mt;
+      const e = (rt - beta[i] * mt) * (isLast ? liveScale : 1);
       z[uk * N + i] = Math.max(-8, Math.min(8, e / sigma[i]));
       vr[uk * N + i] = Math.min(4, tk.valRatio[t]);
     }
@@ -178,15 +182,18 @@ function applyLivePricesToFold(ds, f, u, fitted, liveSnap) {
   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 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);
 
-  // 1) пересчитываем z[u*N + i] по живой цене акции относительно закрытия предыдущей свечи
+  // 1) пересчитываем z[u*N + i] по живой цене акции с нормировкой к масштабу одной 10-минутной свечи
   for (let i = 0; i < N; i++) {
     const tk = ds.tokens[i];
     const prevPx = tk.close[idx - 1];
     const livePx = liveSnap.prices.get(tk.symbol);
     if (livePx > 0 && prevPx > 0) {
       const ret = Math.log(livePx / prevPx);
-      const e = ret - f.beta[i] * mLive;
+      const e = (ret - f.beta[i] * mLive) * liveScale;
       f.z[u * N + i] = Math.max(-8, Math.min(8, e / f.sigma[i]));
     }
   }
@@ -316,29 +323,38 @@ function buildPredictionRows(ds, p, idx, f, u, fitted, chosen, H, effMinEdge, au
     const tierMult = symbolEdgeMult(tk.symbol);
     const symNeedL = Math.max(needL * tierMult, 0.0030);
     const symNeedS = Math.max(needS * tierMult, 0.0031);
-    // Внутрисвечной предохранитель реального времени:
-    // не даём сигнал на покупку («не ловим падающий нож»), если на текущей живой свече акция проваливается против рынка сильнее чем на -0.35%,
-    // и не даём сигнал на шорт, если на текущей живой свече акция взлетает вверх сильнее чем на +0.35%!
-    const liveBuyOk = !(liveSnap?.realtime && lastMovePct < -0.35);
-    const liveShortOk = !(liveSnap?.realtime && lastMovePct > 0.35);
+    // Аварийный предохранитель экстремальных свечей (±4,5% за одну 10-минутную свечу — планка / остановка торгов / обвал):
+    // обычные рабочие импульсы 1,5–3,5% НЕ блокируются, так как именно на возврате к среднему после локального выброса модель формирует сигнал!
+    const EXTREME_BAR_MOVE_PCT = 4.5;
+    const liveBuyOk = !(liveSnap && lastMovePct < -EXTREME_BAR_MOVE_PCT);
+    const liveShortOk = !(liveSnap && lastMovePct > EXTREME_BAR_MOVE_PCT);
     // сигналы — только по бумагам из текущего состава индекса (исторические бумаги остаются в матрице рынка как контекст)
     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(rawShortHit && shortableMap && shortableMap[tk.symbol] === false);
+    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 row = {
       i, symbol: tk.symbol, name: tk.name,
+      tier: tierMult === 1 ? 1 : 2,
       price: round(livePx, 4),
       liquid: tk.liq[idx] >= LIQ_MIN,
       expected: exp,
       expectedPct: round(exp * 100, 3),
+      buyThresholdPct: round(symNeedL * 100, 3),
+      shortThresholdPct: round(symNeedS * 100, 3),
       lastMovePct,
       weight: round(weight, 3),
       signal: inIdx && tk.liq[idx] >= LIQ_MIN && exp > symNeedL && liveBuyOk,
+      ...(shortAllowed !== null ? { shortAllowed } : {}),
+      ...(buyBlockedByDip ? { buyBlockedByDip: true } : {}),
       ...(inIdx ? {} : { inIndex: false }),
     };
     if (dir !== 'long') {
       row.shortSignal = rawShortHit && !shortBlockedByBroker;
       if (shortBlockedByBroker) row.shortBlockedByBroker = true;
+      if (shortBlockedBySqueeze) row.shortBlockedBySqueeze = true;
     }
     if (explain) {
       const ex = explainAttention(fitted.attention, f, u, i);
@@ -350,13 +366,74 @@ function buildPredictionRows(ds, p, idx, f, u, fitted, chosen, H, effMinEdge, au
   return { f, u, fitted, chosen, threshold, needL, needS, marketDown: bear, rows };
 }
 
-// Новости — только в прогнозе «сейчас»
+// Новости и защитные блокировки (сквиз, запрет шорта у брокера, дивидендная отсечка, новостной фильтр) — в прогнозе «сейчас»
 function withNews(result, p) {
   const nm = p.newsEnabled ? newsForSymbols(24) : null;
+  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;
+  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) {
+    const mult = symbolEdgeMult(r.symbol);
+    if (r.tier === undefined) r.tier = mult === 1 ? 1 : 2;
+    if (r.buyThresholdPct === undefined) r.buyThresholdPct = round(Math.max(baseBuyThr * mult, 0.30), 3);
+    if (r.shortThresholdPct === undefined) r.shortThresholdPct = round(Math.max(baseShortThr * mult, 0.31), 3);
     const n = nm?.get(r.symbol);
     if (n) r.news = n;
     else delete r.news;
+
+    if (shortableMap && r.symbol in shortableMap) {
+      r.shortAllowed = Boolean(shortableMap[r.symbol]);
+    }
+    if (r.expectedPct < 0 && r.shortAllowed === false) {
+      r.shortBlockedByBroker = true;
+      r.shortSignal = false;
+    } else if (r.expectedPct >= 0) {
+      delete r.shortBlockedByBroker;
+    }
+    if (r.expectedPct < 0 && (r.lastMovePct ?? 0) > 4.5) {
+      r.shortBlockedBySqueeze = true;
+      r.shortSignal = false;
+    } else {
+      delete r.shortBlockedBySqueeze;
+    }
+    if (r.expectedPct > 0 && (r.lastMovePct ?? 0) < -4.5) {
+      r.buyBlockedByDip = true;
+      r.signal = false;
+    } else {
+      delete r.buyBlockedByDip;
+    }
+
+    const dg = p.modelUseDividends !== false ? liveDividendGuard(r.symbol, r.price, nowTs) : null;
+    if (r.expectedPct > 0 && dg?.blockLong) {
+      r.buyBlockedByDiv = `Отсечка ${dg.exDate} (дивиденд ${dg.yieldPct}%)`;
+      r.signal = false;
+    } else {
+      delete r.buyBlockedByDiv;
+    }
+    if (r.expectedPct < 0 && dg?.blockShort) {
+      r.shortBlockedByDiv = `Отсечка ${dg.exDate} (дивиденд ${dg.yieldPct}%)`;
+      r.shortSignal = false;
+    } else {
+      delete r.shortBlockedByDiv;
+    }
+
+    const bNews = nb?.get(r.symbol);
+    if (r.expectedPct > 0 && bNews?.bad) {
+      r.buyBlockedByNews = bNews.bad.gist;
+      r.signal = false;
+    } else {
+      delete r.buyBlockedByNews;
+    }
+    if (r.expectedPct < 0 && bNews?.good) {
+      r.shortBlockedByNews = bNews.good.gist;
+      r.shortSignal = false;
+    } else {
+      delete r.shortBlockedByNews;
+    }
   }
   return result;
 }
@@ -417,6 +494,8 @@ async function tickLiveForecastState(p, now = Date.now()) {
     bar: fmtLiveBarLabel(barTs, liveSnap ? liveTs : null),
     buyThresholdPct: round(Math.max((r.needL ?? r.threshold) * 100, 0.30), 3),
     shortThresholdPct: round(Math.max((r.needS ?? r.threshold) * 100, 0.31), 3),
+    buyThresholdTier2Pct: round(Math.max((r.needL ?? r.threshold) * TIER2_EDGE_MULT * 100, 0.30), 3),
+    shortThresholdTier2Pct: round(Math.max((r.needS ?? r.threshold) * TIER2_EDGE_MULT * 100, 0.31), 3),
     marketDown: r.marketDown,
     rows: sortedRows,
   };
@@ -444,7 +523,7 @@ export async function forecastNow(input, { force = false, onProgress } = {}) {
   //    ВСЕГДА выполняем быстрый живой пересчёт по секундным котировкам Т-Банка/Мосбиржи (~80 мс, никогда не блокируя UI),
   //    а если с момента последнего обновления 10-минутных свечей прошло больше 10 минут — запускаем догрузку свечей параллельно в фоне!
   if (!force && baseState && baseState.key === key) {
-    if (now - baseState.dsLoadedAt >= 10 * 60000 && !inflight.has(key)) {
+    if (now - baseState.dsLoadedAt >= 4 * 60000 && !inflight.has(key)) {
       setImmediate(() => {
         refreshDatasetStateInBackground(p, key).catch(() => {});
       });
@@ -469,15 +548,26 @@ 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 rows = (saved.result.rows || []).map((r) => {
         const px = liveSnap?.prices?.get(r.symbol);
-        return px > 0 ? { ...r, price: round(px, 4) } : r;
+        const mult = symbolEdgeMult(r.symbol);
+        return {
+          ...r,
+          ...(px > 0 ? { price: round(px, 4) } : {}),
+          tier: r.tier ?? (mult === 1 ? 1 : 2),
+          buyThresholdPct: r.buyThresholdPct ?? round(Math.max(baseBuyThr * mult, 0.30), 3),
+          shortThresholdPct: r.shortThresholdPct ?? round(Math.max(baseShortThr * mult, 0.31), 3),
+        };
       });
       const updated = {
         ...saved.result,
         at: now,
         liveTs,
         bar: fmtLiveBarLabel(saved.result.barTs || saved.result.at, liveSnap ? liveTs : null),
+        buyThresholdTier2Pct: saved.result.buyThresholdTier2Pct ?? round(Math.max(baseBuyThr * TIER2_EDGE_MULT, 0.30), 3),
+        shortThresholdTier2Pct: saved.result.shortThresholdTier2Pct ?? round(Math.max(baseShortThr * TIER2_EDGE_MULT, 0.31), 3),
         rows,
       };
       return withNews(updated, p);
@@ -496,8 +586,10 @@ function refreshDatasetStateInBackground(p, key, { force = false, onProgress } =
   const now = Date.now();
   const task = (async () => {
     hub.emit({ type: 'trading:pulse', kind: 'train', ts: now, text: 'Обновление котировок и расчёт прогноза…' });
-    const trainedToday = !force && isModelTrainedToday(p, now);
-    const windowDays = trainedToday ? 7 : Math.ceil(p.modelTrainDays * 1.5 + 25);
+    // Всегда держим полный горизонт окна обучения (например, 160 дн. при modelTrainDays=90):
+    // чтение из локальной SQLite занимает ~0,3 с, гарантируя неизменность списка бумаг N (попадание в trainedModelCache за 1 мс без переобучения),
+    // прогретый суточный профиль объёма valRatio и корректный 10-дневный фильтр тренда isMarketDown!
+    const windowDays = Math.ceil(p.modelTrainDays * 1.5 + 25);
     // При первом холодном прогреве после перезапуска сервера (!baseState && !force) сначала читаем 100% локально из SQLite (за ~1-2 сек без похода в сеть по 100 акциям),
     // а сетевую догрузку свежих свечей запускаем уже после того, как baseState готов в RAM!
     const coldLocalFirst = !baseState && !force;
@@ -523,6 +615,8 @@ function refreshDatasetStateInBackground(p, key, { force = false, onProgress } =
       horizon: effHorizon, direction: p.modelDirection, model: r.chosen, thresholdPct: round(r.threshold * 100, 3),
       buyThresholdPct: round(Math.max((r.needL ?? r.threshold) * 100, 0.30), 3),
       shortThresholdPct: round(Math.max((r.needS ?? r.threshold) * 100, 0.31), 3),
+      buyThresholdTier2Pct: round(Math.max((r.needL ?? r.threshold) * TIER2_EDGE_MULT * 100, 0.30), 3),
+      shortThresholdTier2Pct: round(Math.max((r.needS ?? r.threshold) * TIER2_EDGE_MULT * 100, 0.31), 3),
       marketDown: r.marketDown,
       rows: sortedRows,
       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 },

package/server/model/live.js

@@ -5,7 +5,8 @@ import { round, DAY, MSK, fmtBarMsk } from '../util.js';
 import { hub } from '../hub.js';
 import { latestBarTs } from '../data/moex.js';
 import { loadDataset, barsFromHours, BAR_MS, BAR_INTERVAL } from './dataset.js';
-import { predictAt, lastClosedIndex, isModelTrainedToday } from './forecast.js';
+import { predictAt, lastClosedIndex } from './forecast.js';
+import { symbolEdgeMult, QUARANTINE_DECAY, isStockQuarantined, canEnterIntraday, shouldExitBeforeNight } from './edge.js';
 import { computeReport, downsample } from './metrics.js';
 import { MODELS } from './models.js';
 import { blockingNews } from '../news/index.js';
@@ -261,8 +262,7 @@ class LiveEngine {
     try {
       const p = s.params;
       const now = Date.now();
-      const trainedToday = isModelTrainedToday(p, now);
-      const windowDays = trainedToday ? 7 : Math.ceil(p.modelTrainDays * 1.5 + 25);
+      const windowDays = Math.ceil(p.modelTrainDays * 1.5 + 25);
       const ds = await loadDataset({ fromTs: now - windowDays * DAY, tillTs: now, useMacro: p.modelUseMacro, useDividends: p.modelUseDividends !== false });
       s.lastSeenTs = latest;
       changed = true;
@@ -416,25 +416,30 @@ class LiveEngine {
       const exitRatio = autoAdapt ? 0.95 : Number(p.modelExitRatio ?? 0.5);
       const mktDown = p.modelMarketFilter === 'ma' && r.marketDown;
       const quarantined = new Set();
-      if (autoAdapt && s.trades.length >= 3) {
+      if (autoAdapt && s.trades.length >= 1) {
         const stMap = new Map();
         for (const t of s.trades) {
           // затухание прошлых штрафов с возрастом сделки (~15 торговых дней полураспада)
           const ageSteps = Math.max(0, (ts - (t.exitTs || ts)) / (stepBars * BAR_MS));
-          const wDecay = Math.pow(0.99, ageSteps);
+          const wDecay = Math.pow(QUARANTINE_DECAY, ageSteps);
           const cur = stMap.get(t.symbol) || { pnl: 0, cnt: 0 };
           cur.pnl = cur.pnl * 0.90 + (Number(t.pnlPct || 0) / 100) * wDecay;
           cur.cnt += wDecay;
           stMap.set(t.symbol, cur);
         }
-        for (const [sym, st] of stMap) if (st.cnt >= 3 && st.pnl < -0.012) quarantined.add(sym);
+        for (const [sym, st] of stMap) if (isStockQuarantined(st.cnt, st.pnl)) quarantined.add(sym);
       }
       for (const [sym, h] of s.held) {
+        if (autoAdapt && shouldExitBeforeNight(ts, h.entryTs, stepBars, BAR_INTERVAL)) {
+          closePos(sym, 'Закрытие перед ночным клирингом');
+          continue;
+        }
         const x = row.get(sym);
         const heldBars = Math.round((ts - h.entryTs) / BAR_MS);
-        const req = r.threshold * (autoAdapt && heldBars <= 2 * stepBars ? 0.35 : exitRatio);
+        const req = r.threshold * (autoAdapt && heldBars <= 2 * stepBars ? 0.35 : exitRatio) * symbolEdgeMult(sym);
         if (!(x && x.liquid && (h.side === 'short' ? x.expected < -req : x.expected > req))) closePos(sym);
       }
+      const timeOk = !autoAdapt || canEnterIntraday(ts, H, BAR_INTERVAL);
       const sideHeld = (side) => [...s.held].filter(([sym, h]) => h.side === side && !closing.has(sym));
       const nb = p.newsFilter ? blockingNews(6) : null;
       const take = (list, side, n) => {
@@ -445,13 +450,6 @@ class LiveEngine {
           if (quarantined.has(x.symbol)) { step.decisions.push({ action: 'skip', symbol: x.symbol, text: 'Пропущена: в карантине после серии убыточных сделок' }); continue; }
           const b = nb?.get(x.symbol)?.[side === 'buy' ? 'bad' : 'good'];
           if (b) { step.decisions.push({ action: 'skip', symbol: x.symbol, text: `Пропущена: ${side === 'buy' ? 'плохая' : 'хорошая'} новость — ${b.gist}` }); continue; }
-          if (autoK && out.length >= 1) {
-            const bestE = Math.abs(out[0].expected);
-            const curE = Math.abs(x.expected);
-            const relMin = out.length === 1 ? 0.62 : 0.78;
-            const absMin = out.length === 1 ? r.threshold * 1.15 : r.threshold * 1.45;
-            if (!(curE >= bestE * relMin && curE >= absMin)) break;
-          }
           out.push(x);
         }
         return out;
@@ -459,13 +457,13 @@ class LiveEngine {
       let entries;
       if (dir === 'long') {
         const free = K - s.held.size + s.pending.filter((o) => o.action === 'sell').length;
-        const candL = mktDown ? [] : r.rows.filter((x) => x.signal && !s.held.has(x.symbol)).sort((a, b) => b.expected - a.expected);
+        const candL = (mktDown || !timeOk) ? [] : r.rows.filter((x) => x.signal && !s.held.has(x.symbol) && !closing.has(x.symbol)).sort((a, b) => b.expected - a.expected);
         if (mktDown && free > 0) step.decisions.push({ action: 'skip', symbol: 'IMOEX', text: 'Новые покупки пропущены: индекс Мосбиржи падает' });
         entries = take(candL, 'buy', free).map((x) => [x, 'buy']);
       } else {
-        const open = (x) => !s.held.has(x.symbol) || closing.has(x.symbol);
-        const candL = mktDown ? [] : r.rows.filter((x) => x.signal && open(x)).sort((a, b) => b.expected - a.expected);
-        const candS = r.rows.filter((x) => x.shortSignal && open(x)).sort((a, b) => a.expected - b.expected);
+        const open = (x) => !s.held.has(x.symbol) && !closing.has(x.symbol);
+        const candL = (mktDown || !timeOk) ? [] : r.rows.filter((x) => x.signal && open(x)).sort((a, b) => b.expected - a.expected);
+        const candS = !timeOk ? [] : r.rows.filter((x) => x.shortSignal && open(x)).sort((a, b) => a.expected - b.expected);
         if (mktDown) step.decisions.push({ action: 'skip', symbol: 'IMOEX', text: 'Новые покупки пропущены: индекс Мосбиржи падает' });
         const nL = K - sideHeld('long').length;
         const nS = K - sideHeld('short').length;

package/server/model/research.js

@@ -9,7 +9,7 @@ import { ensureProfiles } from './profiles.js';
 import { spearman } from './linalg.js';
 import { listRuns, getRun, createRun, finishRun, saveTrade, saveRunExtra, kvGet } from '../db.js';
 import { strategyDefaults } from '../config.js';
-import { ENTRY_EDGE_MULT, symbolEdgeMult } from './edge.js';
+import { ENTRY_EDGE_MULT, symbolEdgeMult, QUARANTINE_DECAY, isStockQuarantined, canEnterIntraday, shouldExitBeforeNight } from './edge.js';
 import { buildDividendCalendar, nextDividendAt, dividendRules, DIV_TAX } from './dividends.js';
 
 const DAY = 86400000;
@@ -38,7 +38,8 @@ export function isMarketDown(ds, t) {
 // Версия обработки данных: при её смене прежние прогоны не считаются «такими же» (у старых её нет).
 // 8 — скорректированный спектр Марченко–Пастура (sigmaBulk) для 0 — Авто + динамическая концентрация слота (Conviction Sizing)
 // 9: исторический состав индекса (без ошибки выжившего), дивиденды префов, правила v0.5.x
-const DATA_VERSION = 9;
+// 10: запрет переноса внутридневных сделок через ночь, период полураспада карантина 15 дн., строгий 1-й эшелон
+const DATA_VERSION = 10;
 
 const AUTO_LOCKED = { modelHorizon: 2.5, modelMinEdge: 2.5, modelExitRatio: 0.95 };
 function reuseParamsKey(params) {
@@ -389,10 +390,11 @@ async function run(runId, p, state) {
     const countSide = (side) => [...held.values()].filter((h) => h.side === side).length;
     // Самообучение правил по прошлым закрытым сделкам (временный карантин «акций-убийц» с затуханием и авто-калибровка порога выхода)
     const stockPnl = new Float64Array(N), stockCnt = new Float64Array(N);
-    const stockAllowed = (i) => !autoAdapt || !(stockCnt[i] >= 3 && stockPnl[i] < -0.012);
+    const stockAllowed = (i) => !autoAdapt || !isStockQuarantined(stockCnt[i], stockPnl[i]);
     let curExitRatio = autoAdapt ? 0.95 : exitRatio;
     const stepBars = autoAdapt ? Math.max(3, Math.floor(H / 5)) : H;
     const maxSlotWeight = dir === 'long' ? Math.min(0.58, Math.max(1 / K, 1.8 / K)) : Math.min(0.75, 3.0 / (2 * K));
+    let closedThisBar = new Set();
 
     const closePos = (i, h, t, end, why, forcedExitPrice = null) => {
       const exitPrice = forcedExitPrice > 0 ? forcedExitPrice : exitPx(i, t);
@@ -417,6 +419,7 @@ async function run(runId, p, state) {
       stats.feesRub += fee + h.entryCost;
       trades.push(tradeRec(name, i, h, t, exitPrice, gross - fee - borrow - divLoss - h.entryCost, h.entryCost + fee, borrow, end, why));
       held.delete(i);
+      closedThisBar.add(i);
       if (autoAdapt) {
         const realGross = h.side === 'short' ? (1 - exitPrice / h.entryPrice) : (exitPrice / h.entryPrice - 1);
         const realNetPct = realGross - 2 * realCost;
@@ -427,13 +430,15 @@ async function run(runId, p, state) {
     for (let k = startIdx; k < testTs.length; k += stepBars) {
       const t = testTs[k];
       const tIn = Math.min(t + lag, T - 1), tOut = Math.min(t + lag + stepBars, T - 1);
+      closedThisBar = new Set();
       if (autoAdapt) {
-        for (let i = 0; i < N; i++) { stockPnl[i] *= 0.99; stockCnt[i] *= 0.99; }
+        for (let i = 0; i < N; i++) { stockPnl[i] *= QUARANTINE_DECAY; stockCnt[i] *= QUARANTINE_DECAY; }
       }
       const pr = preds[name].get(t);
       const sg = sigmaAt.get(t);
       const bear = isMarketDown(ds, t);
       const mktDown = mktFilter && bear;
+      const barTs = tsOf(t);
       // дивидендный предохранитель: закрываем позиции в последний день с правом на дивиденд и не входим перед отсечкой
       if (divGuard) {
         for (const [i, h] of [...held]) {
@@ -441,6 +446,16 @@ async function run(runId, p, state) {
           if (r && (h.side === 'long' ? r.exitLong : r.exitShort)) { closePos(i, h, tIn, false, 'Дивидендная отсечка'); stats.divExits++; }
         }
       }
+      // не переносим внутридневные позиции через ночь и выходные
+      if (autoAdapt) {
+        for (const [i, h] of [...held]) {
+          if (shouldExitBeforeNight(barTs, tsOf(h.entryT), stepBars, BAR_INTERVAL)) {
+            closePos(i, h, tIn, false, 'Закрытие перед ночным клирингом');
+          }
+        }
+      }
+      const timeOk = !autoAdapt || canEnterIntraday(barTs, H, BAR_INTERVAL);
+      const canOpenAt = (i) => timeOk && !held.has(i) && !closedThisBar.has(i) && stockAllowed(i) && canEnter(i, t);
       const okLong = (i) => !divRule(i, t)?.blockLong;
       const okShort = (i) => !divRule(i, t)?.blockShort;
       let order, entries;
@@ -458,8 +473,8 @@ async function run(runId, p, state) {
         }
         const needL = autoAdapt && bear ? need * 1.25 : need;
         const needS = autoAdapt ? (bear ? need * 0.90 : need * 1.25) : need;
-        const candL = mktDown ? [] : [...pr.keys()].filter((i) => !held.has(i) && stockAllowed(i) && canEnter(i, t) && okLong(i) && edge(i) > needL * symMult[i]).sort((a, b) => pr[b] - pr[a]);
-        const candS = [...pr.keys()].filter((i) => !held.has(i) && stockAllowed(i) && canEnter(i, t) && okShort(i) && edge(i) < -needS * symMult[i]).sort((a, b) => pr[a] - pr[b]);
+        const candL = (mktDown || !timeOk) ? [] : [...pr.keys()].filter((i) => canOpenAt(i) && okLong(i) && edge(i) > needL * symMult[i]).sort((a, b) => pr[b] - pr[a]);
+        const candS = !timeOk ? [] : [...pr.keys()].filter((i) => canOpenAt(i) && okShort(i) && edge(i) < -needS * symMult[i]).sort((a, b) => pr[a] - pr[b]);
         // Вытеснение слабой/остывшей позиции новым мощным лидером (Opportunity Rotation):
         // если капитал заперт в позиции с ослабевшим ожиданием (< 0.55 * exitNeed), а на текущей свече появился лидер в 2.4 раза сильнее порога,
         // освобождаем слот под лидера, чтобы ни одна фаза не застревала в слабых бумагах
@@ -500,11 +515,11 @@ async function run(runId, p, state) {
         }
         const free = K - held.size;
         const needL = autoAdapt && bear ? need * 1.25 : need;
-        const rawCand = mktDown ? [] : [...pr.keys()].filter((i) => !held.has(i) && stockAllowed(i) && canEnter(i, t) && okLong(i) && edge(i) > needL * symMult[i]).sort((a, b) => pr[b] - pr[a]);
+        const rawCand = (mktDown || !timeOk) ? [] : [...pr.keys()].filter((i) => canOpenAt(i) && okLong(i) && edge(i) > needL * symMult[i]).sort((a, b) => pr[b] - pr[a]);
         const cand = filterDynamicTopK(rawCand, edge, needL, Math.max(0, free));
         order = [...held.keys(), ...cand];
       } else {
-        const cand = mktDown ? [] : [...pr.keys()].filter((i) => stockAllowed(i) && pr[i] > 0 && canEnter(i, t)).sort((a, b) => pr[b] - pr[a]).slice(0, K);
+        const cand = (mktDown || !timeOk) ? [] : [...pr.keys()].filter((i) => !closedThisBar.has(i) && stockAllowed(i) && pr[i] > 0 && canEnter(i, t)).sort((a, b) => pr[b] - pr[a]).slice(0, K);
         order = cand;
         const next = new Set(order);
         for (const [i, h] of [...held]) if (!next.has(i)) closePos(i, h, tIn, false);
@@ -1028,10 +1043,11 @@ async function runStabilityLoop(targetId, runRow, st) {
       const borrowFee = (h, t) => h.alloc * (p.modelShortFeePct / 100) * ((tsOf(t) - tsOf(h.entryT)) / 3600000 / 24 / 365);
       const countSide = (side) => [...held.values()].filter((h) => h.side === side).length;
       const stockPnl = new Float64Array(N), stockCnt = new Float64Array(N);
-      const stockAllowed = (i) => !autoAdapt || !(stockCnt[i] >= 3 && stockPnl[i] < -0.012);
+      const stockAllowed = (i) => !autoAdapt || !isStockQuarantined(stockCnt[i], stockPnl[i]);
       const curExitRatio = autoAdapt ? 0.95 : exitRatio;
-      const stepBars = autoAdapt ? Math.max(2, Math.floor(H / 2)) : H;
+      const stepBars = autoAdapt ? Math.max(3, Math.floor(H / 5)) : H;
       const maxSlotWeight = dir === 'long' ? Math.min(0.45, Math.max(1 / K, 1.35 / K)) : Math.min(0.35, 1.4 / (2 * K));
+      let closedThisBar = new Set();
       const closePos = (i, h, t) => {
         const exitPrice = px(i, t);
         const gross = h.side === 'short' ? h.alloc * (1 - exitPrice / h.entryPrice) : h.alloc * (exitPrice / h.entryPrice - 1);
@@ -1040,6 +1056,7 @@ async function runStabilityLoop(targetId, runRow, st) {
         equity += gross - fee - borrow;
         trades.push({ pnl: gross - fee - borrow - h.entryCost, entryTs: tsOf(h.entryT), exitTs: tsOf(t) });
         held.delete(i);
+        closedThisBar.add(i);
         if (autoAdapt) {
           const realGross = h.side === 'short' ? (1 - exitPrice / h.entryPrice) : (exitPrice / h.entryPrice - 1);
           stockPnl[i] = stockPnl[i] * 0.90 + (realGross - 2 * realCost);
@@ -1048,12 +1065,21 @@ async function runStabilityLoop(targetId, runRow, st) {
       };
       for (let k = 0; k < testTs.length; k += stepBars) {
         const t = testTs[k], tIn = t + 1, tOut = Math.min(t + 1 + stepBars, T - 1);
+        closedThisBar = new Set();
         if (autoAdapt) {
-          for (let i = 0; i < N; i++) { stockPnl[i] *= 0.99; stockCnt[i] *= 0.99; }
+          for (let i = 0; i < N; i++) { stockPnl[i] *= QUARANTINE_DECAY; stockCnt[i] *= QUARANTINE_DECAY; }
         }
         const pr = preds.get(t), sg = sigmaAt.get(t);
         const bear = isMarketDown(ds, t);
         const mktDown = mktFilter && bear;
+        const barTs = tsOf(t);
+        if (autoAdapt) {
+          for (const [i, h] of [...held]) {
+            if (shouldExitBeforeNight(barTs, tsOf(h.entryT), stepBars, BAR_INTERVAL)) closePos(i, h, tIn);
+          }
+        }
+        const timeOk = !autoAdapt || canEnterIntraday(barTs, H, BAR_INTERVAL);
+        const canOpenAt = (i) => timeOk && !held.has(i) && !closedThisBar.has(i) && stockAllowed(i) && canEnter(i, t);
         const edge = (i) => pr[i] * sg[i] * Math.sqrt(H);
         const need = effMinEdge * 2 * realCost * ENTRY_EDGE_MULT, exitNeed = need * curExitRatio, earlyExitNeed = need * 0.35;
         let order, entries;
@@ -1065,8 +1091,8 @@ async function runStabilityLoop(targetId, runRow, st) {
           }
           const needL = autoAdapt && bear ? need * 1.25 : need;
           const needS = autoAdapt ? (bear ? need * 0.90 : need * 1.25) : need;
-          const candL = mktDown ? [] : [...pr.keys()].filter((i) => !held.has(i) && stockAllowed(i) && canEnter(i, t) && edge(i) > needL * symbolEdgeMult(tokens[i].symbol)).sort((a, b) => pr[b] - pr[a]);
-          const candS = [...pr.keys()].filter((i) => !held.has(i) && stockAllowed(i) && canEnter(i, t) && edge(i) < -needS * symbolEdgeMult(tokens[i].symbol)).sort((a, b) => pr[a] - pr[b]);
+          const candL = (mktDown || !timeOk) ? [] : [...pr.keys()].filter((i) => canOpenAt(i) && edge(i) > needL * symbolEdgeMult(tokens[i].symbol)).sort((a, b) => pr[b] - pr[a]);
+          const candS = !timeOk ? [] : [...pr.keys()].filter((i) => canOpenAt(i) && edge(i) < -needS * symbolEdgeMult(tokens[i].symbol)).sort((a, b) => pr[a] - pr[b]);
           const nL = K - countSide('long'), nS = K - countSide('short');
           entries = [...candL.slice(0, Math.max(0, nL)).map((i) => [i, 'long', edge(i)]), ...candS.slice(0, Math.max(0, nS)).map((i) => [i, 'short', edge(i)])];
         } else if (effMinEdge > 0) {
@@ -1076,10 +1102,10 @@ async function runStabilityLoop(targetId, runRow, st) {
             if (!(e > req) || !liquid(i, t)) closePos(i, h, tIn);
           }
           const needL = autoAdapt && bear ? need * 1.25 : need;
-          const cand = mktDown ? [] : [...pr.keys()].filter((i) => !held.has(i) && stockAllowed(i) && canEnter(i, t) && edge(i) > needL).sort((a, b) => pr[b] - pr[a]).slice(0, Math.max(0, K - held.size));
+          const cand = (mktDown || !timeOk) ? [] : [...pr.keys()].filter((i) => canOpenAt(i) && edge(i) > needL).sort((a, b) => pr[b] - pr[a]).slice(0, Math.max(0, K - held.size));
           order = [...held.keys(), ...cand];
         } else {
-          const cand = mktDown ? [] : [...pr.keys()].filter((i) => stockAllowed(i) && pr[i] > 0 && canEnter(i, t)).sort((a, b) => pr[b] - pr[a]).slice(0, K);
+          const cand = (mktDown || !timeOk) ? [] : [...pr.keys()].filter((i) => !closedThisBar.has(i) && stockAllowed(i) && pr[i] > 0 && canEnter(i, t)).sort((a, b) => pr[b] - pr[a]).slice(0, K);
           order = cand;
           const next = new Set(order);
           for (const [i, h] of [...held]) if (!next.has(i)) closePos(i, h, tIn);