neuroalpha 0.5.22 → 0.5.24

package/package.json

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

package/server/brokers/index.js

@@ -118,15 +118,15 @@ export function roundToStep(price, minStep = 0.01, decimals = 2) {
   return Number(v.toFixed(Math.max(0, Math.min(6, decimals))));
 }
 
-// Снайперский расчёт лимитной цены (1-tick Limit):
-// отталкивается от живой секундной цены basePx и сдвигает её ровно на 1 минимальный шаг цены (minStep),
-// но не более заданного offsetPct, чтобы не переплачивать маркетмейкерам за пересечение спреда!
+// Снайперский расчёт лимитной цены:
+// отталкивается от живой секундной цены basePx и задаёт защитный предел исполнения по offsetPct (но не менее 1 минимального шага цены minStep),
+// а в момент фактической отправки в стакан sendOrderToBroker дополнительно подстраивает цену под лучший bid/ask живого стакана 1×1!
 export function sniperLimitPrice(basePx, dir, offsetPct = 0.02, sp = { minStep: 0.01, decimals: 2 }) {
   const step = sp.minStep > 0 ? sp.minStep : 0.01;
-  const maxOffRatio = Math.max(0, Math.min(0.0005, (Number(offsetPct) || 0.02) / 100));
+  const maxOffRatio = Math.max(0, Math.min(0.001, (Number(offsetPct) || 0.02) / 100));
   const byPct = basePx * (1 + dir * maxOffRatio);
   const byOneTick = basePx + dir * step;
-  const rawLimit = dir > 0 ? Math.min(byPct, byOneTick) : Math.max(byPct, byOneTick);
+  const rawLimit = dir > 0 ? Math.max(byPct, byOneTick) : Math.min(byPct, byOneTick);
   return roundToStep(rawLimit, step, sp.decimals);
 }
 
