neuroalpha 0.5.34 → 0.6.1

package/server/model/forecast.js

@@ -4,10 +4,10 @@ import { round, DAY, MSK, fmtBarMsk } from '../util.js';
 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, REGIME_SHOCK_1D, REGIME_CRASH_30M, canEnterIntraday } from './edge.js';
+import { ENTRY_EDGE_MULT, TIER2_EDGE_MULT, TIER1_LIQUID_SYMBOLS, symbolEdgeMult, computeTokenEdgeMults, REGIME_SHOCK_1D, REGIME_CRASH_30M, canEnterIntraday, isMarketDown } from './edge.js';
 export { TIER1_LIQUID_SYMBOLS, symbolEdgeMult, computeTokenEdgeMults };
 import { newsForSymbols, blockingNews } from '../news/index.js';
+import { dayContext } from './policy.js';
 import { liveDividendGuard } from './dividends.js';
 import { fetchTbankRealtimePrices } from '../brokers/index.js';
 import { kvGet, kvSet } from '../db.js';
@@ -450,6 +450,12 @@ function buildPredictionRows(ds, p, idx, f, u, fitted, chosen, H, effMinEdge, au
       if (shortBlockedByBroker) row.shortBlockedByBroker = true;
       if (shortBlockedBySqueeze) row.shortBlockedBySqueeze = true;
     }
