neuroalpha 0.5.21 → 0.5.24

package/server/model/dataset.js

@@ -121,35 +121,37 @@ const MACRO = [
 
 const MCODES = ['F', 'G', 'H', 'J', 'K', 'M', 'N', 'Q', 'U', 'V', 'X', 'Z']; // месяцы в кодах фьючерсов
 
-// Список существующих контрактов BR с их периодами (кэш на сутки, чтобы не пробовать все коды каждый раз)
-async function brentContracts(fromTs, tillTs, signal) {
+// Список существующих контрактов BR с их периодами (кэш на 7 суток, чтобы не пробовать все коды каждый раз)
+async function brentContracts(fromTs, tillTs, signal, { localOnly = false } = {}) {
   const cached = kvGet('brContracts');
   let list = cached?.list;
-  if (!cached || Date.now() - cached.at > DAY) {
+  if ((!cached || Date.now() - cached.at > 7 * DAY) && !(localOnly && list?.length)) {
     list = [];
     const codes = [];
-    const y0 = new Date(fromTs - 40 * DAY).getUTCFullYear(), y1 = new Date(tillTs + 100 * DAY).getUTCFullYear();
+    const y0 = new Date(fromTs - 40 * DAY).getUTCFullYear(), y1 = new Date(tillTs + 50 * DAY).getUTCFullYear();
     for (let y = y0; y <= y1; y++) for (const m of MCODES) codes.push(`BR${m}${y % 10}`);
-    await pool(codes, 6, async (code) => {
+    await pool(codes, 4, async (code) => {
       try {
-        const rows = await ensureCandles(code, 24, fromTs - 35 * DAY, tillTs + 35 * DAY, { signal });
+        const rows = await ensureCandles(code, 24, fromTs - 35 * DAY, tillTs + 35 * DAY, { signal, localOnly });
         if (rows.length) list.push({ code, first: rows[0].ts, last: rows[rows.length - 1].ts });
       } catch { /* контракта нет */ }
     });
     list.sort((a, b) => a.first - b.first);
-    kvSet('brContracts', { at: Date.now(), list });
+    if (list.length) kvSet('brContracts', { at: Date.now(), list });
   }
-  return list.filter((c) => c.last >= fromTs && c.first <= tillTs);
+  return (list || []).filter((c) => c.last >= fromTs && c.first <= tillTs);
 }
 
 // Непрерывный ряд цены нефти: в каждый день — контракт с наибольшим оборотом дня,
 // на стыке контрактов цена продолжается без скачка (доходность стыка = 0)
-async function loadBrent(fromTs, tillTs, signal) {
-  const list = await brentContracts(fromTs, tillTs, signal);
+async function loadBrent(fromTs, tillTs, signal, { localOnly = false } = {}) {
+  const list = await brentContracts(fromTs, tillTs, signal, { localOnly });
   const raw = [];
+  const now = Date.now();
   await pool(list, 4, async (c) => {
     try {
-      const rows = await ensureCandles(c.code, BAR_INTERVAL, fromTs, tillTs, { signal });
+      const isExpired = c.last < now - 10 * DAY;
+      const rows = await ensureCandles(c.code, BAR_INTERVAL, fromTs, tillTs, { signal, localOnly: localOnly || isExpired });
       if (rows.length) raw.push(compact(rows));
     } catch { /* пропускаем */ }
   });
@@ -280,7 +282,7 @@ export async function loadDataset({ interval = BAR_INTERVAL, fromTs, tillTs, use
   if (useMacro) {
     try {
       onProgress({ symbol: 'BR', done: done, total: all.length });
-      raw.BR = await loadBrent(fromTs, tillTs, signal);
+      raw.BR = await loadBrent(fromTs, tillTs, signal, { localOnly });
     } catch (e) {
       if (signal?.aborted) throw new Error('Отменено');
       raw.BR = EMPTY();
@@ -397,6 +399,24 @@ export async function loadDataset({ interval = BAR_INTERVAL, fromTs, tillTs, use
     }
   }
   const mret = lret(mk.close);
+  // На самых свежих барах текущего дня (последние 2 часа), когда 10-минутные свечи акций уже получены в реальном времени из Т-Банка,
+  // а индекс IMOEX в бесплатном MOEX ISS ещё отстаёт на 20 минут, достраиваем mret и mclose по средневзвешенной доходности акций индекса:
+  for (let i = Math.max(1, T - 12); i < T; i++) {
+    if (!mk.has[i] && mk.close[i - 1] > 0) {
+      let wSum = 0, rSum = 0;
+      for (const tk of tokens) {
+        if (tk.has[i] && (!tk.inIndex || tk.inIndex[i])) {
+          const w = tk.weight > 0 ? tk.weight : 1;
+          rSum += w * tk.ret[i];
+          wSum += w;
+        }
+      }
+      if (wSum > 0) {
+        mret[i] = rSum / wSum;
+        mk.close[i] = mk.close[i - 1] * Math.exp(mret[i]);
+      }
+    }
+  }
   // макро-ряды: лог-доходности с переносом цены (вне торгов — 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;

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';
@@ -17,9 +17,35 @@ const trainedModelCache = new Map(); // fitKey -> { dayMsk, trainedAt, fTrain, f
 let baseState = null; // { key, trainedAt, ds, last, r, snap, prevExpMap, prevRankMap, lastTickResult, lastTickAt }
 const inflight = new Map();
 
+// Синхронная живая доходность индекса относительно закрытия свечи 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 +57,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 +206,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 +305,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 +314,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,
   };
@@ -315,27 +340,66 @@ function buildPredictionRows(ds, p, idx, f, u, fitted, chosen, H, effMinEdge, au
   const avgInv = nInv ? sInv / nInv : 0;
   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 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) => {
-    const exp = preds[chosen][i] * f.sigma[i] * Math.sqrt(H);
+    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;
+    const ex = (explain || isOverheated) ? explainAttention(fitted.attention, f, u, i) : null;
+    let selfRaw = ex ? ex.self * f.sigma[i] * Math.sqrt(H) : 0;
+    if (isOverheated && selfRaw > 0) {
+      // Если акция уже взлетела за день/3 дня (памп) и начала откатываться вниз, линейный «возврат к среднему»
+      // ошибочно трактует начало обвала с пика как «перепроданность к отскоку вверх» — гасим ложный отскок вверх, не переворачивая в искусственный шорт:
+      if (exp > 0) exp = Math.max(0, exp - selfRaw);
+      selfRaw = 0;
+    }
+    const buyBlockedByOverheat = (exp > 0 && (excess1d >= 0.06 || excess3d >= 0.12))
+      ? round((excess1d >= 0.06 ? excess1d : excess3d) * 100, 1)
+      : 0;
     // Индивидуальный множитель порога каждой акции по её фактическому обороту в рублях и волатильности свечи:
     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);
-    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,
@@ -352,6 +416,7 @@ function buildPredictionRows(ds, p, idx, f, u, fitted, chosen, H, effMinEdge, au
       signal: inIdx && tk.liq[idx] >= LIQ_MIN && exp > symNeedL && liveBuyOk,
       ...(shortAllowed !== null ? { shortAllowed } : {}),
       ...(buyBlockedByDip ? { buyBlockedByDip: true } : {}),
+      ...(buyBlockedByOverheat ? { buyBlockedByOverheat } : {}),
       ...(inIdx ? {} : { inIndex: false }),
     };
     if (dir !== 'long') {
@@ -359,10 +424,9 @@ function buildPredictionRows(ds, p, idx, f, u, fitted, chosen, H, effMinEdge, au
       if (shortBlockedByBroker) row.shortBlockedByBroker = true;
       if (shortBlockedBySqueeze) row.shortBlockedBySqueeze = true;
     }
-    if (explain) {
-      const ex = explainAttention(fitted.attention, f, u, i);
+    if (explain && ex) {
       row.influences = ex.neighbors.map((x) => ({ symbol: ds.tokens[x.i].symbol, contribPct: round(x.contrib * f.sigma[i] * Math.sqrt(H) * 100, 3), closeness: round(f.cos[i][x.i], 2) }));
-      row.selfPct = round(ex.self * f.sigma[i] * Math.sqrt(H) * 100, 3);
+      row.selfPct = round(selfRaw * 100, 3);
     }
     return row;
   });

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 } from './edge.js';
+import { 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';
@@ -434,9 +434,14 @@ class LiveEngine {
           closePos(sym, 'Закрытие перед ночным клирингом');
           continue;
         }
+        const tkIdx = bySym.get(sym);
+        if (autoAdapt && tkIdx !== undefined && isRegimeShocked(ds, tkIdx, idx, h.side || 'long')) {
+          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) * symbolEdgeMult(sym);
+        const req = r.threshold * (autoAdapt && heldBars <= 2 * stepBars ? 0.35 : exitRatio) * (x?.edgeMult || 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);
@@ -454,16 +459,33 @@ class LiveEngine {
         }
         return out;
       };
+      const open = (x) => !s.held.has(x.symbol) && !closing.has(x.symbol);
+      const candL = (mktDown || !timeOk) ? [] : r.rows.filter((x) => x.signal && open(x)).sort((a, b) => b.expected - a.expected);
+      const candS = (dir === 'long' || !timeOk) ? [] : r.rows.filter((x) => x.shortSignal && open(x)).sort((a, b) => a.expected - b.expected);
+      const usedNow = [...s.held.entries()].filter(([sym]) => !closing.has(sym)).reduce((sum, [, h]) => sum + h.alloc, 0);
+      if (autoAdapt && usedNow > s.equity * 0.65 && (candL.length > 0 || candS.length > 0)) {
+        const bestNewEdge = Math.max(candL.length ? candL[0].expected : 0, candS.length ? Math.abs(candS[0].expected) : 0);
+        const exitNeed = r.threshold * exitRatio;
+        if (bestNewEdge >= r.threshold * 2.2) {
+          let weakestSym = null, weakestE = Infinity;
+          for (const [sym, h] of s.held) {
+            if (closing.has(sym)) continue;
+            const xCur = row.get(sym);
+            const curSignedE = xCur ? (h.side === 'short' ? -xCur.expected : xCur.expected) : 0;
+            if (curSignedE < exitNeed * 0.60 && curSignedE < weakestE && bestNewEdge > Math.max(r.threshold, curSignedE) * 2.4) {
+              weakestE = curSignedE;
+              weakestSym = sym;
+            }
+          }
+          if (weakestSym) closePos(weakestSym, 'Ротация в более сильного лидера');
+        }
+      }
       let entries;
       if (dir === 'long') {
         const free = K - s.held.size + s.pending.filter((o) => o.action === 'sell').length;
-        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 || !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;
@@ -472,7 +494,7 @@ class LiveEngine {
       for (const [x, action] of entries) {
         const infl = x.influences?.length ? x.influences.map((n) => n.symbol).join(', ') : '';
         const exp = `${x.expectedPct > 0 ? '+' : ''}${x.expectedPct}`;
-        const why = `Стратегия «${MODELS[r.chosen].label}»: ${action === 'short' ? 'продажа: ' : ''}ожидание ${exp}% за ${round(p.modelHorizon, 2)} ч относительно рынка${infl ? `; влияют ${infl}` : ''}`;
+        const why = `Стратегия «${MODELS[r.chosen].label}»: ${action === 'short' ? 'продажа: ' : ''}ожидание ${exp}% за ${round(effHorizon, 2)} ч относительно рынка${infl ? `; влияют ${infl}` : ''}`;
         s.pending.push({ action, symbol: x.symbol, reason: why, expectedPct: x.expectedPct, weight: x.weight ?? 1 });
         step.decisions.push({ action, symbol: symName(x), text: `${action === 'short' ? 'продать без покупки' : 'купить'} — ожидание ${exp}%${infl ? `, влияют ${infl}` : ''}` });
       }

package/server/model/models.js

@@ -262,7 +262,7 @@ export function buildFold(ds, { trainStart, testStart, testEnd, H, embedDim, tex
           out[u] = a >= 0 ? sum / Math.sqrt(sc.len) : 0;
         }
       });
-      list.push({ id: m.id, label: m.label, b, zs });
+      list.push({ id: m.id, label: m.label, b, msig, zs });
     }
     if (list.length) macro = { list };
   }
@@ -505,15 +505,37 @@ export const modelNames = () => Object.keys(MODELS);
 // Объяснение прогноза «внимания»: вклад каждого соседа в прогноз акции j
 export function explainAttention(m, f, u, j, top = 3) {
   const N = f.N;
+  const k = u * N + j;
   const contrib = new Float64Array(N);
-  const wAtt = m.inertiaCoef ? 0.50 : 1, wIn = m.inertiaCoef ? 0.50 : 0;
+  let sAtt = 0;
   HEADS.forEach((h, hi) => {
     const A = m.As[BETAS.findIndex((b) => b.v === h.beta)];
     const X = f.X[h.kind === 'price' ? 0 : 1][h.scale];
-    for (let i = 0; i < N; i++) contrib[i] += wAtt * m.coef[hi] * A[j * N + i] * X[u * N + i];
+    for (let i = 0; i < N; i++) {
+      const c = m.coef[hi] * A[j * N + i] * X[u * N + i];
+      contrib[i] += c;
+      sAtt += c;
+    }
   });
-  let self = 0;
-  for (let q = 0; q < 3; q++) self += (wAtt * m.coef[HEADS.length + q] + wIn * (m.inertiaCoef?.[q] || 0)) * f.X[0][q][u * N + j];
+  let selfAtt = 0, sIn = 0;
+  for (let q = 0; q < 3; q++) {
+    const xq = f.X[0][q][k];
+    selfAtt += m.coef[HEADS.length + q] * xq;
+    if (m.inertiaCoef) sIn += (m.inertiaCoef[q] || 0) * xq;
+  }
+  sAtt += selfAtt;
+  const ML = f.macro ? f.macro.list : [];
+  for (let mi = 0; mi < ML.length; mi++) {
+    let zz = 0;
+    const zs = ML[mi].zs;
+    for (let q = 0; q < 3; q++) zz += m.coef[HEADS.length + 3 + mi * 3 + q] * zs[q * f.W + u];
+    sAtt += ML[mi].b[j] * zz;
+  }
+  const conflictScale = (m.inertiaCoef && sAtt * sIn < 0) ? 0.5 : 1;
+  const wAtt = (m.inertiaCoef ? 0.50 : 1) * conflictScale;
+  const wIn = (m.inertiaCoef ? 0.50 : 0) * conflictScale;
+  for (let i = 0; i < N; i++) contrib[i] *= wAtt;
+  const self = wAtt * selfAtt + wIn * sIn;
   const idx = [...contrib.keys()].filter((i) => i !== j).sort((a, b) => Math.abs(contrib[b]) - Math.abs(contrib[a])).slice(0, top);
   return { neighbors: idx.map((i) => ({ i, contrib: contrib[i] })), self };
 }