@@ -498,6 +498,7 @@ export function saveBrokerAccount(input = {}) {
     skipEdgeMinutes: input.skipEdgeMinutes !== undefined ? Boolean(input.skipEdgeMinutes) : (prev.skipEdgeMinutes ?? true),
     autoSchedule: input.autoSchedule !== undefined ? Boolean(input.autoSchedule) : (prev.autoSchedule ?? true),
     lastScheduledBarTs: strategyOrCapChanged ? 0 : (prev.lastScheduledBarTs || 0),
+    lastFullStepWallTs: strategyOrCapChanged ? 0 : (prev.lastFullStepWallTs || 0),
     // дневной стоп при сохранении настроек не снимается — только отдельным действием «Снять стоп до конца дня»
     haltedReason: prev.haltedReason || null,
     ddOverrideDay: prev.ddOverrideDay || null,
@@ -710,8 +711,9 @@ async function resolveTbankMetaMap(base, headers, keys = []) {
 // Возвращает живые секундные цены акций из T-Invest API (GetLastPrices, 0 секунд задержки), если у любого пользователя подключён счёт Т-Банка
 export async function fetchTbankRealtimePrices() {
   try {
-    // только токен владельца текущих данных — токены других пользователей не используются никогда
-    const tbAcc = loadRawAccounts().find((a) => a.broker === 'tbank' && a.token);
+    // только токен владельца текущих данных — токены других пользователей не используются никогда (предпочитаем боевой контур песочнице)
+    const rawAccs = loadRawAccounts();
+    const tbAcc = rawAccs.find((a) => a.broker === 'tbank' && a.token && !a.sandbox) || rawAccs.find((a) => a.broker === 'tbank' && a.token);
     if (!tbAcc?.token) return null;
     await ensureTbankShortableMap(tbAcc);
     const uidMap = kvGet('tbankShortableMap')?.uidMap || {};
@@ -744,7 +746,8 @@ export async function fetchTbankRealtimePrices() {
 // Возвращает свежие 10-минутные свечи акции из T-Invest API (GetCandles, 0 секунд задержки, без 20-минутного отставания бесплатного MOEX ISS)
 export async function fetchTbankCandles(symbol, fromTs, tillTs = Date.now(), { includeIncomplete = false } = {}) {
   try {
-    const tbAcc = loadRawAccounts().find((a) => a.broker === 'tbank' && a.token);
+    const rawAccs = loadRawAccounts();
+    const tbAcc = rawAccs.find((a) => a.broker === 'tbank' && a.token && !a.sandbox) || rawAccs.find((a) => a.broker === 'tbank' && a.token);
     if (!tbAcc?.token) return null;
     await ensureTbankShortableMap(tbAcc);
     const shortMap = kvGet('tbankShortableMap');
@@ -1771,7 +1774,7 @@ export async function prepareBrokerOrders(id, { onlyEntries = false } = {}) {
     if (aQty > 0) {
       const lots = Math.floor(aQty / sp.lotSize);
       const curGainPct = avgPx > 0 ? ((curPx - avgPx) / avgPx) * 100 : 0;
-      const hitHardStopLoss = curGainPct <= -5.0;
+      const hitHardStopLoss = curGainPct <= -5.0 || Boolean(autoAdapt && r.buyBlockedByDip);
       const keepByForecast = onlyEntries ? (r.liquid && r.expectedPct > -needPct) : (r.liquid && r.expectedPct > curExitThr);
       const dg = divGuardOf(sym, curPx);
       const divExit = Boolean(dg?.exitLong);
@@ -1796,7 +1799,7 @@ export async function prepareBrokerOrders(id, { onlyEntries = false } = {}) {
     } else if (aQty < 0) {
       const lots = Math.floor(Math.abs(aQty) / sp.lotSize);
       const curGainPct = avgPx > 0 ? ((avgPx - curPx) / avgPx) * 100 : 0;
-      const hitHardStopLoss = curGainPct <= -4.5;
+      const hitHardStopLoss = curGainPct <= -4.5 || Boolean(autoAdapt && r.shortBlockedBySqueeze);
       const keepByForecast = onlyEntries ? (dir !== 'long' && r.liquid && r.expectedPct < needPct) : (dir !== 'long' && r.liquid && r.expectedPct < -curExitThr);
       const dg = divGuardOf(sym, curPx);
       const divExit = Boolean(dg?.exitShort);
@@ -1899,7 +1902,11 @@ export async function prepareBrokerOrders(id, { onlyEntries = false } = {}) {
     }
   }
   const freedRub = orders.filter((o) => o.action === 'sell').reduce((s, o) => s + o.amountRub, 0);
-  const cashLimit = acc.lastSync?.cashRub !== undefined ? acc.lastSync.cashRub + freedRub : budget;
+  const coverSpentRub = orders.filter((o) => o.action === 'cover').reduce((s, o) => s + o.amountRub, 0);
+  const openShortRub = [...heldMap.values()]
+    .filter((p) => rowMap.has(p.symbol) && algoQtyOf(p.symbol, p.qty) < 0 && !closing.has(p.symbol))
+    .reduce((s, p) => s + Math.abs(algoQtyOf(p.symbol, p.qty) * p.price), 0);
+  const cashLimit = acc.lastSync?.cashRub !== undefined ? acc.lastSync.cashRub + freedRub - coverSpentRub - openShortRub : budget;
   let availRub = Math.min(Math.max(0, budget * 0.99 - usedRub), Math.max(0, cashLimit));
 
     // 2) вход в лучшие сигналы (с учётом лотности Мосбиржи, свободного лимита и адаптивного отбора числа акций Dynamic Top-K)
@@ -2111,9 +2118,13 @@ export async function prepareBrokerOrders(id, { onlyEntries = false } = {}) {
     return brokersState();
   }
 
+  const batchNowTs = Date.now();
+  if (!onlyEntries) {
+    acc.lastFullStepWallTs = batchNowTs;
+  }
   acc.pendingBatch = {
-    id: `batch_${Date.now()}`,
-    createdAt: Date.now(),
+    id: `batch_${batchNowTs}`,
+    createdAt: batchNowTs,
     bar: fc.bar,
     budgetRub: budget,
     availRub: round(availRub, 0),
@@ -2190,19 +2201,35 @@ async function sendOrderToBroker(acc, ord) {
       if (bestBid > 0 && bestAsk >= bestBid) {
         const midPx = (bestBid + bestAsk) / 2;
         const spreadPct = ((bestAsk - bestBid) / midPx) * 100;
+        const step = sp.minStep || 0.01;
         const maxSpreadPct = ord.symbol === 'LQDT' ? 0.15 : Math.max(0.28, Math.abs(Number(ord.expectedPct) || 0.6) * 0.45);
         if (isEntry && spreadPct > maxSpreadPct) {
           logBrokerEvent(acc, 'spread_skip', `${ord.symbol}: спред ${round(spreadPct, 2)}% > порога ${round(maxSpreadPct, 2)}% (ожидание ${ord.expectedPct || 0}%)`);
           throw Object.assign(new Error(`Широкий спред в стакане ${ord.symbol} (${round(spreadPct, 2)}% > ${round(maxSpreadPct, 2)}%) — вход пропущен, чтобы не потерять на спреде`), { definitive: true });
         }
-        if (isEntry && ord.symbol !== 'LQDT') {
-          // Пассивный вход на середине спреда (или на 1 шаг внутри спреда от своей стороны), но не хуже расчётной limitPrice
-          const passivePx = isBuy
-            ? Math.min(finalLimitPx, roundToStep(Math.min(midPx, bestBid + (sp.minStep || 0.01)), sp.minStep, sp.decimals))
-            : Math.max(finalLimitPx, roundToStep(Math.max(midPx, bestAsk - (sp.minStep || 0.01)), sp.minStep, sp.decimals));
-          if (passivePx > 0) finalLimitPx = passivePx;
-        } else if (ord.symbol === 'LQDT') {
+        if (ord.symbol === 'LQDT') {
           finalLimitPx = roundToStep(isBuy ? bestAsk : bestBid, sp.minStep || 0.001, sp.decimals ?? 3);
+        } else if (!isEntry) {
+          // Закрывающие заявки (sell / cover): при нормальном спреде (<= 0,8%) ставим цену в лучшую встречную заявку стакана (bestBid / bestAsk),
+          // чтобы выход исполнялся мгновенно (за < 1 сек) и гарантированно освобождал кэш перед открытием новых позиций!
+          if (spreadPct <= 0.80) {
+            const mktExitPx = roundToStep(isBuy ? bestAsk : bestBid, step, sp.decimals);
+            if (mktExitPx > 0) finalLimitPx = isBuy ? Math.max(finalLimitPx, mktExitPx) : Math.min(finalLimitPx, mktExitPx);
+          }
+        } else {
+          // Входящие заявки (buy / short):
+          // • при узком спреде (<= 0,06% или <= 2 шагов цены — голубые фишки 1-го эшелона) берём по лучшей встречной цене в пределах защитного лимита finalLimitPx, чтобы не упускать движение;
+          // • при более широком спреде (2–3 эшелон) встаём на середине спреда (или на 1 шаг внутри спреда), не переплачивая маркетмейкеру!
+          const tightSpread = spreadPct <= 0.06 || (bestAsk - bestBid) <= 2.1 * step;
+          if (tightSpread) {
+            const activePx = roundToStep(isBuy ? bestAsk : bestBid, step, sp.decimals);
+            if (activePx > 0) finalLimitPx = isBuy ? Math.min(finalLimitPx, activePx) : Math.max(finalLimitPx, activePx);
+          } else {
+            const passivePx = isBuy
+              ? Math.min(finalLimitPx, roundToStep(Math.min(midPx, bestBid + step), step, sp.decimals))
+              : Math.max(finalLimitPx, roundToStep(Math.max(midPx, bestAsk - step), step, sp.decimals));
+            if (passivePx > 0) finalLimitPx = passivePx;
+          }
         }
       }
     }
@@ -2751,14 +2778,21 @@ async function tickBrokerSchedule() {
           // Внутричасовой перехват H/5 (каждые 30 мин) активен в режимах VIP и Хозяин; на тарифах Инвестор и Профи шаг равен полному горизонту H
           const stepBars = ((plan.allowVipBoost || plan.isOwner) && autoAdapt) ? Math.max(3, Math.floor(H / 5)) : H;
           const minStepMs = stepBars * BAR_MS;
-          const lastRunWallTs = acc.pendingBatch?.executedAt || acc.pendingBatch?.createdAt || 0;
+          const lastFullWallTs = acc.lastFullStepWallTs || 0;
+          const lastAnyWallTs = acc.pendingBatch?.executedAt || acc.pendingBatch?.createdAt || 0;
+          const hasOpenAlgoPos = (acc.lastSync?.positions || []).some((p) => p.qty && p.symbol !== 'LQDT' && p.symbol !== 'TMON@' && p.symbol !== 'TMON' && p.symbol !== 'SBMM' && algoQtyFor(acc, p.symbol, p.qty) !== 0);
+          const nowTs = Date.now();
+          const nightExitDue = autoAdapt && hasOpenAlgoPos && shouldExitBeforeNight(nowTs, 0, 3, BAR_INTERVAL) && (!lastFullWallTs || !shouldExitBeforeNight(lastFullWallTs, 0, 3, BAR_INTERVAL) || (nowTs - lastFullWallTs >= 15 * 60000));
           const dueFullStep = Boolean(
-            latest &&
-            (latest - (acc.lastScheduledBarTs || 0) >= minStepMs) &&
-            !(lastRunWallTs > 0 && Date.now() - lastRunWallTs < minStepMs - 5 * 60000),
+            nightExitDue || (
+              latest &&
+              (latest - (acc.lastScheduledBarTs || 0) >= minStepMs) &&
+              !(lastFullWallTs > 0 && nowTs - lastFullWallTs < minStepMs - 5 * 60000)
+            ),
           );
           if (dueFullStep) {
-            acc.lastScheduledBarTs = latest;
+            acc.lastScheduledBarTs = latest || acc.lastScheduledBarTs || nowTs;
+            acc.lastFullStepWallTs = nowTs;
             saveRawAccounts(list);
             if (acc.token) await syncBrokerAccount(acc.id).catch(() => {});
             await prepareBrokerOrders(acc.id).catch(() => {});
@@ -2769,7 +2803,7 @@ async function tickBrokerSchedule() {
           const lqdtBaseQty = Number(acc.baselineQty?.LQDT || 0);
           const lqdtAvailRub = lqdtPos ? Math.max(0, (lqdtPos.qty - (acc.legacyMode === 'takeover' ? 0 : Math.max(0, lqdtBaseQty))) * (lqdtPos.price || 0)) : 0;
           const freeCashRub = Number(acc.lastSync?.cashRub ?? acc.maxCapitalRub ?? 0) + lqdtAvailRub;
-          if (acc.mode === 'auto' && acc.token && freeCashRub >= 15000 && Date.now() - lastRunWallTs >= 20000) {
+          if (acc.mode === 'auto' && acc.token && freeCashRub >= 15000 && nowTs - Math.max(lastFullWallTs, lastAnyWallTs) >= 20000) {
             await prepareBrokerOrders(acc.id, { onlyEntries: true }).catch(() => {});
           }
         }
@@ -3056,6 +3090,9 @@ async function checkIntradayProfitLock(accId) {
   for (const ord of lockOrders) {
     logBrokerEvent(acc, 'protective_stop', `${ord.reason}: ${ord.action} ${ord.symbol} ${ord.lots} л.`);
     try {
+      if (acc.brokerStopBySymbol?.[ord.symbol]) {
+        await closeBrokerStopBeforeExit(acc, ord.symbol);
+      }
       const r = await sendOrderToBroker(acc, ord);
       results.push({ symbol: ord.symbol, ok: true, orderId: r.orderId });
       delete acc.entryTsBySymbol[ord.symbol];
@@ -3068,10 +3105,10 @@ async function checkIntradayProfitLock(accId) {
   }
   acc.pendingBatch = {
     ...(acc.pendingBatch || {}),
-    id: `batch_tp_${execNowTs}`,
+    id: `batch_stop_${execNowTs}`,
     createdAt: execNowTs,
     executedAt: execNowTs,
-    bar: `${fmtBarMsk(execNowTs)} (Take-Profit)`,
+    bar: `${fmtBarMsk(execNowTs)} (Защитный стоп)`,
     orders: lockOrders,
     status: results.every((r) => r.ok) ? 'executed' : 'partial',
     results,

package/server/data/moex.js

@@ -1,5 +1,5 @@
 // Copyright (c) 2026 Roman A. Perepelkin. All rights reserved. Proprietary software.
-import { saveCandles, loadCandles, candleRange, kvGet, kvSet } from '../db.js';
+import { saveCandles, loadCandles, candleRange, candleMaxBetween, kvGet, kvSet } from '../db.js';
 import { DAY, MSK } from '../util.js';
 
 let realtimeCandleFetcher = null;
@@ -80,9 +80,11 @@ export async function ensureCandles(symbol, interval, fromTs, tillTs, { signal,
   const now = Date.now();
   const pKey = `candProbe:${symbol}:${interval}`;
   const probe = kvGet(pKey);
-  // Защита от ложных меток candProbe v1 (где из-за старого условия first.ts <= range.min записывалось fromTs без скачивания):
-  // валидной считаем только метку v2 (или если range.min реально доходит до fromTs)
-  const covered = probe && probe.v === 2 && probe.fromTs <= fromTs + 5 * DAY;
+  // Метка v3: fromTs — до какой даты левый край подтверждён (свечи есть в базе или на бирже раньше их нет).
+  // Метки v1/v2 не доверяем: старое условие range.n < 500 записывало fromTs без скачивания, и у бумаг с накопленной
+  // историей левый край (например, 2022 год) так и не догружался — датасет зависел от того, когда создана база.
+  const verifiedFrom = probe?.v === 3 ? probe.fromTs : Infinity;
+  let leftFill = probe?.v === 3 ? probe.leftFill || null : null;
 
   if (!range.n) {
     // В базе ещё нет свечей этой бумаги — качаем весь запрошенный диапазон один раз
@@ -90,28 +92,35 @@ export async function ensureCandles(symbol, interval, fromTs, tillTs, { signal,
       signal,
       onBatch: (page) => saveCandles(symbol, interval, page),
     });
-    kvSet(pKey, { v: 2, fromTs });
+    kvSet(pKey, { v: 3, fromTs });
     lastTailCheckAt.set(`${symbol}:${interval}`, now);
     return loadCandles(symbol, interval, fromTs, tillTs);
   }
 
-  // 1) ЛЕВЫЙ КРАЙ:
-  // Если в локальной базе SQLite уже накоплена история (range.n >= 500 свечей), НИКОГДА не лезем на биржу докачивать левый край
-  // при смене «Окна обучения» или «Периода исследования» — работаем мгновенно по уже сохранённым в SQLite историческим свечам!
-  if (!covered && range.n < 500 && range.min > fromTs + 5 * DAY) {
+  // 1) ЛЕВЫЙ КРАЙ: история докачивается один раз, дальше работаем только по SQLite.
+  // Докачка идёт от ранних свечей к поздним; пока она не завершена, в метке хранится leftFill,
+  // чтобы после обрыва продолжить с последней сохранённой свечи, а не оставить дыру в середине истории.
+  let probeFrom = Math.min(verifiedFrom, range.min);
+  if (!leftFill && range.min > fromTs + 5 * DAY && verifiedFrom > fromTs + 5 * DAY) {
     const first = (await fetchCandles(symbol, interval, tsToDate(fromTs), null, { signal, pages: 1 }))[0];
     if (!first || first.ts >= range.min - DAY) {
-      kvSet(pKey, { v: 2, fromTs: Math.min(fromTs, probe?.v === 2 ? probe.fromTs : fromTs) });
+      probeFrom = fromTs; // раньше имеющихся свечей на бирже истории нет
     } else {
-      const leftTill = tsToDate(range.min + DAY);
-      await fetchCandles(symbol, interval, tsToDate(fromTs), leftTill, {
-        signal,
-        onBatch: (page) => saveCandles(symbol, interval, page),
-      });
-      kvSet(pKey, { v: 2, fromTs: Math.min(fromTs, probe?.v === 2 ? probe.fromTs : fromTs) });
+      leftFill = { from: fromTs, till: range.min };
+      kvSet(pKey, { v: 3, fromTs: probeFrom, leftFill, tailCheckedAt: probe?.tailCheckedAt });
     }
-  } else if (!probe || probe.v !== 2 || probe.fromTs > fromTs) {
-    kvSet(pKey, { v: 2, fromTs: Math.min(fromTs, range.min) });
+  }
+  if (leftFill) {
+    const resumeTs = candleMaxBetween(symbol, interval, leftFill.from, leftFill.till - 1) ?? leftFill.from;
+    await fetchCandles(symbol, interval, tsToDate(resumeTs), tsToDate(leftFill.till + DAY), {
+      signal,
+      onBatch: (page) => saveCandles(symbol, interval, page),
+    });
+    probeFrom = Math.min(probeFrom, leftFill.from);
+    leftFill = null;
+  }
+  if (probe?.v !== 3 || probe.fromTs !== probeFrom || probe.leftFill) {
+    kvSet(pKey, { v: 3, fromTs: probeFrom, tailCheckedAt: probe?.tailCheckedAt });
   }
 
   // 2) ПРАВЫЙ КРАЙ (свежие свечи текущего дня):
@@ -137,7 +146,7 @@ export async function ensureCandles(symbol, interval, fromTs, tillTs, { signal,
     // В первую очередь берём свежие 10-минутные свечи из T-Invest API (GetCandles — 0 сек задержки против 20–25 мин у бесплатного MOEX ISS)
     let filledByTbank = false;
     if (isTbankEligible) {
-      const tbRows = await realtimeCandleFetcher(symbol, Math.max(range.max - 20 * 60000, now - 2 * DAY), Math.min(tillTs, now)).catch(() => null);
+      const tbRows = await realtimeCandleFetcher(symbol, Math.max(range.max - 20 * 60000, now - 3 * DAY + 120000), Math.min(tillTs, now)).catch(() => null);
       if (tbRows?.length) {
         saveCandles(symbol, interval, tbRows);
         filledByTbank = true;
@@ -149,7 +158,7 @@ export async function ensureCandles(symbol, interval, fromTs, tillTs, { signal,
         onBatch: (page) => saveCandles(symbol, interval, page),
       });
     }
-    kvSet(pKey, { v: 2, fromTs: Math.min(fromTs, probe?.v === 2 ? probe.fromTs : range.min), tailCheckedAt: now });
+    kvSet(pKey, { v: 3, fromTs: probeFrom, tailCheckedAt: now });
   }
 
   return loadCandles(symbol, interval, fromTs, tillTs);

package/server/db.js

@@ -343,6 +343,10 @@ export function candleRange(symbol, interval) {
   return db.prepare('SELECT MIN(ts) AS min, MAX(ts) AS max, COUNT(*) AS n FROM candles WHERE symbol = ? AND interval = ?').get(symbol, interval);
 }
 
+export function candleMaxBetween(symbol, interval, fromTs, tillTs) {
+  return db.prepare('SELECT MAX(ts) AS max FROM candles WHERE symbol = ? AND interval = ? AND ts >= ? AND ts <= ?').get(symbol, interval, fromTs, tillTs)?.max ?? null;
+}
+
 export function createRun(mode, params, uid = getUid()) {
   const r = db.prepare('INSERT INTO runs (mode, status, created_at, params, user_id) VALUES (?, ?, ?, ?, ?)').run(mode, 'running', Date.now(), JSON.stringify(params), uid ?? 1);
   return Number(r.lastInsertRowid);

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,
   };
@@ -316,19 +341,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 +373,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 +384,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,

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 };
 }

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, TIER1_LIQUID_SYMBOLS, symbolEdgeMult, computeTokenEdgeMults, QUARANTINE_DECAY, isStockQuarantined, canEnterIntraday, shouldExitBeforeNight } from './edge.js';
+import { ENTRY_EDGE_MULT, TIER1_LIQUID_SYMBOLS, symbolEdgeMult, computeTokenEdgeMults, QUARANTINE_DECAY, isStockQuarantined, canEnterIntraday, shouldExitBeforeNight, isRegimeShocked } from './edge.js';
 import { buildDividendCalendar, nextDividendAt, dividendRules, DIV_TAX } from './dividends.js';
 
 const DAY = 86400000;
@@ -40,7 +40,9 @@ export function isMarketDown(ds, t) {
 // 9: исторический состав индекса (без ошибки выжившего), дивиденды префов, правила v0.5.x
 // 10: запрет переноса внутридневных сделок через ночь, период полураспада карантина 15 дн., строгий 1-й эшелон
 // 11: индивидуальный расчёт порога каждой акции по её фактическому рублёвому обороту и остаточной волатильности
-const DATA_VERSION = 11;
+// 12: калибровка индивидуальных порогов 2–3 эшелона по ликвидности, защита от шорт-сквизов (≥20% за день) и обвалов (≥9,5% за 30м), отбор доступных шортов до Top-K
+// 13: полная докачка левого края истории свечей (раньше при уже накопленных свечах 2022 год не догружался)
+const DATA_VERSION = 13;
 
 const AUTO_LOCKED = { modelHorizon: 2.5, modelMinEdge: 2.5, modelExitRatio: 0.95 };
 function reuseParamsKey(params) {
@@ -461,8 +463,8 @@ async function run(runId, p, state) {
       }
       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;
+      const okLong = (i) => !divRule(i, t)?.blockLong && (!needTrade || (tokens[i].has[tIn] && tokens[i].open[tIn] > 0)) && (!autoAdapt || !isRegimeShocked(ds, i, t, 'long'));
+      const okShort = (i) => !divRule(i, t)?.blockShort && (!shortable || shortable.has(tokens[i].symbol)) && (!needTrade || (tokens[i].has[tIn] && tokens[i].open[tIn] > 0)) && (!autoAdapt || !isRegimeShocked(ds, i, t, 'short'));
       let order, entries;
       if (dir !== 'long') {
         const edge = (i) => pr[i] * sg[i] * Math.sqrt(H);
@@ -474,12 +476,15 @@ async function run(runId, p, state) {
           const e = edge(i);
           const barsHeld = tIn - h.entryT;
           const req = (autoAdapt && barsHeld <= 2 * stepBars ? earlyExitNeed : exitNeed) * symMult[i];
-          if (!(h.side === 'long' ? e > req : e < -req) || !liquid(i, t)) closePos(i, h, tIn, false, 'Прогноз ослаб');
+          const shocked = autoAdapt && isRegimeShocked(ds, i, t, h.side);
+          if (shocked || !(h.side === 'long' ? e > req : e < -req) || !liquid(i, t)) {
+            closePos(i, h, tIn, false, shocked ? 'Защита от экстремального сквиза/обвала' : 'Прогноз ослаб');
+          }
         }
         const needL = autoAdapt && bear ? need * 1.25 : need;
         const needS = autoAdapt ? (bear ? need * 0.90 : need * 1.25) : need;
-        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]);
+        const candL = (mktDown || !timeOk) ? [] : [...pr.keys()].filter((i) => edge(i) > needL * symMult[i] && canOpenAt(i) && okLong(i)).sort((a, b) => pr[b] - pr[a]);
+        const candS = !timeOk ? [] : [...pr.keys()].filter((i) => edge(i) < -needS * symMult[i] && canOpenAt(i) && okShort(i)).sort((a, b) => pr[a] - pr[b]);
         // Вытеснение слабой/остывшей позиции новым мощным лидером (Opportunity Rotation):
         // если капитал заперт в позиции с ослабевшим ожиданием (< 0.55 * exitNeed), а на текущей свече появился лидер в 2.4 раза сильнее порога,
         // освобождаем слот под лидера, чтобы ни одна фаза не застревала в слабых бумагах
@@ -516,11 +521,27 @@ async function run(runId, p, state) {
           const e = edge(i);
           const barsHeld = tIn - h.entryT;
           const req = (autoAdapt && barsHeld <= 2 * stepBars ? earlyExitNeed : exitNeed) * symMult[i];
-          if (!(e > req) || !liquid(i, t)) closePos(i, h, tIn, false);
+          const shocked = autoAdapt && isRegimeShocked(ds, i, t, 'long');
+          if (shocked || !(e > req) || !liquid(i, t)) closePos(i, h, tIn, false, shocked ? 'Защита от экстремального обвала' : '');
         }
-        const free = K - held.size;
         const needL = autoAdapt && bear ? need * 1.25 : need;
-        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 rawCand = (mktDown || !timeOk) ? [] : [...pr.keys()].filter((i) => edge(i) > needL * symMult[i] && canOpenAt(i) && okLong(i)).sort((a, b) => pr[b] - pr[a]);
+        const usedNow = [...held.values()].reduce((s, h) => s + h.alloc, 0);
+        if (autoAdapt && usedNow > equity * 0.65 && rawCand.length > 0) {
+          const bestNewEdge = edge(rawCand[0]);
+          if (bestNewEdge >= need * 2.2) {
+            let weakestIdx = -1, weakestE = Infinity;
+            for (const [i] of held) {
+              const curSignedE = edge(i);
+              if (curSignedE < exitNeed * 0.60 && curSignedE < weakestE && bestNewEdge > Math.max(need, curSignedE) * 2.4) {
+                weakestE = curSignedE;
+                weakestIdx = i;
+              }
+            }
+            if (weakestIdx >= 0) closePos(weakestIdx, held.get(weakestIdx), tIn, false, 'Ротация в более сильного лидера');
+          }
+        }
+        const free = K - held.size;
         const cand = filterDynamicTopK(rawCand, edge, needL, Math.max(0, free));
         order = [...held.keys(), ...cand];
       } else {
@@ -912,7 +933,7 @@ function runStressTest({ simulate, chosen, testTs, tsOf, mcurve, p, H }) {
     return round(((lo + hi) / 2) * 100, 3);
   };
   // Подбор порога входа под реальные издержки: живое исполнение, издержки 0,09% на сторону (комиссия 0,04% + проскальзывание ~0,05%)
-  const thresholdSweep = [1, 1.5, 1.65, 2, 2.5, 3].map((m) => {
+  const thresholdSweep = [1, 1.5, 1.6, 1.65, 2, 2.5, 3].map((m) => {
     const sim = simulate(chosen, 0.0009, p.modelShortFeePct, 0, { ...LIVE, needMult: m });
     const f = computeReport(sim.trades, sim.curve, p.capital, 0).full;
     return { needMult: m, current: m === ENTRY_EDGE_MULT, entryEdgePct: round(2.5 * 2 * base * m * 100, 3), returnPct: f.returnPct, cagrPct: cagr(f.returnPct, yearsOf(sim.curve)), profitFactor: f.profitFactor, maxDrawdownPct: f.maxDrawdownPct, trades: f.trades, avgTradePct: f.avgTradePct, last12Pct: segment(sim, lastTs - 365 * 86400000).returnPct, last6Pct: segment(sim, lastTs - 182 * 86400000).returnPct };
@@ -924,7 +945,7 @@ function runStressTest({ simulate, chosen, testTs, tsOf, mcurve, p, H }) {
     market: { full: mSeg(-Infinity), last12: mSeg(lastTs - 365 * 86400000), last6: mSeg(lastTs - 182 * 86400000) },
     shortableKnown: Boolean(shortable),
     caveats: [
-      'Состав рынка — сегодняшний индекс широкого рынка, бумаги отобраны по покрытию данных за весь период (ошибка выжившего не устранена).',
+      'Состав рынка — исторический состав индекса MOEXBMI на каждую дату плюс текущий состав; отсекаются только бумаги с покрытием данных менее 15% периода.',
       'Константы стратегии подбирались на этой же истории, поэтому «последние 6 и 12 месяцев» не являются честно отложенной выборкой. Честная проверка — торговля после фиксации версии.',
       'Список бумаг для шорта — текущий, а не на каждую дату.',
     ],
@@ -974,7 +995,9 @@ async function runStabilityLoop(targetId, runRow, st) {
     await pause();
     const p = normalizeParams(runRow.params || {});
     const shifts = [-8, -4, 0, 4, 8];
-    const H = barsFromHours(p.modelHorizon);
+    const autoAdapt = p.modelAutoAdapt !== false;
+    const effHorizon = autoAdapt ? 2.5 : p.modelHorizon;
+    const H = barsFromHours(effHorizon);
     const tillTs = Date.now();
     const todayStartMsk = Math.floor((tillTs + MSK) / DAY) * DAY - MSK;
     const fromTs = todayStartMsk - 1650 * DAY;
@@ -991,11 +1014,18 @@ async function runStabilityLoop(targetId, runRow, st) {
     const trainLen = Math.round(p.modelTrainDays * bpd), testLen = Math.round(20 * bpd);
     const chosen = p.modelType in MODELS ? p.modelType : 'attention';
     const realCost = (p.commissionPct + p.slippagePct) / 100;
-    const K = p.modelTopK, dir = p.modelDirection, slots = dir === 'long' ? K : 2 * K;
-    const autoAdapt = p.modelAutoAdapt !== false;
+    const rawTopK = Number(p.modelTopK ?? 2);
+    const K = rawTopK > 0 ? rawTopK : 4;
+    const dir = p.modelDirection, slots = dir === 'long' ? K : 2 * K;
     const effMinEdge = autoAdapt ? 2.5 : p.modelMinEdge;
     const exitRatio = Number(p.modelExitRatio ?? 0.5);
     const mktFilter = p.modelMarketFilter === 'ma', invVol = p.modelAllocMode === 'invvol';
+    const baseSymMult = Float64Array.from(tokens, (tk) => symbolEdgeMult(tk.symbol));
+    const divCal = buildDividendCalendar(ds);
+    const divRule = (i, t) => {
+      const nd = nextDividendAt(divCal, i, t);
+      return nd ? dividendRules(nd.daysToEx, nd.y) : null;
+    };
     const liquid = (i, t) => tokens[i].liq[t] >= LIQ_MIN && tokens[i].open[t + 1] > 0;
     const canEnter = (i, t) => liquid(i, t) && (!tokens[i].inIndex || tokens[i].inIndex[t] === 1);
     const tsOf = (t) => timeline[Math.min(t, T - 1)];
@@ -1019,7 +1049,7 @@ async function runStabilityLoop(targetId, runRow, st) {
       const maxH = autoAdapt ? Math.round(H * 1.4) : H;
       const folds = Math.max(1, Math.ceil((T - maxH - testStart) / testLen));
       let fi = 0;
-      const preds = new Map(), sigmaAt = new Map();
+      const preds = new Map(), sigmaAt = new Map(), multAt = new Map();
       while (testStart < T - maxH - 2) {
         if (st.cancelled) throw new Error('Отменено');
         const testEnd = Math.min(testStart + testLen, T - maxH - 2);
@@ -1028,12 +1058,14 @@ async function runStabilityLoop(targetId, runRow, st) {
         emitStab({ pct, text: `Проверка устойчивости: сдвиг ${si + 1} из ${shifts.length} (${shLabel}), шаг ${fi + 1} из ${folds}…` });
         await tick();
         const f = buildFold(ds, { trainStart, testStart, testEnd, H, embedDim: p.modelEmbedDim, textWeight: p.modelTextWeight, profiles, multiHorizon: autoAdapt });
+        const foldEdgeMults = computeTokenEdgeMults(tokens, f.sigma, trainStart, testStart);
         const m = await MODELS[chosen].fit(f);
         for (let t = testStart; t < testEnd; t++) {
           const u = t - f.lo;
           if (!f.yok[u]) continue;
           preds.set(t, MODELS[chosen].predict(m, f, u));
           sigmaAt.set(t, f.sigma);
+          multAt.set(t, foldEdgeMults);
         }
         testStart = testEnd;
         fi++;
@@ -1051,7 +1083,7 @@ async function runStabilityLoop(targetId, runRow, st) {
       const stockAllowed = (i) => !autoAdapt || !isStockQuarantined(stockCnt[i], stockPnl[i]);
       const curExitRatio = autoAdapt ? 0.95 : exitRatio;
       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));
+      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) => {
         const exitPrice = px(i, t);
@@ -1075,9 +1107,14 @@ async function runStabilityLoop(targetId, runRow, st) {
           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 symMult = multAt.get(t) || baseSymMult;
         const bear = isMarketDown(ds, t);
         const mktDown = mktFilter && bear;
         const barTs = tsOf(t);
+        for (const [i, h] of [...held]) {
+          const r = divRule(i, t);
+          if (r && (h.side === 'long' ? r.exitLong : r.exitShort)) closePos(i, h, tIn);
+        }
         if (autoAdapt) {
           for (const [i, h] of [...held]) {
             if (shouldExitBeforeNight(barTs, tsOf(h.entryT), stepBars, BAR_INTERVAL)) closePos(i, h, tIn);
@@ -1085,29 +1122,64 @@ async function runStabilityLoop(targetId, runRow, st) {
         }
         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 && (!autoAdapt || !isRegimeShocked(ds, i, t, 'long'));
+        const okShort = (i) => !divRule(i, t)?.blockShort && (!autoAdapt || !isRegimeShocked(ds, i, t, 'short'));
         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;
         if (dir !== 'long') {
           for (const [i, h] of [...held]) {
             const e = edge(i), barsHeld = tIn - h.entryT;
-            const req = (autoAdapt && barsHeld <= 2 * stepBars ? earlyExitNeed : exitNeed) * symbolEdgeMult(tokens[i].symbol);
-            if (!(h.side === 'long' ? e > req : e < -req) || !liquid(i, t)) closePos(i, h, tIn);
+            const req = (autoAdapt && barsHeld <= 2 * stepBars ? earlyExitNeed : exitNeed) * symMult[i];
+            const shocked = autoAdapt && isRegimeShocked(ds, i, t, h.side);
+            if (shocked || !(h.side === 'long' ? e > req : e < -req) || !liquid(i, t)) closePos(i, h, tIn);
           }
           const needL = autoAdapt && bear ? need * 1.25 : need;
           const needS = autoAdapt ? (bear ? need * 0.90 : need * 1.25) : need;
-          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 candL = (mktDown || !timeOk) ? [] : [...pr.keys()].filter((i) => edge(i) > needL * symMult[i] && canOpenAt(i) && okLong(i)).sort((a, b) => pr[b] - pr[a]);
+          const candS = !timeOk ? [] : [...pr.keys()].filter((i) => edge(i) < -needS * symMult[i] && canOpenAt(i) && okShort(i)).sort((a, b) => pr[a] - pr[b]);
+          const usedNow = [...held.values()].reduce((s, h) => s + h.alloc, 0);
+          if (autoAdapt && usedNow > equity * 0.65 && (candL.length > 0 || candS.length > 0)) {
+            const bestNewEdge = Math.max(candL.length ? edge(candL[0]) : 0, candS.length ? Math.abs(edge(candS[0])) : 0);
+            if (bestNewEdge >= need * 2.2) {
+              let weakestIdx = -1, weakestE = Infinity;
+              for (const [i, h] of held) {
+                const curSignedE = h.side === 'long' ? edge(i) : -edge(i);
+                if (curSignedE < exitNeed * 0.60 && curSignedE < weakestE && bestNewEdge > Math.max(need, curSignedE) * 2.4) {
+                  weakestE = curSignedE;
+                  weakestIdx = i;
+                }
+              }
+              if (weakestIdx >= 0) closePos(weakestIdx, held.get(weakestIdx), tIn);
+            }
+          }
           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) {
           for (const [i, h] of [...held]) {
             const e = edge(i), barsHeld = tIn - h.entryT;
-            const req = autoAdapt && barsHeld <= 2 * stepBars ? earlyExitNeed : exitNeed;
-            if (!(e > req) || !liquid(i, t)) closePos(i, h, tIn);
+            const req = (autoAdapt && barsHeld <= 2 * stepBars ? earlyExitNeed : exitNeed) * symMult[i];
+            const shocked = autoAdapt && isRegimeShocked(ds, i, t, 'long');
+            if (shocked || !(e > req) || !liquid(i, t)) closePos(i, h, tIn);
           }
           const needL = autoAdapt && bear ? need * 1.25 : need;
-          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));
+          const rawCand = (mktDown || !timeOk) ? [] : [...pr.keys()].filter((i) => edge(i) > needL * symMult[i] && canOpenAt(i) && okLong(i)).sort((a, b) => pr[b] - pr[a]);
+          const usedNow = [...held.values()].reduce((s, h) => s + h.alloc, 0);
+          if (autoAdapt && usedNow > equity * 0.65 && rawCand.length > 0) {
+            const bestNewEdge = edge(rawCand[0]);
+            if (bestNewEdge >= need * 2.2) {
+              let weakestIdx = -1, weakestE = Infinity;
+              for (const [i] of held) {
+                const curSignedE = edge(i);
+                if (curSignedE < exitNeed * 0.60 && curSignedE < weakestE && bestNewEdge > Math.max(need, curSignedE) * 2.4) {
+                  weakestE = curSignedE;
+                  weakestIdx = i;
+                }
+              }
+              if (weakestIdx >= 0) closePos(weakestIdx, held.get(weakestIdx), tIn);
+            }
+          }
+          const cand = rawCand.slice(0, Math.max(0, K - held.size));
           order = [...held.keys(), ...cand];
         } else {
           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);
@@ -1125,11 +1197,25 @@ async function runStabilityLoop(targetId, runRow, st) {
         }
         const usedStart = [...held.values()].reduce((s, h) => s + h.alloc, 0);
         let avail = Math.max(0, equity * 0.99 - usedStart);
+        const activeTotal = Math.max(2, held.size + newEntries.length);
+        const dynSlotWeight = autoAdapt
+          ? Math.min(dir === 'long' ? 0.58 : 0.75, Math.max(maxSlotWeight, (dir === 'long' ? 1.8 : 3.0) / Math.min(slots, activeTotal + 1)))
+          : maxSlotWeight;
+        if (autoAdapt && newEntries.length > 1) {
+          newEntries.sort((a, b) => Math.abs(b[2] ?? 0) - Math.abs(a[2] ?? 0));
+        }
+        const edgeWeights = newEntries.map(([i, , edgeAt]) => {
+          const effE = edgeAt !== null && edgeAt !== undefined ? Math.abs(edgeAt) : (sg ? Math.abs(pr[i] * sg[i] * Math.sqrt(H)) : 0);
+          return Math.max(0.0001, effE);
+        });
+        let remWeightSum = edgeWeights.reduce((a, b) => a + b, 0);
         for (let idx = 0; idx < newEntries.length; idx++) {
-          const [i, side, edgeAt] = newEntries[idx];
-          const effEdge = edgeAt !== null && edgeAt !== undefined ? Math.abs(edgeAt) : (sg ? Math.abs(pr[i] * sg[i] * Math.sqrt(H)) : 0);
-          const conv = autoAdapt && need > 0 && effEdge > 0 ? Math.min(1.20, Math.max(0.85, 0.80 + 0.20 * (effEdge / need))) : 1;
-          const baseAlloc = autoAdapt ? Math.min(equity * maxSlotWeight * conv, avail / Math.max(1, newEntries.length - idx)) : Math.min(equity / slots, avail / Math.max(1, newEntries.length - idx));
+          const [i, side] = newEntries[idx];
+          const effEdge = edgeWeights[idx];
+          const conv = autoAdapt && need > 0 && effEdge > 0 ? Math.min(1.65, Math.max(0.85, 0.80 + 0.30 * (effEdge / need))) : 1;
+          const propShare = autoAdapt && remWeightSum > 0 ? avail * (effEdge / remWeightSum) : avail / Math.max(1, newEntries.length - idx);
+          remWeightSum = Math.max(0, remWeightSum - effEdge);
+          const baseAlloc = autoAdapt ? Math.min(equity * dynSlotWeight * conv, propShare, avail) : Math.min(equity / slots, avail / Math.max(1, newEntries.length - idx));
           let alloc = baseAlloc;
           if (invVol && avgInv > 0 && sg[i] > 0) {
             const w = Math.max(0.4, Math.min(1.8, (1 / sg[i]) / avgInv));

package/server/strategist/tools.js

@@ -283,6 +283,7 @@ export const TOOLS = {
           динамика_проц: x.deltaPct || 0,
           сигнал_покупки: !!x.signal,
           ...(buyBlockedByDip ? { покупка_заблокирована: `сейчас бумага падает на текущей свече (${x.lastMovePct}%), сработала защита от ловли падающего ножа` } : {}),
+          ...(x.buyBlockedByOverheat ? { покупка_заблокирована_перегревом: `бумага уже перегрета (+${x.buyBlockedByOverheat}% сверх рынка за 1–3 дня), сработала защита от покупки на вершине пампа` } : {}),
           ...(x.buyBlockedByDiv ? { покупка_заблокирована_дивидендами: x.buyBlockedByDiv } : {}),
           ...(x.buyBlockedByNews ? { покупка_заблокирована_новостями: x.buyBlockedByNews } : {}),
           ...(x.shortSignal !== undefined ? { сигнал_шорта: !!x.shortSignal } : {}),