+    // контекст торгового дня (экстремумы, движение к закрытию прошлого дня) — для фильтра входа против события, стопа и журнала решений
+    const dc = dayContext(ds, i, idx, f.sigma[i] * 100, livePx);
+    row.day = {
+      prevClose: dc.prevClose, dayHigh: dc.dayHigh, dayLow: dc.dayLow, barsSinceHigh: dc.barsSinceHigh, barsSinceLow: dc.barsSinceLow,
+      marketDayPct: round(dc.marketDayPct, 3), realizedBarPct: round(dc.realizedBarPct, 3), dayMovePct: round(dc.dayMovePct, 2), sigmaBarPct: round(dc.sigmaBarPct, 3),
+    };
     if (explain && ex) {
       row.influences = ex.neighbors.map((x) => ({ symbol: ds.tokens[x.i].symbol, contribPct: round(x.contrib * f.sigma[i] * Math.sqrt(H) * 100, 3), closeness: round(f.cos[i][x.i], 2) }));
       row.selfPct = round(selfRaw * 100, 3);
@@ -533,7 +539,26 @@ function withNews(result, p) {
     r.thresholdRatioPct = Math.round(ratio * 100);
     r.crossedThreshold = ratio >= 1;
   }
-  if (!Array.isArray(result.nearSignals) || !result.nearSignals.length) {
+  // Если в сохранённом кэше список был обрезан прежним лимитом (40), пересобираем полный список из накопленных записей
+  const saved = !nearSignalsCache.episodesMap.size ? kvGet('nearSignalsLog') : null;
+  if (saved?.entries?.length && (saved.list?.length || 0) < Math.min(120, saved.entries.length)) {
+    nearSignalsCache = { key: saved.key, scannedBarTs: saved.scannedBarTs || 0, episodesMap: new Map(saved.entries), list: [] };
+  }
+  if (!Array.isArray(result.nearSignals) || !result.nearSignals.length || (nearSignalsCache.episodesMap.size && !nearSignalsCache.list.length)) {
+    if (nearSignalsCache.episodesMap.size && !nearSignalsCache.list.length) {
+      nearSignalsCache.list = [...nearSignalsCache.episodesMap.values()]
+        .sort((a, b) => (b.lastBarTs - a.lastBarTs) || (b.peakRatioPct - a.peakRatioPct))
+        .slice(0, 120)
+        .map((ep) => {
+          const gapPct = round(Math.max(0, ep.thresholdPct - Math.abs(ep.peakExpectedPct)), 2);
+          const reasonText = ep.status === 'signal'
+            ? 'Порог пройден — сигнал сформирован'
+            : ep.status === 'blocked'
+              ? `Порог пройден, но вход закрыт: ${(ep.reasons || []).join(' · ') || 'защитный фильтр'}`
+              : `Ниже порога на ${gapPct}%${ep.reasons?.length ? ` (также активен фильтр: ${ep.reasons.join(' · ')})` : ''}`;
+          return { ...ep, gapPct, reasonText };
+        });
+    }
     const savedNear = nearSignalsCache.list?.length ? nearSignalsCache.list : (kvGet('nearSignalsLog')?.list || []);
     result.nearSignals = savedNear;
   }
@@ -656,7 +681,7 @@ async function updateNearSignalsJournal(ds, p, last, key) {
   if (updated || !nearSignalsCache.list.length) {
     const list = [...nearSignalsCache.episodesMap.values()]
       .sort((a, b) => (b.lastBarTs - a.lastBarTs) || (b.peakRatioPct - a.peakRatioPct))
-      .slice(0, 40)
+      .slice(0, 120)
       .map((ep) => {
         const gapPct = round(Math.max(0, ep.thresholdPct - Math.abs(ep.peakExpectedPct)), 2);
         const reasonText = ep.status === 'signal'

package/server/model/policy.js

@@ -0,0 +1,193 @@
+// Copyright (c) 2026 Roman A. Perepelkin. All rights reserved. Proprietary software.
+// Единые правила сопровождения позиций для живой торговли (brokers/index.js) и симулятора стратегии (simulator.js):
+// окна начала/конца сессий, фиксация прибыли, защитный стоп, размер позиции и фильтр входа против события.
+// Любое правило меняется только здесь — бэктест и живой контур не могут разойтись.
+import { symbolEdgeMult, TIER1_LIQUID_SYMBOLS } from './edge.js';
+
+const MSK = 3 * 3600000;
+const DAY = 86400000;
+
+// Параметры стратегии. Изменение принимается, только если в лаборатории правил (scripts/strategy-lab.mjs) на пошаговой проверке
+// с исполнением как в живом контуре оно лучше прежних правил И на первой, И на второй половине периода.
+// Проверка 06.11.2026 (06.2024–11.2026, 788 сделок): аварийный стоп 7% вместо 4,5/5% — +23,6%/+8,2% по половинам против +22,9%/+5,0%,
+// просадка 3,9% против 5,0%; стопы 7–15% дают одинаковый итог (плато). Модель торгует возврат к среднему, и тесный стоп
+// закрывал позиции на пике отклонения. Стоп по волатильности, стоп отмены идеи, размер по риску — хуже на обеих половинах.
+export const STRATEGY_POLICY = Object.freeze({
+  // аварийный стоп: фиксированный процент от средней цены входа (у брокера и во внутреннем контуре)
+  stop: Object.freeze({ mode: 'fixed', longPct: 7.0, shortPct: 7.0 }),
+  // фиксация прибыли (скользящий Take-Profit и защита заработанного)
+  profitLock: true,
+  // размер позиции: 'slot' — доля бюджета × сила сигнала
+  sizing: Object.freeze({ mode: 'slot' }),
+  // Множитель размера позиции по эшелонам. Для 1-го эшелона множитель равен плечу счёта (настройка maxLeverage),
+  // 2–3-й эшелон торгуется половинным размером. Проверка 06.11.2026: сделки 1-го эшелона — PF 1,9/3,6 по половинам периода
+  // (издержки 0,065% на сторону), 2–3-го эшелона — чистыми 0,1% на сделку (издержки 0,125%). Плечо 3 на 1-й эшелон и ½ на 2-й:
+  // CAGR 56%/49% по половинам против 44%/24% (с доходом LQDT), PF 1,87; рост итога с плечом почти линейный на обеих половинах.
+  sizeMultT2: 0.5,
+  // капитал хранится в фонде денежного рынка LQDT как залог: внутридневные позиции открываются под обеспечение
+  // (без платы за перенос — позиции закрываются до ночи), LQDT не продаётся под входы
+  cashYield: true,
+  // фильтр входа против сильного дневного движения (null — выключен)
+  counterTrend: null,
+  // стоп отмены идеи: выход, если цена обновила дневной экстремум против позиции (null — выключен)
+  thesisStop: null,
+  // паузы повторного входа после выхода, минуты
+  cooldownMin: 30,
+  stopCooldownMin: 60,
+});
+
+// ---------- окна начала и конца сессий (широкий спред, гэпы, аукционы) ----------
+export const SESSION_EDGE_WINDOWS = [
+  [6 * 60 + 50, 7 * 60 + 25],
+  [9 * 60 + 50, 10 * 60 + 10],
+  [18 * 60 + 35, 18 * 60 + 55],
+];
+export function sessionEdgeWarning(ts = Date.now()) {
+  const mins = Math.floor(((ts + MSK) % DAY) / 60000);
+  for (const [a, b] of SESSION_EDGE_WINDOWS) {
+    if (mins >= a && mins <= b) return 'Первые минуты утренней/основной сессии или закрытие дневной (широкий спред и утренние гэпы в стакане)';
+  }
+  return null;
+}
+
+// ---------- фиксация прибыли ----------
+// Уровни в процентах выигрыша от средней цены. peakGainPct — лучший выигрыш с момента входа.
+// Возвращает { floorPct, minExitPct, kind } — выход, когда текущий выигрыш опустился до floorPct, но не ниже minExitPct; или null.
+export function profitLockLevels(sym, peakGainPct, heldMin, roundTripFeePct = 0.10) {
+  const tierMult = symbolEdgeMult(sym);
+  const minNetFloorPct = Math.max(roundTripFeePct + 0.30, Math.round(0.38 * tierMult * 100) / 100);
+  const tpTriggerPct = (heldMin < 15 ? 1.55 : 1.20) * tierMult;
+  if (peakGainPct >= tpTriggerPct) {
+    return { floorPct: Math.max(peakGainPct * 0.70, peakGainPct - 0.45, minNetFloorPct), minExitPct: minNetFloorPct, kind: 'tp' };
+  }
+  if (heldMin >= 15 && peakGainPct >= 0.85 * tierMult) {
+    return { floorPct: Math.max(minNetFloorPct, peakGainPct * 0.45), minExitPct: roundTripFeePct + 0.22, kind: 'be' };
+  }
+  return null;
+}
+
+export function evaluateProfitLock(sym, side, avgPx, curPx, peakPx, roundTripFeePct = 0.10, heldMin = 0) {
+  if (!(avgPx > 0 && curPx > 0)) return null;
+  const isLong = side === 'long';
+  const curGainPct = isLong ? ((curPx - avgPx) / avgPx) * 100 : ((avgPx - curPx) / avgPx) * 100;
+  const effPeakPx = peakPx > 0
+    ? (isLong ? Math.max(peakPx, avgPx, curPx) : Math.min(peakPx, avgPx, curPx))
+    : (isLong ? Math.max(avgPx, curPx) : Math.min(avgPx, curPx));
+  const peakGainPct = isLong ? ((effPeakPx - avgPx) / avgPx) * 100 : ((avgPx - effPeakPx) / avgPx) * 100;
+  const lv = profitLockLevels(sym, peakGainPct, heldMin, roundTripFeePct);
+  if (!lv || !(curGainPct <= lv.floorPct && curGainPct >= lv.minExitPct)) return null;
+  const r2 = (v) => Math.round(v * 100) / 100;
+  return lv.kind === 'tp'
+    ? `Фиксация прибыли (Take-Profit: пик +${r2(peakGainPct)}% → +${r2(curGainPct)}%)`
+    : `Защита прибыли от отката (пик +${r2(peakGainPct)}% → фиксация +${r2(curGainPct)}%)`;
+}
+
+// ---------- защитный стоп ----------
+// sigmaBarPct — обычный остаточный размах 10-минутной свечи бумаги (%), realizedBarPct — фактический размах свечей сегодня (%).
+export function protectiveStopPct(side, { sigmaBarPct = 0, realizedBarPct = 0, horizonBars = 15 } = {}, policy = STRATEGY_POLICY) {
+  const st = policy.stop || {};
+  if (st.mode === 'vol' && sigmaBarPct > 0) {
+    const vol = Math.max(sigmaBarPct, st.useRealized ? realizedBarPct : 0);
+    const raw = st.k * vol * Math.sqrt(horizonBars);
+    const maxPct = side === 'long' ? (st.maxLongPct ?? 5.0) : (st.maxShortPct ?? 4.5);
+    return Math.max(st.minPct ?? 1.0, Math.min(maxPct, raw));
+  }
+  return side === 'long' ? (st.longPct ?? 5.0) : (st.shortPct ?? 4.5);
+}
+
+// ---------- плечо и множители размера по эшелонам ----------
+export const MAX_LEVERAGE = 7;
+export function tierSizeMult(symbol, leverage = 1, policy = STRATEGY_POLICY) {
+  const lev = Math.max(1, Math.min(MAX_LEVERAGE, Number(leverage) || 1));
+  return TIER1_LIQUID_SYMBOLS.has(symbol) ? lev : (policy.sizeMultT2 ?? 1);
+}
+
+// ---------- предельный размер позиции на одну бумагу ----------
+export function symbolCapRub(symbol, side, budget, barTurnoverRub = 0) {
+  const isT1 = TIER1_LIQUID_SYMBOLS.has(symbol);
+  const rawCap = budget * (side === 'short' ? (isT1 ? 0.35 : 0.18) : (isT1 ? 0.45 : 0.22));
+  return (!isT1 && barTurnoverRub > 0) ? Math.max(45000, Math.min(rawCap, barTurnoverRub * 0.12)) : rawCap;
+}
+
+// Размер новой позиции в рублях до учёта свободного кэша и пропорциональной доли:
+//   'slot' — рабочий слот × сила сигнала (conv), не больше предела бумаги;
+//   'risk' — при срабатывании стопа счёт теряет не больше riskPct% бюджета.
+export function targetPositionRub({ symbol, side, budget, slotRub, conv = 1, stopPct, barTurnoverRub = 0 }, policy = STRATEGY_POLICY) {
+  const cap = symbolCapRub(symbol, side, budget, barTurnoverRub);
+  const sz = policy.sizing || {};
+  if (sz.mode === 'risk' && stopPct > 0) {
+    const byRisk = (budget * (sz.riskPct / 100)) / (stopPct / 100);
+    return Math.min(cap, byRisk * (sz.useConv ? conv : 1), sz.maxSlotPct ? budget * sz.maxSlotPct : Infinity);
+  }
+  return Math.min(cap, slotRub * conv);
+}
+
+// ---------- контекст торгового дня бумаги по свечам до момента решения ----------
+// t — последняя учтённая свеча; livePx — живая цена внутри формирующейся свечи (в живом контуре), иначе закрытие свечи t.
+export function dayContext(ds, i, t, sigmaBarPct, livePx = 0) {
+  const tk = ds.tokens[i];
+  const day = Math.floor((ds.timeline[t] + MSK) / DAY);
+  let d0 = t;
+  while (d0 > 0 && Math.floor((ds.timeline[d0 - 1] + MSK) / DAY) === day) d0--;
+  const px = livePx > 0 ? livePx : tk.close[t];
+  let hi = 0, lo = Infinity, hiAt = d0, loAt = d0;
+  for (let k = d0; k <= t; k++) {
+    if (!tk.has[k]) continue;
+    if (tk.high[k] > hi) { hi = tk.high[k]; hiAt = k; }
+    if (tk.low[k] > 0 && tk.low[k] < lo) { lo = tk.low[k]; loAt = k; }
+  }
+  if (px > hi) { hi = px; hiAt = t; }
+  if (px > 0 && px < lo) { lo = px; loAt = t; }
+  const prevClose = d0 > 0 ? tk.close[d0 - 1] : 0;
+  const mPrev = d0 > 0 ? ds.mclose[d0 - 1] : 0;
+  let s2 = 0, n2 = 0;
+  for (let k = Math.max(d0 + 1, t - 17); k <= t; k++) {
+    if (!tk.has[k]) continue;
+    const r = tk.ret[k] - ds.mret[k];
+    s2 += r * r; n2++;
+  }
+  return {
+    px, prevClose, dayHigh: hi, dayLow: Number.isFinite(lo) ? lo : 0,
+    barsSinceHigh: t - hiAt, barsSinceLow: t - loAt, sigmaBarPct,
+    marketDayPct: mPrev > 0 && ds.mclose[t] > 0 ? (ds.mclose[t] / mPrev - 1) * 100 : 0,
+    realizedBarPct: n2 >= 4 ? Math.sqrt(s2 / n2) * 100 : 0,
+    dayMovePct: prevClose > 0 ? (px / prevClose - 1) * 100 - (mPrev > 0 && ds.mclose[t] > 0 ? (ds.mclose[t] / mPrev - 1) * 100 : 0) : 0,
+  };
+}
+
+// ---------- фильтр входа против события ----------
+// Все величины — по ценам до момента решения: px — текущая цена, dayHigh/dayLow — экстремумы сегодняшних свечей,
+// prevClose — закрытие прошлого торгового дня, sigmaBarPct — обычный размах 10-минутной свечи, barsSinceHigh/barsSinceLow — свечей с момента экстремума.
+export function counterTrendBlocked(side, ctx, policy = STRATEGY_POLICY) {
+  const g = policy.counterTrend;
+  if (!g || !ctx || !(ctx.px > 0) || !(ctx.prevClose > 0) || !(ctx.sigmaBarPct > 0)) return null;
+  const sigDay = ctx.sigmaBarPct * Math.sqrt(g.dayBars || 50);
+  const dayMovePct = ((ctx.px / ctx.prevClose) - 1) * 100 - (ctx.marketDayPct || 0);
+  const againstPct = side === 'short' ? dayMovePct : -dayMovePct;
+  const r1 = (v) => Math.round(v * 10) / 10;
+  // бумага уже ушла за день слишком далеко против позиции — движение вызвано событием, возврата к среднему не ждём
+  if (g.maxMovePct > 0 && againstPct >= g.maxMovePct) return `бумага уже ${side === 'short' ? 'выросла' : 'упала'} за день на ${r1(Math.abs(dayMovePct))}% к индексу (предел ${g.maxMovePct}%)`;
+  if (g.maxMoveSig > 0 && againstPct >= g.maxMoveSig * sigDay) return `движение за день ${r1(dayMovePct)}% к индексу больше ${g.maxMoveSig} дневных размахов бумаги`;
+  if (!(g.minDayMoveSig > 0)) return null;
+  if (side === 'short') {
+    if (!(dayMovePct >= g.minDayMoveSig * sigDay)) return null;
+    const offHighPct = ctx.dayHigh > 0 ? ((ctx.dayHigh - ctx.px) / ctx.dayHigh) * 100 : 0;
+    if (offHighPct < g.minPullbackSig * ctx.sigmaBarPct * Math.sqrt(g.pullbackBars || 6)) return `цена у дневного максимума после роста +${Math.round(dayMovePct * 10) / 10}% (откат ${Math.round(offHighPct * 100) / 100}%)`;
+    if ((ctx.barsSinceHigh ?? 99) < (g.stallBars || 0)) return `дневной максимум обновлялся ${ctx.barsSinceHigh * 10} мин назад после роста +${Math.round(dayMovePct * 10) / 10}%`;
+    return null;
+  }
+  if (!(dayMovePct <= -g.minDayMoveSig * sigDay)) return null;
+  const offLowPct = ctx.dayLow > 0 ? ((ctx.px - ctx.dayLow) / ctx.dayLow) * 100 : 0;
+  if (offLowPct < g.minPullbackSig * ctx.sigmaBarPct * Math.sqrt(g.pullbackBars || 6)) return `цена у дневного минимума после падения ${Math.round(dayMovePct * 10) / 10}% (отскок ${Math.round(offLowPct * 100) / 100}%)`;
+  if ((ctx.barsSinceLow ?? 99) < (g.stallBars || 0)) return `дневной минимум обновлялся ${ctx.barsSinceLow * 10} мин назад после падения ${Math.round(dayMovePct * 10) / 10}%`;
+  return null;
+}
+
+// Уровень стопа отмены идеи: обновление дневного экстремума против позиции с запасом buffer (в обычных размахах свечи).
+export function thesisStopPx(side, { dayHigh, dayLow, sigmaBarPct }, policy = STRATEGY_POLICY) {
+  const g = policy.thesisStop;
+  if (!g || !(sigmaBarPct > 0)) return 0;
+  const buf = Math.max(g.minBufPct ?? 0.3, g.bufSig * sigmaBarPct) / 100;
+  if (side === 'short') return dayHigh > 0 ? dayHigh * (1 + buf) : 0;
+  return dayLow > 0 ? dayLow * (1 - buf) : 0;
+}

package/server/model/research.js

@@ -9,8 +9,10 @@ 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, isRegimeShocked } from './edge.js';
+import { ENTRY_EDGE_MULT, TIER1_LIQUID_SYMBOLS, symbolEdgeMult, computeTokenEdgeMults, QUARANTINE_DECAY, isStockQuarantined, canEnterIntraday, shouldExitBeforeNight, isRegimeShocked, isMarketDown } from './edge.js';
 import { buildDividendCalendar, nextDividendAt, dividendRules, DIV_TAX } from './dividends.js';
+import { simulateStrategy, alignSeries } from './simulator.js';
+import { ensureLqdtHistory } from '../data/lqdt.js';
 
 const DAY = 86400000;
 const MSK = 3 * 3600000;
@@ -23,17 +25,7 @@ const tick = () => new Promise((r) => setImmediate(r));
 // Ключевые параметры для сравнения исследований (включая capital — он влияет на рубли)
 const REUSE_KEYS = ['modelAutoAdapt', 'modelType', 'modelHorizon', 'modelMinEdge', 'modelExitRatio', 'modelTopK', 'modelAllocMode', 'modelDirection', 'modelMarketFilter', 'modelShortFeePct', 'modelTrainDays', 'modelHistoryDays', 'modelEmbedDim', 'modelUseMacro', 'modelUseDividends', 'modelTextWeight', 'commissionPct', 'slippagePct', 'oosPct', 'capital'];
 
-// Фильтр падающего рынка: индекс Мосбиржи в среднесрочном нисходящем тренде (ниже уровня 10 торговых дней назад)
-// или в сильном локальном обвале (ниже уровня дня и 3 дней назад на >1%)
-export function isMarketDown(ds, t) {
-  const bpd = Math.max(1, Math.round(ds.barsPerDay || 54));
-  const d10 = bpd * 10, d3 = bpd * 3;
-  if (t < d3) return false;
-  const cur = ds.mclose[t], p3 = ds.mclose[t - d3], pd = ds.mclose[t - bpd];
-  if (!(cur > 0 && p3 > 0 && pd > 0)) return false;
-  if (t >= d10 && ds.mclose[t - d10] > 0 && cur < ds.mclose[t - d10] * 0.99) return true;
-  return cur < pd * 0.99 && cur < p3 * 0.99;
-}
+export { isMarketDown };
 
 // Версия обработки данных: при её смене прежние прогоны не считаются «такими же» (у старых её нет).
 // 8 — скорректированный спектр Марченко–Пастура (sigmaBulk) для 0 — Авто + динамическая концентрация слота (Conviction Sizing)
@@ -44,7 +36,9 @@ export function isMarketDown(ds, t) {
 // 13: полная докачка левого края истории свечей (раньше при уже накопленных свечах 2022 год не догружался)
 // 14: фиксация начала датасета современного 17-часового режима Мосбиржи (18.01.2024) и якоря фолдов после редомициляции (13.06.2024)
 // 15: защита от биржевых планок (high === low) и блокировка утренних шортов 2-го эшелона в первые 20 минут сессии (07:00–07:20 МСК)
-const DATA_VERSION = 15;
+// 16: главная оценка — симулятор с правилами живого контура (simulator.js), аварийный стоп 7%
+// 17: капитал в LQDT как залог, половинный размер 2-го эшелона, строки с плечом 3 и 5
+const DATA_VERSION = 17;
 
 const AUTO_LOCKED = { modelHorizon: 2.5, modelMinEdge: 2.5, modelExitRatio: 0.95 };
 function reuseParamsKey(params) {
@@ -808,6 +802,48 @@ async function run(runId, p, state) {
   emit({ stage: 'calc', pct: 96, text: 'Финальный пересчёт · стресс-тест исполнения (издержки, задержка входа, ликвидность, лоты, шорты)…' });
   await tick();
   const stress = runStressTest({ simulate, chosen, testTs, tsOf, mcurve, p, H });
+  // Главная честная оценка: те же прогнозы через симулятор с правилами живого контура (server/model/simulator.js)
+  emit({ stage: 'calc', pct: 97, text: 'Финальный пересчёт · симуляция с правилами живого контура (стопы, фиксация прибыли, фильтры, размер позиции)…' });
+  await tick();
+  try {
+    const wfLive = {
+      H, testTs,
+      pred: testTs.map((t) => preds[chosen].get(t)),
+      foldOf: testTs.map((_, k) => k),
+      foldSigma: testTs.map((t) => sigmaAt.get(t)),
+      foldMult: testTs.map((t) => multAt.get(t) || baseSymMult),
+      foldBeta: testTs.map((t) => betaAt.get(t)),
+    };
+    const lqdtRows = await ensureLqdtHistory().catch(() => []);
+    const lqdt = lqdtRows.length ? alignSeries(timeline, lqdtRows) : null;
+    const liveRows = [];
+    for (const lev of [1, 3, 5]) {
+      const lp = simulateStrategy({ ds, wf: wfLive, p, capital: p.capital, shortable: shortableSet(), divCal, lqdt, leverage: lev });
+      const yrs = Math.max(1 / 365, ((lp.curve.at(-1)?.ts || 0) - (lp.curve[0]?.ts || 0)) / (365.25 * 86400000));
+      const lastLpTs = lp.curve.at(-1)?.ts || 0;
+      const segOf = (fromTs) => {
+        const c = lp.curve.filter((x) => x.ts >= fromTs);
+        if (c.length < 2) return { returnPct: null };
+        const m = computeReport(lp.trades.filter((t) => t.entryTs >= fromTs), c, c[0].equity, 0).full;
+        return { returnPct: m.returnPct, profitFactor: m.profitFactor, maxDrawdownPct: m.maxDrawdownPct, trades: m.trades };
+      };
+      const full = computeReport(lp.trades, lp.curve, p.capital, 0).full;
+      const cagrPct = full.returnPct > -100 && yrs >= 0.25 ? round((Math.pow(1 + full.returnPct / 100, 1 / yrs) - 1) * 100, 1) : null;
+      liveRows.push({
+        key: lev === 1 ? 'liveRules' : `liveRulesL${lev}`,
+        label: lev === 1 ? 'Правила живого контура, без плеча (главная оценка)' : `Правила живого контура, плечо ${lev}`,
+        note: `исполнение и сопровождение как у реального счёта: входы на любой свече, аварийный стоп и фиксация прибыли внутри свечи, окна сессий, планки, перегрев, паузы, размер позиции и пределы на бумагу, издержки по эшелонам${lqdt ? ', капитал в LQDT как залог' : ''}${lev > 1 ? `; позиции 1-го эшелона ×${lev}` : ''}`,
+        full: { returnPct: full.returnPct, cagrPct, profitFactor: full.profitFactor, maxDrawdownPct: full.maxDrawdownPct, trades: full.trades, winRate: full.winRate, avgTradePct: full.avgTradePct, longPnl: round(lp.trades.filter((t) => t.side === 'long').reduce((a, t) => a + t.pnl, 0), 0), shortPnl: round(lp.trades.filter((t) => t.side === 'short').reduce((a, t) => a + t.pnl, 0), 0), afterTaxCagrPct: cagrPct === null ? null : round(cagrPct > 0 ? cagrPct * 0.87 : cagrPct, 1) },
+        costs: null,
+        last12: segOf(lastLpTs - 365 * 86400000),
+        last6: segOf(lastLpTs - 182 * 86400000),
+        exits: lp.stats,
+      });
+    }
+    stress.scenarios.unshift(...liveRows);
+  } catch (e) {
+    console.error('Симуляция правил живого контура:', e);
+  }
 
   emit({ stage: 'calc', pct: 98, text: `Финальный пересчёт · запись ${results[chosen].sim.trades.length} сделок и кривых капитала в базу…` });
   await tick();
@@ -837,7 +873,7 @@ async function run(runId, p, state) {
     neighbors,
   });
   delete report.stressPending;
-  const realistic = stress.scenarios.find((s) => s.key === 'realistic');
+  const realistic = stress.scenarios.find((s) => s.key === 'liveRules') || stress.scenarios.find((s) => s.key === 'realistic');
   report.stress = realistic ? { returnPct: realistic.full.returnPct, cagrPct: realistic.full.cagrPct, profitFactor: realistic.full.profitFactor, maxDrawdownPct: realistic.full.maxDrawdownPct, last12Pct: realistic.last12.returnPct } : null;
   finishRun(runId, { metrics: report, equity: downsample(results[chosen].sim.curve) });
   return report;