neuroalpha 0.5.3 → 0.5.4

package/package.json

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

package/public/app.js

@@ -565,13 +565,13 @@ function renderStress(sx) {
   const cell = (v, d = 1, pct = true) => (v === null || v === undefined ? '<span class="muted">—</span>' : `<span class="${pct ? cls(v) : ''}">${pct ? fmtPct(v, d) : fmtNum(v, d)}</span>`);
   const rows = sx.scenarios.map((s) => `<tr${s.key === 'realistic' ? ' style="font-weight:600"' : ''}>
     <td title="${esc(s.note || '')}">${esc(s.label)}</td>
-    <td class="num">${cell(s.full.returnPct)}</td><td class="num">${cell(s.full.cagrPct)}</td>
+    <td class="num">${cell(s.full.returnPct)}</td><td class="num">${cell(s.full.cagrPct)}</td><td class="num">${cell(s.full.afterTaxCagrPct)}</td>
     <td class="num">${cell(s.full.profitFactor, 2, false)}</td><td class="num">${cell(s.full.maxDrawdownPct === null ? null : -s.full.maxDrawdownPct)}</td>
     <td class="num">${fmtNum(s.full.trades, 0)}</td><td class="num">${cell(s.full.avgTradePct, 3)}</td>
     <td class="num">${cell(s.last12.returnPct)}</td><td class="num">${cell(s.last6.returnPct)}</td></tr>`).join('');
   box.innerHTML = `<div class="stab-head">${verdict}<span><b>Стресс-тест исполнения</b>${base && real ? ` · итог ${fmtPct(base.full.returnPct)} → <b class="${cls(real.full.returnPct)}">${fmtPct(real.full.returnPct)}</b> при реалистичном исполнении` : ''} · рынок за период ${fmtPct(sx.market?.full)}</span></div>
-    <div style="overflow-x:auto"><table class="cmp"><thead><tr><th>Сценарий</th><th class="num">Итог</th><th class="num">Годовых</th><th class="num">PF</th><th class="num">Просадка</th><th class="num">Сделок</th><th class="num">Ср. сделка</th><th class="num">12 мес.</th><th class="num">6 мес.</th></tr></thead><tbody>${rows}
-    <tr class="muted"><td>Рынок (индекс МосБиржи)</td><td class="num">${cell(sx.market?.full)}</td><td></td><td></td><td></td><td></td><td></td><td class="num">${cell(sx.market?.last12)}</td><td class="num">${cell(sx.market?.last6)}</td></tr></tbody></table></div>
+    <div style="overflow-x:auto"><table class="cmp"><thead><tr><th>Сценарий</th><th class="num">Итог</th><th class="num">Годовых</th><th class="num" title="Грубая оценка: НДФЛ 13% с прибыли">после НДФЛ</th><th class="num">PF</th><th class="num">Просадка</th><th class="num">Сделок</th><th class="num">Ср. сделка</th><th class="num">12 мес.</th><th class="num">6 мес.</th></tr></thead><tbody>${rows}
+    <tr class="muted"><td>Рынок (индекс МосБиржи)</td><td class="num">${cell(sx.market?.full)}</td><td></td><td></td><td></td><td></td><td></td><td></td><td class="num">${cell(sx.market?.last12)}</td><td class="num">${cell(sx.market?.last6)}</td></tr></tbody></table></div>
     <p class="muted small note">${(sx.caveats || []).map(esc).join(' ')}</p>`;
 }
 

package/server/brokers/index.js

@@ -9,6 +9,7 @@ import { latestBarTs } from '../data/moex.js';
 import { barsFromHours, BAR_INTERVAL, BAR_MS } from '../model/dataset.js';
 import { forecastNow } from '../model/forecast.js';
 import { TIER1_LIQUID_SYMBOLS, symbolEdgeMult } from '../model/edge.js';
+import { liveDividendGuard } from '../model/dividends.js';
 import { MODELS } from '../model/models.js';
 import { blockingNews } from '../news/index.js';
 import { round, MSK, DAY, fmtBarMsk } from '../util.js';
@@ -1597,8 +1598,15 @@ export async function prepareBrokerOrders(id, { onlyEntries = false } = {}) {
   const nb = params.newsFilter ? blockingNews(6) : null;
 
   const cooldownSkipped = fc.rows.filter((r) => ((r.signal && r.expectedPct >= reqBuyEdgeOf(r.symbol)) || (rawDir !== 'long' && r.shortSignal && r.expectedPct <= -reqShortEdgeOf(r.symbol))) && isInCooldown(r.symbol));
-  const buyCands = fc.rows.filter((r) => r.signal && r.expectedPct >= reqBuyEdgeOf(r.symbol) && !isInCooldown(r.symbol) && !quarantined.has(r.symbol) && !nb?.get(r.symbol)?.bad).sort((a, b) => b.expectedPct - a.expectedPct).slice(0, K);
-  const allShortSignals = rawDir !== 'long' ? fc.rows.filter((r) => r.shortSignal && r.expectedPct <= -reqShortEdgeOf(r.symbol) && !isInCooldown(r.symbol) && !quarantined.has(r.symbol) && !nb?.get(r.symbol)?.good).sort((a, b) => a.expectedPct - b.expectedPct) : [];
+  // Дивидендный предохранитель (общие правила с бэктестом, server/model/dividends.js)
+  const divGuardOf = (sym, px) => liveDividendGuard(sym, Number(px) || specs[sym]?.lastPrice || 0, nowTs);
+  const divBlocked = [];
+  const buyCands = fc.rows.filter((r) => r.signal && r.expectedPct >= reqBuyEdgeOf(r.symbol) && !isInCooldown(r.symbol) && !quarantined.has(r.symbol) && !nb?.get(r.symbol)?.bad)
+    .filter((r) => { const g = divGuardOf(r.symbol, r.price); if (g?.blockLong) { divBlocked.push(`${r.symbol} (отсечка ${g.exDate}, ${g.yieldPct}%)`); return false; } return true; })
+    .sort((a, b) => b.expectedPct - a.expectedPct).slice(0, K);
+  const allShortSignals = rawDir !== 'long' ? fc.rows.filter((r) => r.shortSignal && r.expectedPct <= -reqShortEdgeOf(r.symbol) && !isInCooldown(r.symbol) && !quarantined.has(r.symbol) && !nb?.get(r.symbol)?.good)
+    .filter((r) => { const g = divGuardOf(r.symbol, r.price); if (g?.blockShort) { divBlocked.push(`${r.symbol} (отсечка ${g.exDate}, ${g.yieldPct}%)`); return false; } return true; })
+    .sort((a, b) => a.expectedPct - b.expectedPct) : [];
   const nonShortableSkipped = [];
   const rawShortCands = [];
   for (const r of allShortSignals) {
@@ -1654,12 +1662,16 @@ export async function prepareBrokerOrders(id, { onlyEntries = false } = {}) {
       const curGainPct = avgPx > 0 ? ((curPx - avgPx) / avgPx) * 100 : 0;
       const hitHardStopLoss = curGainPct <= -2.6;
       const keepByForecast = onlyEntries ? (r.liquid && r.expectedPct > -needPct) : (r.liquid && r.expectedPct > curExitThr);
-      const keep = keepByForecast && !hitHardStopLoss;
+      const dg = divGuardOf(sym, curPx);
+      const divExit = Boolean(dg?.exitLong);
+      const keep = keepByForecast && !hitHardStopLoss && !divExit;
       if (lots >= 1 && !keep) {
         const limitPrice = sniperLimitPrice(curPx, -1, acc.limitOffsetPct, sp);
         const exitReason = hitHardStopLoss
           ? `Защитный стоп-лосс позиции (${round(curGainPct, 2)}%)`
-          : `Выход из покупки: ожидание ${r.expectedPct > 0 ? '+' : ''}${r.expectedPct}% ниже порога удержания +${curExitThr}%`;
+          : divExit
+            ? `Дивидендная отсечка ${dg.exDate} (дивиденд ${dg.yieldPct}%): закрытие покупки в последний день с правом, чтобы не терять 13% налога с дивиденда`
+            : `Выход из покупки: ожидание ${r.expectedPct > 0 ? '+' : ''}${r.expectedPct}% ниже порога удержания +${curExitThr}%`;
         orders.push({
           symbol: sym, action: 'sell', lotSize: sp.lotSize, lots, shares: lots * sp.lotSize,
           refPrice: curPx, limitPrice, amountRub: round(lots * sp.lotSize * limitPrice, 2),
@@ -1672,12 +1684,16 @@ export async function prepareBrokerOrders(id, { onlyEntries = false } = {}) {
       const curGainPct = avgPx > 0 ? ((avgPx - curPx) / avgPx) * 100 : 0;
       const hitHardStopLoss = curGainPct <= -2.2;
       const keepByForecast = onlyEntries ? (dir !== 'long' && r.liquid && r.expectedPct < needPct) : (dir !== 'long' && r.liquid && r.expectedPct < -curExitThr);
-      const keep = keepByForecast && !hitHardStopLoss;
+      const dg = divGuardOf(sym, curPx);
+      const divExit = Boolean(dg?.exitShort);
+      const keep = keepByForecast && !hitHardStopLoss && !divExit;
       if (lots >= 1 && !keep) {
         const limitPrice = sniperLimitPrice(curPx, 1, acc.limitOffsetPct, sp);
         const exitReason = hitHardStopLoss
           ? `Защитный стоп-лосс шорта от выноса вверх (${round(curGainPct, 2)}%)`
-          : `Закрытие шорта: ожидание ${r.expectedPct > 0 ? '+' : ''}${r.expectedPct}% выше порога удержания −${curExitThr}%`;
+          : divExit
+            ? `Дивидендная отсечка ${dg.exDate} (дивиденд ${dg.yieldPct}%): закрытие шорта в последний день с правом, чтобы брокер не списал компенсацию дивиденда`
+            : `Закрытие шорта: ожидание ${r.expectedPct > 0 ? '+' : ''}${r.expectedPct}% выше порога удержания −${curExitThr}%`;
         orders.push({
           symbol: sym, action: 'cover', lotSize: sp.lotSize, lots, shares: lots * sp.lotSize,
           refPrice: curPx, limitPrice, amountRub: round(lots * sp.lotSize * limitPrice, 2),
@@ -1956,6 +1972,9 @@ export async function prepareBrokerOrders(id, { onlyEntries = false } = {}) {
         : `На свече ${fc.bar} ни одна доступная бумага не превысила порог выгоды +${fc.thresholdPct}%${noShortNote}.`;
     }
   }
+  if (divBlocked.length) {
+    diagNote = `${diagNote ? `${diagNote} ` : ''}Перед дивидендной отсечкой пропущены сигналы: ${[...new Set(divBlocked)].join(', ')}.`;
+  }
 
   if (onlyEntries && !orders.length) {
     return brokersState();

package/server/data/moex.js

@@ -6,7 +6,7 @@ const ISS = 'https://iss.moex.com/iss';
 const INDEXES = new Set(['IMOEX', 'RGBI', 'MOEXBMI']);
 // макро-инструменты: валюта (CETS) и фьючерсы (FORTS/RFUD)
 const CURRENCY = new Set(['CNYRUB_TOM', 'USD000UTSTOM']);
-const FUTURES = /^GLDRUBF$|^BR[A-Z]\d$/;
+const FUTURES = /^GLDRUBF$|^IMOEXF$|^BR[A-Z]\d$/;
 
 export const mskToTs = (s) => Date.parse(s.replace(' ', 'T') + '+03:00');
 export const tsToDate = (ts) => new Date(ts + MSK).toISOString().slice(0, 10);
@@ -175,29 +175,43 @@ async function fetchDividendsIss(symbol, signal) {
 }
 
 // Запасной источник: smart-lab.ru/q/{тикер}/dividend/ — таблица «дата отсечки» (= дата реестра) и сумма в рублях
-async function fetchDividendsSmartlab(symbol, signal) {
-  const url = `https://smart-lab.ru/q/${symbol}/dividend/`;
+async function fetchDividendsSmartlabPage(page, symbol, signal) {
+  const url = `https://smart-lab.ru/q/${page}/dividend/`;
   const sig = signal ? AbortSignal.any([signal, AbortSignal.timeout(30000)]) : AbortSignal.timeout(30000);
   const r = await fetch(url, { headers: { 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)' }, signal: sig });
+  if (r.status === 404) return null;
   if (!r.ok) throw new Error(`HTTP ${r.status}`);
   const t = await r.text();
   const m = t.match(/simple-little-table financials dividends[\s\S]*?<\/table>/);
   if (!m) return null;
   const list = [];
   for (const row of m[0].matchAll(/<tr[^>]*>\s*<td>([A-Z0-9]+)<\/td>\s*<td>[\d.]+<\/td>\s*<td>(\d\d)\.(\d\d)\.(\d{4})<\/td>\s*<td>[^<]*<\/td>\s*<td><strong[^>]*>([\d\s,]+)<\/strong>/g)) {
-    if (row[1] !== symbol) continue; // на странице есть и префы
+    if (row[1] !== symbol) continue; // на странице есть и обыкновенные, и привилегированные акции
     const value = Number(row[5].replace(/\s/g, '').replace(',', '.'));
     if (value > 0) list.push({ registry: `${row[4]}-${row[3]}-${row[2]}`, value });
   }
   return list;
 }
 
+// Запасной источник: smart-lab.ru/q/{тикер}/dividend/ — таблица «дата отсечки» (= дата реестра) и сумма в рублях.
+// Дивиденды привилегированных акций (SBERP, SNGSP, TATNP…) публикуются на странице обыкновенной акции (SBER, SNGS, TATN).
+async function fetchDividendsSmartlab(symbol, signal) {
+  const own = await fetchDividendsSmartlabPage(symbol, symbol, signal);
+  if (own?.length) return own;
+  if (/^[A-Z]{3,}P$/.test(symbol)) {
+    const viaCommon = await fetchDividendsSmartlabPage(symbol.slice(0, -1), symbol, signal);
+    if (viaCommon) return viaCommon;
+  }
+  return own;
+}
+
 // Дивиденды акции с кэшем в kv на 7 суток (включая пустой список для бездивидендных бумаг); при ошибке сети — старый кэш
 export async function ensureDividends(symbol, { signal, localOnly = false } = {}) {
   const key = `dividends:${symbol}`;
   const cached = kvGet(key);
   if (localOnly) return cached?.list || [];
-  if (cached && Array.isArray(cached.list) && Date.now() - cached.at < 7 * DAY) return cached.list;
+  // v2: дивиденды привилегированных акций со страницы обыкновенной (раньше у префов кешировался пустой список)
+  if (cached && cached.v === 2 && Array.isArray(cached.list) && Date.now() - cached.at < 7 * DAY) return cached.list;
   let list = null;
   let networkOk = false;
   try {
@@ -213,7 +227,7 @@ export async function ensureDividends(symbol, { signal, localOnly = false } = {}
   }
   const finalList = Array.isArray(list) ? list : (cached?.list || []);
   if (networkOk || Array.isArray(list)) {
-    kvSet(key, { at: Date.now(), list: finalList });
+    kvSet(key, { v: 2, at: Date.now(), list: finalList });
   }
   return finalList;
 }

package/server/model/dataset.js

@@ -196,6 +196,25 @@ async function loadBrent(fromTs, tillTs, signal) {
   return { n, ts: Float64Array.from(ts), open: Float64Array.from(close), close: Float64Array.from(close), value: new Float64Array(n) };
 }
 
+// Цены инструмента, выровненные по временной шкале датасета (цена открытия свечи; без сделок — последняя известная цена).
+// Используется для расчёта защиты реальным фьючерсом на индекс (IMOEXF), а не самим значением индекса.
+export async function loadAlignedOpen(ds, symbol, { fromTs, tillTs, signal } = {}) {
+  const rows = await ensureCandles(symbol, BAR_INTERVAL, fromTs ?? ds.timeline[0], tillTs ?? ds.timeline[ds.T - 1] + BAR_MS, { signal }).catch(() => []);
+  const out = new Float64Array(ds.T).fill(NaN);
+  let j = 0, last = NaN;
+  for (let i = 0; i < ds.T; i++) {
+    const t = ds.timeline[i];
+    let o = NaN;
+    while (j < rows.length && rows[j].ts <= t) {
+      if (rows[j].ts === t) o = rows[j].open;
+      last = rows[j].close;
+      j++;
+    }
+    out[i] = Number.isFinite(o) && o > 0 ? o : last;
+  }
+  return out;
+}
+
 // Выровненная по времени «матрица рынка»: N акций × T свечей по 10 минут (только будни),
 // цены с переносом последнего значения, обороты, доходности, рынок (IMOEX).
 // Цены акций скорректированы на дивиденды (полная доходность; useDividends=false — без этого), макро — только при useMacro.

package/server/model/dividends.js

@@ -0,0 +1,117 @@
+// Copyright (c) 2026 Roman A. Perepelkin. All rights reserved. Proprietary software.
+// Календарь дивидендных отсечек и общий «дивидендный предохранитель» для бэктеста и живой торговли.
+//
+// Бэктест считает по ценам, скорректированным на дивиденды, а реальный счёт — нет:
+//  • покупка, удерживаемая через отсечку: цена падает на весь дивиденд, а на счёт приходит дивиденд за вычетом НДФЛ 13%
+//    → потеря ≈ 0,13 × дивидендная доходность от позиции (для бумаги с дивидендом 10% это −1,3%);
+//  • шорт через отсечку: брокер списывает компенсацию дивиденда; теоретически это покрывается падением цены,
+//    но брокеры нередко запрещают или принудительно закрывают шорты перед отсечкой — держать шорт через отсечку не нужно.
+// Правила (последний день с правом на дивиденд = торговый день перед экс-датой):
+//  • за 1–2 торговых дня до экс-даты — не открываем шорт;
+//  • в последний день с правом — не открываем покупку при дивиденде ≥ 1% и закрываем позиции стратегии
+//    (покупки при дивиденде ≥ 1%, шорты при дивиденде ≥ 0,3%).
+import { kvGet } from '../db.js';
+import { exDate } from '../data/moex.js';
+
+const MSK = 3 * 3600000;
+const DAY = 86400000;
+export const DIV_TAX = 0.13;
+export const DIV_MIN_YIELD = 0.003; // меньше 0,3% — шум, не реагируем
+export const LONG_EXIT_YIELD = 0.01;
+
+export function dividendRules(daysToEx, y) {
+  if (!(y >= DIV_MIN_YIELD) || !(daysToEx >= 1)) return { blockLong: false, blockShort: false, exitLong: false, exitShort: false };
+  return {
+    blockShort: daysToEx <= 2,
+    blockLong: daysToEx === 1 && y >= LONG_EXIT_YIELD,
+    exitLong: daysToEx === 1 && y >= LONG_EXIT_YIELD,
+    exitShort: daysToEx === 1,
+  };
+}
+
+const uniqDivs = (list) => {
+  const seen = new Set();
+  return (Array.isArray(list) ? list : []).filter((d) => {
+    if (!d?.registry || !(d.value > 0)) return false;
+    const k = `${d.registry}|${d.value}`;
+    if (seen.has(k)) return false;
+    seen.add(k);
+    return true;
+  });
+};
+
+// ---------- бэктест: экс-даты на временной шкале датасета ----------
+// Возвращает { dayIdx: Uint32Array(T), events: Array<Array<{ exDay, exT, y }>> } — по каждой акции список отсечек
+export function buildDividendCalendar(ds) {
+  const { timeline, tokens, T } = ds;
+  const dayIdx = new Uint32Array(T);
+  const days = [], first = [];
+  let lastKey = -1;
+  for (let t = 0; t < T; t++) {
+    const k = Math.floor((timeline[t] + MSK) / DAY);
+    if (k !== lastKey) { lastKey = k; days.push(new Date(k * DAY).toISOString().slice(0, 10)); first.push(t); }
+    dayIdx[t] = days.length - 1;
+  }
+  const events = tokens.map((tk) => {
+    const out = [];
+    for (const d of uniqDivs(kvGet(`dividends:${tk.symbol}`)?.list)) {
+      const ex = exDate(d.registry, days);
+      const di = ex ? days.indexOf(ex) : -1;
+      if (di < 1) continue;
+      const exT = first[di];
+      const pc = tk.close[exT - 1];
+      const y = pc > 0 ? d.value / pc : 0;
+      if (y >= DIV_MIN_YIELD && y < 0.5) out.push({ exDay: di, exT, y });
+    }
+    return out.sort((a, b) => a.exT - b.exT);
+  });
+  return { dayIdx, events };
+}
+
+// Ближайшая отсечка акции i, ещё не наступившая к бару t: { daysToEx, y } или null
+export function nextDividendAt(cal, i, t) {
+  const cur = cal.dayIdx[t];
+  for (const e of cal.events[i]) {
+    if (e.exDay > cur) return { daysToEx: e.exDay - cur, y: e.y, exT: e.exT };
+  }
+  return null;
+}
+
+// ---------- живая торговля: календарь по будням (праздники МосБиржи не учитываются — запас в 1 день) ----------
+const isWeekend = (d) => d.getUTCDay() === 0 || d.getUTCDay() === 6;
+const ymd = (d) => d.toISOString().slice(0, 10);
+const prevWeekday = (d) => { const x = new Date(d); do x.setUTCDate(x.getUTCDate() - 1); while (isWeekend(x)); return x; };
+
+// режим T+1: экс-дата = дата реестра, если это торговый день, иначе предыдущий торговый день
+function liveExDate(registry) {
+  const r = new Date(`${registry}T00:00:00Z`);
+  return isWeekend(r) ? prevWeekday(r) : r;
+}
+
+function weekdaysBetween(fromYmd, toYmd) {
+  let n = 0;
+  const d = new Date(`${fromYmd}T00:00:00Z`), end = new Date(`${toYmd}T00:00:00Z`);
+  while (d < end) {
+    d.setUTCDate(d.getUTCDate() + 1);
+    if (!isWeekend(d)) n++;
+  }
+  return n;
+}
+
+// Предохранитель для живого контура: ближайшая отсечка бумаги и действующие правила
+export function liveDividendGuard(symbol, price, now = Date.now()) {
+  if (!(price > 0)) return null;
+  const today = ymd(new Date(now + MSK));
+  let best = null;
+  for (const d of uniqDivs(kvGet(`dividends:${symbol}`)?.list)) {
+    const ex = ymd(liveExDate(d.registry));
+    if (ex <= today) continue;
+    if (!best || ex < best.ex) best = { ex, value: d.value };
+  }
+  if (!best) return null;
+  const daysToEx = weekdaysBetween(today, best.ex);
+  const y = best.value / price;
+  const rules = dividendRules(daysToEx, y);
+  if (!rules.blockLong && !rules.blockShort && !rules.exitLong && !rules.exitShort) return null;
+  return { ...rules, exDate: best.ex, daysToEx, yieldPct: Math.round(y * 10000) / 100, value: best.value };
+}

package/server/model/research.js

@@ -3,13 +3,14 @@ import { normalizeParams } from '../settings.js';
 import { computeReport, downsample, buildPeriods } from './metrics.js';
 import { round } from '../util.js';
 import { hub } from '../hub.js';
-import { loadDataset, barsFromHours, BAR_INTERVAL } from './dataset.js';
+import { loadDataset, loadAlignedOpen, barsFromHours, BAR_INTERVAL } from './dataset.js';
 import { buildFold, MODELS, modelNames, HEADS, LIQ_MIN, FEATURE_WARMUP, mapSnapshot, alignTo, matchClusters } from './models.js';
 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 { buildDividendCalendar, nextDividendAt, dividendRules, DIV_TAX } from './dividends.js';
 
 const DAY = 86400000;
 const MSK = 3 * 3600000;
@@ -191,6 +192,7 @@ async function run(runId, p, state) {
   const preds = Object.fromEntries(names.map((n) => [n, new Map()])); // t -> Float64Array(N)
   const yraw = new Map(); // t -> Float64Array(N)
   const sigmaAt = new Map(); // t -> обычный размах акций в этом окне обучения
+  const betaAt = new Map(); // t -> бета акций к индексу в этом окне обучения (для защиты от движения рынка)
   const snapshots = [];
   let prevPts = null, prevCl = null, lastFold = null, lastModels = null;
   const folds = Math.ceil((T - H - firstTest) / testLen);
@@ -220,6 +222,7 @@ async function run(runId, p, state) {
       for (const n of names) preds[n].set(t, MODELS[n].predict(fitted[n], f, u));
       yraw.set(t, Float64Array.from(f.yraw.subarray(u * N, u * N + N)));
       sigmaAt.set(t, f.sigma);
+      betaAt.set(t, f.beta);
     }
     // снимок карты рынка на начало месяца прогноза
     const snap = mapSnapshot(f);
@@ -301,6 +304,15 @@ async function run(runId, p, state) {
   const invVol = p.modelAllocMode === 'invvol';
   const realCost = (p.commissionPct + p.slippagePct) / 100;
   const symMult = Float64Array.from(tokens, (tk) => symbolEdgeMult(tk.symbol));
+  const divCal = buildDividendCalendar(ds);
+  // реальные цены вечного фьючерса на индекс МосБиржи (IMOEXF) — для честной оценки защиты фьючерсом
+  let futOpen = null;
+  try {
+    futOpen = await loadAlignedOpen(ds, 'IMOEXF', { fromTs: timeline[Math.max(0, firstTest - 10)], tillTs: timeline[T - 1] + 600000, signal: state.ctrl.signal });
+    let n = 0;
+    for (let t = firstTest; t < T; t++) if (futOpen[t] > 0) n++;
+    if (n < (T - firstTest) * 0.5) futOpen = null;
+  } catch { futOpen = null; }
   const liquid = (i, t) => tokens[i].liq[t] >= LIQ_MIN && tokens[i].open[t + 1] > 0;
   // только покупки: на позицию капитал / K; с продажами: капитал / 2K (покупки и продажи вместе не больше капитала)
   const slots = dir === 'long' ? K : 2 * K;
@@ -350,6 +362,21 @@ async function run(runId, p, state) {
     const needMult = Number(ex.needMult) > 0 ? Number(ex.needMult) : ENTRY_EDGE_MULT;
     const cashRateAnnual = Number(ex.cashRateAnnual) > 0 ? Number(ex.cashRateAnnual) : 0;
     const costOf = (i) => (ex.tierCost ? (symMult[i] === 1 ? 0.00065 : 0.00125) : cost);
+    // дивидендный предохранитель (правило стратегии, как в живом контуре; выключается только для сравнения)
+    const divGuard = ex.divGuard !== false;
+    // налог 13% с дивиденда по покупкам, удержанным через отсечку (цены в бэктесте скорректированы на полный дивиденд)
+    const divTax = Boolean(ex.divTax);
+    // защита от движения рынка: короткий/длинный фьючерс на индекс на чистую бету портфеля
+    const betaHedge = Boolean(ex.betaHedge);
+    const hedgeCarry = Number(ex.hedgeCarry ?? 0.08); // разница фьючерса и индекса, годовых (шорт фьючерса её получает)
+    const hedgeCost = Number(ex.hedgeCost ?? 0.0002); // издержки на сторону при перестройке защиты
+    let hedgeRub = 0;
+    const stats = { borrowRub: 0, divTaxRub: 0, feesRub: 0, hedgePnlRub: 0, hedgeMktRub: 0, hedgeCarryRub: 0, hedgeCostRub: 0, netBetaSum: 0, netBetaN: 0, divExits: 0 };
+    const divRule = (i, t) => {
+      if (!divGuard) return null;
+      const nd = nextDividendAt(divCal, i, t);
+      return nd ? dividendRules(nd.daysToEx, nd.y) : null;
+    };
     let equity = p.capital;
     let idleShareSum = 0, idleSteps = 0, prevStepTs = tsOf(testTs[startIdx] ?? testTs[0]);
     const curve = [{ ts: tsOf(testTs[startIdx] ?? testTs[0]), equity }];
@@ -390,8 +417,16 @@ async function run(runId, p, state) {
         gross = h.alloc * (exitPrice / h.entryPrice - 1);
         fee = (h.alloc + gross) * c;
       }
-      equity += gross - fee - borrow;
-      trades.push(tradeRec(name, i, h, t, exitPrice, gross - fee - borrow - h.entryCost, h.entryCost + fee, borrow, end, why));
+      // покупка удержана через отсечку: на счёт пришёл дивиденд за вычетом НДФЛ, а скорректированная цена учла его целиком
+      let divLoss = 0;
+      if (divTax && h.side === 'long') {
+        for (const e of divCal.events[i]) if (e.exT > h.entryT && e.exT <= t) divLoss += DIV_TAX * e.y * h.alloc;
+      }
+      equity += gross - fee - borrow - divLoss;
+      stats.borrowRub += borrow;
+      stats.divTaxRub += divLoss;
+      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);
       if (autoAdapt) {
         const realGross = h.side === 'short' ? (1 - exitPrice / h.entryPrice) : (exitPrice / h.entryPrice - 1);
@@ -410,6 +445,15 @@ async function run(runId, p, state) {
       const sg = sigmaAt.get(t);
       const bear = isMarketDown(ds, t);
       const mktDown = mktFilter && bear;
+      // дивидендный предохранитель: закрываем позиции в последний день с правом на дивиденд и не входим перед отсечкой
+      if (divGuard) {
+        for (const [i, h] of [...held]) {
+          const r = divRule(i, t);
+          if (r && (h.side === 'long' ? r.exitLong : r.exitShort)) { closePos(i, h, tIn, false, 'Дивидендная отсечка'); stats.divExits++; }
+        }
+      }
+      const okLong = (i) => !divRule(i, t)?.blockLong;
+      const okShort = (i) => !divRule(i, t)?.blockShort;
       let order, entries;
       if (dir !== 'long') {
         const edge = (i) => pr[i] * sg[i] * Math.sqrt(H);
@@ -425,8 +469,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) && liquid(i, t) && edge(i) > needL * symMult[i]).sort((a, b) => pr[b] - pr[a]);
-        const candS = [...pr.keys()].filter((i) => !held.has(i) && stockAllowed(i) && liquid(i, t) && edge(i) < -needS * symMult[i]).sort((a, b) => pr[a] - pr[b]);
+        const candL = mktDown ? [] : [...pr.keys()].filter((i) => !held.has(i) && stockAllowed(i) && liquid(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) && liquid(i, t) && okShort(i) && edge(i) < -needS * symMult[i]).sort((a, b) => pr[a] - pr[b]);
         // Вытеснение слабой/остывшей позиции новым мощным лидером (Opportunity Rotation):
         // если капитал заперт в позиции с ослабевшим ожиданием (< 0.55 * exitNeed), а на текущей свече появился лидер в 2.4 раза сильнее порога,
         // освобождаем слот под лидера, чтобы ни одна фаза не застревала в слабых бумагах
@@ -467,7 +511,7 @@ 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) && liquid(i, t) && edge(i) > needL * symMult[i]).sort((a, b) => pr[b] - pr[a]);
+        const rawCand = mktDown ? [] : [...pr.keys()].filter((i) => !held.has(i) && stockAllowed(i) && liquid(i, t) && 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 {
@@ -539,6 +583,27 @@ async function run(runId, p, state) {
         const dtYears = Math.min(4 / 365, (curStepTs - prevStepTs) / (365.25 * 86400000));
         equity += idleCash * cashRateAnnual * dtYears;
       }
+      // защита фьючерсом на индекс: держим позицию против чистой беты портфеля на отрезке [tIn, tOut]
+      if (betaHedge) {
+        const bt = betaAt.get(t);
+        let netBetaRub = 0;
+        for (const [i, h] of held) netBetaRub += (h.side === 'short' ? -1 : 1) * h.alloc * (bt ? bt[i] : 1);
+        const target = -netBetaRub;
+        const rebal = Math.abs(target - hedgeRub) * hedgeCost;
+        hedgeRub = target;
+        const src = ex.hedgeSource === 'index' || !futOpen ? ds.mopen : futOpen;
+        const m0 = src[tIn], m1 = src[tOut];
+        const mRet = m0 > 0 && m1 > 0 ? m1 / m0 - 1 : 0;
+        const dtYears = Math.max(0, (tsOf(tOut) - tsOf(tIn)) / (365.25 * 86400000));
+        const hp = hedgeRub * mRet - hedgeRub * hedgeCarry * dtYears - rebal;
+        equity += hp;
+        stats.hedgePnlRub += hp;
+        stats.hedgeMktRub += hedgeRub * mRet;
+        stats.hedgeCarryRub += -hedgeRub * hedgeCarry * dtYears;
+        stats.hedgeCostRub += rebal;
+        stats.netBetaSum += equity > 0 ? netBetaRub / equity : 0;
+        stats.netBetaN++;
+      }
       prevStepTs = curStepTs;
       let mtm = 0;
       for (const [i, h] of held) {
@@ -553,7 +618,7 @@ async function run(runId, p, state) {
       exitRatio: curExitRatio,
       quarantined: tokens.map((tk, i) => (!stockAllowed(i) ? tk.symbol : null)).filter(Boolean),
     } : null;
-    return { trades, curve, adaptation, idleCashPct: round((idleShareSum / Math.max(1, idleSteps)) * 100, 1) };
+    return { trades, curve, adaptation, idleCashPct: round((idleShareSum / Math.max(1, idleSteps)) * 100, 1), stats };
   }
   function tradeRec(name, i, h, t, exitPrice, pnl, commission, borrow, end = false, why = '') {
     const heldMin = (t - h.entryT) * BAR_INTERVAL; // минуты
@@ -780,8 +845,9 @@ function runStressTest({ simulate, chosen, testTs, tsOf, mcurve, p, H }) {
     return c.length > 1 ? round((c.at(-1).equity / c[0].equity - 1) * 100, 2) : null;
   };
   const base = (p.commissionPct + p.slippagePct) / 100;
-  const REAL = { lag: 2, needTrade: true, partCap: 0.05, lots: true, shortable };
-  const LIVE = { midBar: true, needTrade: true, partCap: 0.05, lots: true, shortable };
+  // реалистичные сценарии учитывают и налог 13% с дивидендов по покупкам, удержанным через отсечку
+  const REAL = { lag: 2, needTrade: true, partCap: 0.05, lots: true, shortable, divTax: true };
+  const LIVE = { midBar: true, needTrade: true, partCap: 0.05, lots: true, shortable, divTax: true };
   const scenarios = [
     { key: 'base', label: 'Как в основном отчёте', note: `издержки ${round(base * 100, 3)}% на сторону, вход по open следующей свечи`, cost: base, ex: {} },
     { key: 'cost15', label: 'Издержки 0,15% на сторону', note: 'комиссия + спред + проскальзывание для второго-третьего эшелона', cost: 0.0015, ex: {} },
@@ -792,6 +858,8 @@ function runStressTest({ simulate, chosen, testTs, tsOf, mcurve, p, H }) {
     { key: 'shorts', label: 'Шорт только разрешённых бумаг', note: shortable ? `по текущему списку Т-Банка (${shortable.size} бумаг)` : 'список Т-Банка не загружен — проверка не выполнена', cost: base, ex: { shortable } },
     { key: 'liveLike', label: 'Как живой контур (внутри свечи), издержки как в отчёте', note: 'живые цены брокера: вход внутри следующей свечи + сделки, оборот, лоты, шорты', cost: base, ex: LIVE },
     { key: 'liveLike10', label: 'Как живой контур, издержки 0,10%', note: 'то же при издержках 0,10% на сторону (комиссия 0,05% + спред/проскальзывание 0,05%)', cost: 0.001, ex: LIVE },
+    { key: 'liveNoDivGuard', label: 'Живой контур, 0,10%, без дивидендного предохранителя', note: 'для сравнения: позиции держатся через дивидендные отсечки (с налогом 13% по покупкам)', cost: 0.001, ex: { ...LIVE, divGuard: false } },
+    { key: 'liveHedge', label: 'Живой контур, 0,10% + защита фьючерсом на индекс', note: 'реальные цены вечного фьючерса IMOEXF против чистой беты портфеля: перестройка каждые 30 мин, издержки 0,02% на сторону, разница фьючерса и индекса 8% годовых', cost: 0.001, ex: { ...LIVE, betaHedge: true } },
     { key: 'liveTierLqdt', label: 'Живой контур + издержки по эшелонам + свободный кэш в LQDT (16%/год)', note: 'издержки 0,065% 1-й эшелон и 0,125% 2–3-й эшелон + начисление ставки денежного рынка на незанятые рубли (~95% времени)', cost: 0.001, ex: { ...LIVE, tierCost: true, cashRateAnnual: 0.16 } },
     { key: 'execOnly', label: 'Всё вместе, издержки как в отчёте', note: 'задержка, сделки, оборот, лоты и шорты — без роста издержек', cost: base, ex: REAL },
     { key: 'realistic', label: 'Всё вместе, издержки 0,15%', note: 'реалистичная оценка', cost: 0.0015, ex: REAL },
@@ -804,9 +872,21 @@ function runStressTest({ simulate, chosen, testTs, tsOf, mcurve, p, H }) {
     const yrs = yearsOf(sim.curve);
     const longPnl = sim.trades.filter((t) => t.side === 'long').reduce((a, t) => a + t.pnl, 0);
     const shortPnl = sim.trades.filter((t) => t.side === 'short').reduce((a, t) => a + t.pnl, 0);
+    const cg = cagr(full.returnPct, yrs);
+    const perYearPct = (rub) => round((rub / p.capital / yrs) * 100, 2);
     out.push({
       key: s.key, label: s.label, note: s.note,
-      full: { returnPct: full.returnPct, cagrPct: cagr(full.returnPct, yrs), profitFactor: full.profitFactor, maxDrawdownPct: full.maxDrawdownPct, trades: full.trades, winRate: full.winRate, avgTradePct: full.avgTradePct, longPnl: round(longPnl, 0), shortPnl: round(shortPnl, 0) },
+      full: {
+        returnPct: full.returnPct, cagrPct: cg, profitFactor: full.profitFactor, maxDrawdownPct: full.maxDrawdownPct, trades: full.trades, winRate: full.winRate, avgTradePct: full.avgTradePct, longPnl: round(longPnl, 0), shortPnl: round(shortPnl, 0),
+        // грубая оценка после НДФЛ 13% с годовой прибыли (убыточные годы налогом не облагаются)
+        afterTaxCagrPct: cg === null ? null : round(cg > 0 ? cg * (1 - 0.13) : cg, 1),
+      },
+      costs: sim.stats ? {
+        borrowRub: round(sim.stats.borrowRub, 0), divTaxRub: round(sim.stats.divTaxRub, 0), feesRub: round(sim.stats.feesRub, 0), hedgePnlRub: round(sim.stats.hedgePnlRub, 0), divExits: sim.stats.divExits,
+        hedgeMktRub: round(sim.stats.hedgeMktRub, 0), hedgeCarryRub: round(sim.stats.hedgeCarryRub, 0), hedgeCostRub: round(sim.stats.hedgeCostRub, 0),
+        avgNetBetaPct: sim.stats.netBetaN ? round((sim.stats.netBetaSum / sim.stats.netBetaN) * 100, 1) : null,
+        borrowPctPerYear: perYearPct(sim.stats.borrowRub), divTaxPctPerYear: perYearPct(sim.stats.divTaxRub),
+      } : null,
       last12: segment(sim, lastTs - 365 * 86400000),
       last6: segment(sim, lastTs - 182 * 86400000),
     });