neuroalpha 0.6.8 → 0.6.10

package/package.json

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

package/server/brokers/index.js

@@ -2055,8 +2055,9 @@ export async function prepareBrokerOrders(id, { onlyEntries = false, scheduledBa
   const nowTs = Date.now();
   const effHorizon = autoAdapt ? 2.5 : params.modelHorizon;
   const H = barsFromHours(effHorizon);
-  const stepBars = autoAdapt ? Math.max(3, Math.floor(H / 5)) : H;
-  const timeOk = !autoAdapt || canEnterIntraday(nowTs, H, BAR_INTERVAL);
+  const holdBars = autoAdapt ? (STRATEGY_POLICY.holdBars ?? H) : H;
+  const stepBars = autoAdapt ? Math.max(3, Math.floor(holdBars / 5)) : holdBars;
+  const timeOk = !autoAdapt || canEnterIntraday(nowTs, holdBars, BAR_INTERVAL);
   const entryTsMap = acc.entryTsBySymbol || {};
   const exitCooldownMap = acc.exitCooldownBySymbol || {};
   const entryFailMap = acc.entryFailCooldownBySymbol || {};
@@ -2143,7 +2144,7 @@ export async function prepareBrokerOrders(id, { onlyEntries = false, scheduledBa
   const buyCands = !entryTimeOk ? [] : fc.rows.filter((r) => canBuyRow(r) && !isInCooldown(r.symbol) && !isDayBlocked(r.symbol, 'buy') && !isQuarantinedFor(r, 'buy') && !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' && entryTimeOk) ? fc.rows.filter((r) => canShortRow(r) && (!autoAdapt || canEnterIntraday(nowTs, H, BAR_INTERVAL, 'short', r.symbol)) && !isInCooldown(r.symbol) && !isDayBlocked(r.symbol, 'short') && !isQuarantinedFor(r, 'short') && !nb?.get(r.symbol)?.good)
+  const allShortSignals = (rawDir !== 'long' && entryTimeOk) ? fc.rows.filter((r) => canShortRow(r) && (!autoAdapt || canEnterIntraday(nowTs, holdBars, BAR_INTERVAL, 'short', r.symbol)) && !isInCooldown(r.symbol) && !isDayBlocked(r.symbol, 'short') && !isQuarantinedFor(r, 'short') && !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 = [];
@@ -2193,8 +2194,8 @@ export async function prepareBrokerOrders(id, { onlyEntries = false, scheduledBa
     const effEntryTs = Math.max(entryTsMap[sym] || 0, lastHistEntryTs);
     const heldMs = effEntryTs > 0 ? Math.max(0, nowTs - effEntryTs) : 0;
     const heldMin = heldMs / 60000;
-    const horizonMin = Math.max(90, effHorizon * 60);
-    // Плавный переход порога удержания от мягкого (0.35 до 45 мин) к динамическому плотному (0.95 × clamp(realizedBarPct / sigmaBarPct, 0.75, 1.25) к концу горизонта 2.5 ч)
+    const horizonMin = Math.max(90, holdBars * BAR_INTERVAL);
+    // Плавный переход порога удержания от мягкого (0.35 до 45 мин) к динамическому плотному (0.95 × clamp(realizedBarPct / sigmaBarPct, 0.75, 1.25) к концу глубины сопровождения)
     const symMult = r.edgeMult || symbolEdgeMult(sym);
     const holdRatio = exitHoldRatio(heldMin, horizonMin, {
       sigmaBarPct: Number(r.day?.sigmaBarPct || r.sigmaPct) || 0,
@@ -2584,7 +2585,7 @@ export async function prepareBrokerOrders(id, { onlyEntries = false, scheduledBa
     } else if (portfolioStale) {
       diagNote = `Сервис портфеля брокера временно отвечает с задержкой (${acc.lastSync?.staleReason || 'таймаут'}) — открытие новых позиций отложено до подтверждения остатков, текущие позиции и заявки под контролем.`;
     } else if (!timeOk) {
-      diagNote = `На свече ${fc.bar} вечернее окно новых входов закрыто: до конца сессии осталось меньше горизонта прогноза (${effHorizon} ч) — внутридневные сделки не переносятся через ночь.`;
+      diagNote = `На свече ${fc.bar} вечернее окно новых входов закрыто: до конца сессии осталось меньше глубины сопровождения (${round((holdBars * BAR_INTERVAL) / 60, 2)} ч) — внутридневные сделки не переносятся через ночь.`;
     } else if (edgeWarn) {
       diagNote = `На свече ${fc.bar} новые входы временно отложены: ${edgeWarn.toLowerCase()}.`;
     } else if ((newBuys.length || newShorts.length) && availRub < 1500) {
@@ -3483,8 +3484,9 @@ async function tickBrokerSchedule() {
           const autoAdapt = params.modelAutoAdapt !== false;
           const effHorizon = autoAdapt ? 2.5 : params.modelHorizon;
           const H = barsFromHours(effHorizon);
-          // Внутричасовой перехват H/5 (каждые 30 мин) активен в режимах VIP и Хозяин; на тарифах Инвестор и Профи шаг равен полному горизонту H
-          const stepBars = ((plan.allowVipBoost || plan.isOwner) && autoAdapt) ? Math.max(3, Math.floor(H / 5)) : H;
+          const holdBars = autoAdapt ? (STRATEGY_POLICY.holdBars ?? H) : H;
+          // Внутричасовой перехват holdBars/5 (каждые 30 мин) активен в режимах VIP и Хозяин; на тарифах Инвестор и Профи шаг равен полному окну holdBars
+          const stepBars = ((plan.allowVipBoost || plan.isOwner) && autoAdapt) ? Math.max(3, Math.floor(holdBars / 5)) : holdBars;
           const minStepMs = stepBars * BAR_MS;
           const rawLastFullWallTs = acc.lastFullStepWallTs || 0;
           const batchCreatedTs = acc.pendingBatch?.createdAt || 0;

package/server/index.js

@@ -146,10 +146,23 @@ function lanUrls() {
     .map((a) => `http://${a.address}:${PORT}`);
 }
 
+const shouldOpenBrowser = process.env.OPEN_BROWSER === '1'
+  || (process.env.OPEN_BROWSER !== '0'
+    && process.env.NO_BROWSER !== '1'
+    && !process.argv.includes('--no-browser')
+    && !process.execArgv.includes('--watch')
+    && !IS_CENTRAL
+    && (!IS_INSTANCE || IS_DESKTOP)
+    && (process.platform === 'win32' || process.platform === 'darwin' || Boolean(process.env.DISPLAY || process.env.WAYLAND_DISPLAY)));
+
 wss.on('error', () => {});
 server.on('error', (e) => {
-  if (e.code === 'EADDRINUSE') console.error(`Порт ${PORT} занят: сервер уже запущен? Клиент: http://localhost:${PORT}`);
-  else console.error(e);
+  if (e.code === 'EADDRINUSE') {
+    console.error(`Порт ${PORT} занят: сервер уже запущен? Клиент: http://localhost:${PORT}`);
+    if (shouldOpenBrowser) openBrowser(`http://localhost:${PORT}`);
+  } else {
+    console.error(e);
+  }
   process.exit(1);
 });
 
@@ -160,7 +173,7 @@ server.listen(PORT, LISTEN_HOST, () => {
   console.log(`ИИ-стратег: ${llm.enabled ? `${llm.provider} · ${llm.model}` : 'выключен (нет модели или ключа: Настройки → Модели ИИ)'}`);
   if (!LISTEN_HOST || LISTEN_HOST === '0.0.0.0') for (const url of lanUrls()) console.log(`  В локальной сети: ${url}`);
   console.log(`Клиент: http://localhost:${PORT}`);
-  if (process.env.OPEN_BROWSER === '1') openBrowser(`http://localhost:${PORT}`);
+  if (shouldOpenBrowser) openBrowser(`http://localhost:${PORT}`);
 });
 
 function openBrowser(url) {

package/server/model/dataset.js

@@ -239,13 +239,14 @@ export async function loadDataset({ interval = BAR_INTERVAL, fromTs, tillTs, use
     }
     return lastClosedBar >= latestClosedSlotTs;
   };
+  const cacheTtlMs = isTradingNow ? 4 * 60000 : 30 * 60000;
   const key = cacheKey(interval, fromTs, tillTs, useMacro, useDividends, localOnly);
   const hit = datasetCache.get(key);
-  if (hit && now - hit.at < 4 * 60000 && isCacheFreshForSlot(hit)) return hit.ds;
+  if (hit && now - hit.at < cacheTtlMs && isCacheFreshForSlot(hit)) return hit.ds;
   // Если в памяти уже есть более широкий датасет (не localOnly), который полностью покрывает запрошенный диапазон [fromTs … tillTs], возвращаем его
   const modeKey = JSON.stringify([interval, useMacro ? 1 : 0, useDividends ? (process.env.DIVIDENDS_MODE || 1) : 0]);
   for (const v of datasetCache.values()) {
-    if (v.modeKey === modeKey && (!v.localOnly || localOnly) && now - v.at < 4 * 60000 && Math.abs(v.fromTs - fromTs) < 2 * DAY && Math.abs(v.tillTs - tillTs) < 10 * 60000 && isCacheFreshForSlot(v)) {
+    if (v.modeKey === modeKey && (!v.localOnly || localOnly) && now - v.at < cacheTtlMs && Math.abs(v.fromTs - fromTs) < 2 * DAY && Math.abs(v.tillTs - tillTs) < 10 * 60000 && isCacheFreshForSlot(v)) {
       return v.ds;
     }
   }
@@ -263,7 +264,6 @@ export async function loadDataset({ interval = BAR_INTERVAL, fromTs, tillTs, use
   const symbols = vocab.map((v) => v.symbol);
   const raw = {};
   let done = 0;
-  const divStat = { applied: 0, skipped: 0 };
   const macroIds = useMacro ? MACRO.filter((m) => m.id !== 'BR').map((m) => m.id) : [];
   const all = [...symbols, 'IMOEX', ...macroIds];
   // акция дольше 2 минут — пропускаем и останавливаем её загрузку (скачанное останется в кэше)
@@ -284,9 +284,7 @@ export async function loadDataset({ interval = BAR_INTERVAL, fromTs, tillTs, use
           raw[s] = compact(rows);
           if (divs?.length) {
             // DIVIDENDS_MODE=raw — прежняя корректировка без сверки с ценой (только для сравнения результатов)
-            const st = adjustDividends(raw[s], divs, { verify: process.env.DIVIDENDS_MODE !== 'raw' });
-            divStat.applied += st.applied;
-            divStat.skipped += st.skipped;
+            adjustDividends(raw[s], divs, { verify: process.env.DIVIDENDS_MODE !== 'raw' });
           }
         })(),
         new Promise((_, rej) => {
@@ -306,7 +304,6 @@ export async function loadDataset({ interval = BAR_INTERVAL, fromTs, tillTs, use
       onProgress({ symbol: s, done: ++done, total: all.length });
     }
   });
-  if (useDividends) console.log(`[dataset] дивиденды: учтено ${divStat.applied}, пропущено (нет подтверждающего падения цены) ${divStat.skipped}`);
   // нефть Brent: склейка фьючерсов (много контрактов — отдельно от общего пула)
   if (useMacro) {
     try {

package/server/model/forecast.js

@@ -7,7 +7,7 @@ import { loadProfiles } from './profiles.js';
 import { ENTRY_EDGE_MULT, TIER2_EDGE_MULT, TIER1_LIQUID_SYMBOLS, symbolEdgeMult, computeTokenEdgeMults, REGIME_SHOCK_1D, REGIME_CRASH_30M, isStockQuarantined, canEnterIntraday, isMarketDown } from './edge.js';
 export { TIER1_LIQUID_SYMBOLS, symbolEdgeMult, computeTokenEdgeMults };
 import { newsForSymbols, blockingNews } from '../news/index.js';
-import { dayContext } from './policy.js';
+import { dayContext, STRATEGY_POLICY } from './policy.js';
 import { liveDividendGuard } from './dividends.js';
 import { fetchTbankRealtimePrices, getActiveAccountSignalFilters } from '../brokers/index.js';
 import { kvGet, kvSet } from '../db.js';
@@ -447,7 +447,8 @@ function buildPredictionRows(ds, p, idx, f, u, fitted, chosen, H, effMinEdge, au
     const isLimitUpLocked = isFlatLimitBar && excess1d > 0.05;
     const isLimitDownLocked = isFlatLimitBar && excess1d < -0.05;
     const barDecisionTs = ds.timeline[idx] || Date.now();
-    const isMorningOpenShortBlocked = autoAdapt && !canEnterIntraday(barDecisionTs, H, 10, 'short', tk.symbol);
+    const holdBars = autoAdapt ? (STRATEGY_POLICY.holdBars ?? H) : H;
+    const isMorningOpenShortBlocked = autoAdapt && !canEnterIntraday(barDecisionTs, holdBars, 10, 'short', tk.symbol);
     const isRegimeCrash = excess1d < -REGIME_SHOCK_1D || excess30m < -REGIME_CRASH_30M || isLimitDownLocked;
     const isRegimeSqueeze = excess1d > REGIME_SHOCK_1D || isLimitUpLocked;
     const isExtremeDip = Boolean(isRegimeCrash || (liveSnap && (lastMovePct < -EXTREME_BAR_MOVE_PCT || rawPriceMovePct < -EXTREME_BAR_MOVE_PCT)));
@@ -939,10 +940,15 @@ export async function forecastNow(input, { force = false, onProgress } = {}) {
       inflight.delete(key);
       inflightStartedAt.delete(key);
     }
+    const mskDate = new Date(now + MSK);
+    const mskDow = mskDate.getUTCDay();
+    const mskMins = mskDate.getUTCHours() * 60 + mskDate.getUTCMinutes();
+    const isTradingWindow = mskDow >= 1 && mskDow <= 5 && mskMins >= 7 * 60 && mskMins <= 23 * 60 + 55;
     const latestClosedSlotTs = Math.floor((now - BAR_MS) / BAR_MS) * BAR_MS;
     const curBarTs = baseState.ds?.timeline?.[baseState.last] || 0;
-    const barStale = curBarTs > 0 && curBarTs < latestClosedSlotTs && (now - baseState.dsLoadedAt >= 60000);
-    if ((now - baseState.dsLoadedAt >= 4 * 60000 || barStale) && !inflight.has(key)) {
+    const barStale = isTradingWindow && curBarTs > 0 && curBarTs < latestClosedSlotTs && (now - baseState.dsLoadedAt >= 60000);
+    const dsTtlMs = isTradingWindow ? 4 * 60000 : 30 * 60000;
+    if ((now - baseState.dsLoadedAt >= dsTtlMs || barStale) && !inflight.has(key)) {
       setImmediate(() => {
         refreshDatasetStateInBackground(p, key).catch(() => {});
       });

package/server/model/live.js

@@ -7,6 +7,7 @@ import { latestBarTs } from '../data/moex.js';
 import { loadDataset, barsFromHours, BAR_MS, BAR_INTERVAL } from './dataset.js';
 import { predictAt, lastClosedIndex } from './forecast.js';
 import { ENTRY_EDGE_MULT, symbolEdgeMult, QUARANTINE_DECAY, isStockQuarantined, canEnterIntraday, shouldExitBeforeNight, isRegimeShocked } from './edge.js';
+import { STRATEGY_POLICY } from './policy.js';
 import { computeReport, downsample } from './metrics.js';
 import { MODELS } from './models.js';
 import { blockingNews } from '../news/index.js';
@@ -395,7 +396,8 @@ class LiveEngine {
     const autoAdapt = p.modelAutoAdapt !== false;
     const effHorizon = autoAdapt ? 2.5 : p.modelHorizon;
     const H = barsFromHours(effHorizon);
-    const stepBars = autoAdapt ? Math.max(3, Math.floor(H / 5)) : H;
+    const holdBars = autoAdapt ? (STRATEGY_POLICY.holdBars ?? H) : H;
+    const stepBars = autoAdapt ? Math.max(3, Math.floor(holdBars / 5)) : holdBars;
     if (s.barsSinceRebalance >= stepBars) {
       await new Promise((r) => setImmediate(r));
       const r = await predictAt(ds, p, idx);
@@ -442,7 +444,7 @@ class LiveEngine {
         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);
+      const timeOk = !autoAdapt || canEnterIntraday(ts, holdBars, BAR_INTERVAL);
       const sideHeld = (side) => [...s.held].filter(([sym, h]) => h.side === side && !closing.has(sym));
       const nb = p.newsFilter ? blockingNews(6) : null;
       const take = (list, side, n) => {
@@ -462,7 +464,7 @@ class LiveEngine {
       };
       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) && (!autoAdapt || canEnterIntraday(ts, H, BAR_INTERVAL, 'short', x.symbol))).sort((a, b) => a.expected - b.expected);
+      const candS = (dir === 'long' || !timeOk) ? [] : r.rows.filter((x) => x.shortSignal && open(x) && (!autoAdapt || canEnterIntraday(ts, holdBars, BAR_INTERVAL, 'short', x.symbol))).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);

package/server/model/policy.js

@@ -38,6 +38,12 @@ export const STRATEGY_POLICY = Object.freeze({
   // в спокойный день (множитель до 0.75×) не вытряхивает позицию раньше времени, в турбулентный день (до 1.25×) быстрее фиксирует выход при затухании прогноза.
   // Проверка 09.11.2026 (06.2024–11.2026, плечо 3×): CAGR 58,6%/52,1% по половинам (весь 55,1%, PF 1,97, DD 6,4%) против 57,5%/48,1% (весь 52,6%, PF 1,89, DD 6,8%).
   exitVolClamp: Object.freeze([0.75, 1.25]),
+  // глубина сопровождения позиции и вечерней отсечки входов в 10-минутных свечах (13 свечей = 130 минут = 2 ч 10 м),
+  // при сохранении базового мульти-горизонта обучения модели (H = 15 свечей = 2,5 ч) и калибровки порога входа √H.
+  // Проверка 12.11.2026 (06.2024–11.2026, 59 051 свеча): улучшает итог и снижает риск на обеих половинах истории при любом плече
+  // (при плече 2×: CAGR 54,5%/40,6% по половинам, весь 47,2%, PF 1,87, DD 3,4%, худшая сделка −3,54% против 51,9%/40,3%, весь 45,8%, PF 1,82, DD 3,6%, худшая −4,39%;
+  //  при плече 3×: CAGR 65,9%/55,2% по половинам, весь 60,3%, PF 2,03, DD 6,0% против 61,9%/54,6%, весь 58,0%, PF 1,97, DD 6,3%).
+  holdBars: 13,
 });
 
 // ---------- окна начала и конца сессий (широкий спред, гэпы, аукционы) ----------

package/server/model/research.js

@@ -12,6 +12,7 @@ import { strategyDefaults } from '../config.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 { STRATEGY_POLICY, exitHoldRatio } from './policy.js';
 import { ensureLqdtHistory } from '../data/lqdt.js';
 
 const DAY = 86400000;
@@ -38,7 +39,8 @@ export { isMarketDown };
 // 15: защита от биржевых планок (high === low) и блокировка утренних шортов 2-го эшелона в первые 20 минут сессии (07:00–07:20 МСК)
 // 16: главная оценка — симулятор с правилами живого контура (simulator.js), аварийный стоп 7%
 // 17: капитал в LQDT как залог, половинный размер 2-го эшелона, строки с плечом 3 и 5
-const DATA_VERSION = 17;
+// 18: глубина сопровождения позиции и вечернего окна входов holdBars=13 (130 мин) во всех контурах симуляции
+const DATA_VERSION = 18;
 
 const AUTO_LOCKED = { modelHorizon: 2.5, modelMinEdge: 2.5, modelExitRatio: 0.95 };
 function reuseParamsKey(params) {
@@ -395,7 +397,9 @@ async function run(runId, p, state) {
     const stockPnl = new Float64Array(N), stockCnt = new Float64Array(N);
     const stockAllowed = (i, edgeRatio = 0) => !autoAdapt || !isStockQuarantined(stockCnt[i], stockPnl[i], edgeRatio);
     let curExitRatio = autoAdapt ? 0.95 : exitRatio;
-    const stepBars = autoAdapt ? Math.max(3, Math.floor(H / 5)) : H;
+    const holdBars = autoAdapt ? (STRATEGY_POLICY.holdBars ?? H) : H;
+    const horizonMin = Math.max(90, holdBars * BAR_INTERVAL);
+    const stepBars = autoAdapt ? Math.max(3, Math.floor(holdBars / 5)) : holdBars;
     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();
 
@@ -458,21 +462,21 @@ async function run(runId, p, state) {
           }
         }
       }
-      const timeOk = !autoAdapt || canEnterIntraday(barTs, H, BAR_INTERVAL);
+      const timeOk = !autoAdapt || canEnterIntraday(barTs, holdBars, BAR_INTERVAL);
       const canOpenAt = (i, edgeRatio = 0) => timeOk && !held.has(i) && !closedThisBar.has(i) && stockAllowed(i, edgeRatio) && canEnter(i, t);
       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') && canEnterIntraday(barTs, H, BAR_INTERVAL, 'short', tokens[i].symbol)));
+      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') && canEnterIntraday(barTs, holdBars, BAR_INTERVAL, 'short', tokens[i].symbol)));
       let order, entries;
       if (dir !== 'long') {
         const edge = (i) => pr[i] * sg[i] * Math.sqrt(H);
         const need = effMinEdge * 2 * realCost * needMult;
         const exitNeed = need * curExitRatio;
-        const earlyExitNeed = need * 0.35;
-        // держим позицию, пока ожидаемое движение выше порога выхода (первые два полушага — мягкий порог, чтобы не резать сделку от шума)
+        // держим позицию по единой рампе удержания exitHoldRatio (до 45 мин — 0.35, затем плавный подъём к 0.95 к концу глубины сопровождения horizonMin)
         for (const [i, h] of [...held]) {
           const e = edge(i);
           const barsHeld = tIn - h.entryT;
-          const req = (autoAdapt && barsHeld <= 2 * stepBars ? earlyExitNeed : exitNeed) * symMult[i];
+          const holdRatio = exitHoldRatio(barsHeld * BAR_INTERVAL, horizonMin, { baseEndRatio: curExitRatio, autoAdapt }, STRATEGY_POLICY);
+          const req = need * holdRatio * 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, false, shocked ? 'Защита от экстремального сквиза/обвала' : 'Прогноз ослаб');
@@ -513,11 +517,11 @@ async function run(runId, p, state) {
         const edge = (i) => pr[i] * sg[i] * Math.sqrt(H);
         const need = effMinEdge * 2 * realCost * needMult;
         const exitNeed = need * curExitRatio;
-        const earlyExitNeed = need * 0.35;
         for (const [i, h] of [...held]) {
           const e = edge(i);
           const barsHeld = tIn - h.entryT;
-          const req = (autoAdapt && barsHeld <= 2 * stepBars ? earlyExitNeed : exitNeed) * symMult[i];
+          const holdRatio = exitHoldRatio(barsHeld * BAR_INTERVAL, horizonMin, { baseEndRatio: curExitRatio, autoAdapt }, STRATEGY_POLICY);
+          const req = need * holdRatio * symMult[i];
           const shocked = autoAdapt && isRegimeShocked(ds, i, t, 'long');
           if (shocked || !(e > req) || !liquid(i, t)) closePos(i, h, tIn, false, shocked ? 'Защита от экстремального обвала' : '');
         }
@@ -1120,7 +1124,9 @@ async function runStabilityLoop(targetId, runRow, st) {
       const stockPnl = new Float64Array(N), stockCnt = new Float64Array(N);
       const stockAllowed = (i, edgeRatio = 0) => !autoAdapt || !isStockQuarantined(stockCnt[i], stockPnl[i], edgeRatio);
       const curExitRatio = autoAdapt ? 0.95 : exitRatio;
-      const stepBars = autoAdapt ? Math.max(3, Math.floor(H / 5)) : H;
+      const holdBars = autoAdapt ? (STRATEGY_POLICY.holdBars ?? H) : H;
+      const horizonMin = Math.max(90, holdBars * BAR_INTERVAL);
+      const stepBars = autoAdapt ? Math.max(3, Math.floor(holdBars / 5)) : holdBars;
       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) => {
@@ -1158,17 +1164,18 @@ async function runStabilityLoop(targetId, runRow, st) {
             if (shouldExitBeforeNight(barTs, tsOf(h.entryT), stepBars, BAR_INTERVAL)) closePos(i, h, tIn);
           }
         }
-        const timeOk = !autoAdapt || canEnterIntraday(barTs, H, BAR_INTERVAL);
+        const timeOk = !autoAdapt || canEnterIntraday(barTs, holdBars, BAR_INTERVAL);
         const canOpenAt = (i, edgeRatio = 0) => timeOk && !held.has(i) && !closedThisBar.has(i) && stockAllowed(i, edgeRatio) && 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') && canEnterIntraday(barTs, H, BAR_INTERVAL, 'short', tokens[i].symbol)));
+        const okShort = (i) => !divRule(i, t)?.blockShort && (!autoAdapt || (!isRegimeShocked(ds, i, t, 'short') && canEnterIntraday(barTs, holdBars, BAR_INTERVAL, 'short', tokens[i].symbol)));
         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;
+        const need = effMinEdge * 2 * realCost * ENTRY_EDGE_MULT, exitNeed = need * curExitRatio;
         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) * symMult[i];
+            const holdRatio = exitHoldRatio(barsHeld * BAR_INTERVAL, horizonMin, { baseEndRatio: curExitRatio, autoAdapt }, STRATEGY_POLICY);
+            const req = need * holdRatio * 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);
           }
@@ -1196,7 +1203,8 @@ async function runStabilityLoop(targetId, runRow, st) {
         } 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) * symMult[i];
+            const holdRatio = exitHoldRatio(barsHeld * BAR_INTERVAL, horizonMin, { baseEndRatio: curExitRatio, autoAdapt }, STRATEGY_POLICY);
+            const req = need * holdRatio * symMult[i];
             const shocked = autoAdapt && isRegimeShocked(ds, i, t, 'long');
             if (shocked || !(e > req) || !liquid(i, t)) closePos(i, h, tIn);
           }

package/server/model/simulator.js

@@ -36,8 +36,9 @@ export function simulateStrategy({ ds, wf, p, policy = STRATEGY_POLICY, capital
   const N = tokens.length;
   const H = wf.H;
   const sqrtH = Math.sqrt(H);
+  const holdBars = policy.holdBars ?? H;
   const bpd = Math.max(1, Math.round(ds.barsPerDay || 94));
-  const stepBars = plan === 'owner' || plan === 'vip' ? Math.max(3, Math.floor(H / 5)) : H;
+  const stepBars = plan === 'owner' || plan === 'vip' ? Math.max(3, Math.floor(holdBars / 5)) : holdBars;
   const K = policy.K ?? 4;
   const dir = p.modelDirection === 'long' ? 'long' : 'longshort';
   const realCost = (p.commissionPct + p.slippagePct) / 100;
@@ -48,7 +49,7 @@ export function simulateStrategy({ ds, wf, p, policy = STRATEGY_POLICY, capital
   const commission = p.commissionPct / 100;
   const cooldownBars = Math.round((policy.cooldownMin ?? 30) / BAR_INTERVAL);
   const stopCooldownBars = Math.round((policy.stopCooldownMin ?? 60) / BAR_INTERVAL);
-  const horizonMin = Math.max(90, (H * BAR_INTERVAL));
+  const horizonMin = Math.max(90, holdBars * BAR_INTERVAL);
   const slotW = policy.slotPct ?? (plan === 'owner' ? 0.45 : plan === 'vip' ? 0.40 : plan === 'pro' ? Math.min(0.28, 1.15 / 8) : Math.min(0.24, 1.05 / 5));
   const convMax = plan === 'owner' ? 1.65 : plan === 'vip' ? 1.30 : 1;
   const convK = plan === 'owner' ? 0.30 : 0.25;
@@ -275,7 +276,7 @@ export function simulateStrategy({ ds, wf, p, policy = STRATEGY_POLICY, capital
         dayDdBreachCount = 0;
       }
     }
-    const timeOk = !dayHalted && canEnterIntraday(decTs, H, BAR_INTERVAL) && !sessionEdgeWarning(decTs) && !nightNow && (policy.entryEveryBar !== false || isStep);
+    const timeOk = !dayHalted && canEnterIntraday(decTs, holdBars, BAR_INTERVAL) && !sessionEdgeWarning(decTs) && !nightNow && (policy.entryEveryBar !== false || isStep);
     if (timeOk) {
       const baseOk = (i, edgeRatio = 0) => !held.has(i) && cooldownUntil[i] <= t && liquid(i) && (!tokens[i].inIndex || tokens[i].inIndex[t] === 1) && !isStockQuarantined(stockCnt[i], stockPnl[i], edgeRatio) && (policy.tier2 !== false || isT1(i));
       const candL = [];
@@ -292,7 +293,7 @@ export function simulateStrategy({ ds, wf, p, policy = STRATEGY_POLICY, capital
         } else if (dir !== 'long' && e < -thrS) {
           if (!baseOk(i, (-e) / thrS)) continue;
           if (shortable && !shortable.has(tokens[i].symbol)) continue;
-          if (!canEnterIntraday(decTs, H, BAR_INTERVAL, 'short', tokens[i].symbol)) continue;
+          if (!canEnterIntraday(decTs, holdBars, BAR_INTERVAL, 'short', tokens[i].symbol)) continue;
           const fl = flags(i);
           if (fl.spikeBlock || divRule(i, t)?.blockShort) continue;
           candS.push(i);
@@ -335,7 +336,7 @@ export function simulateStrategy({ ds, wf, p, policy = STRATEGY_POLICY, capital
         const sigmaBarPct = sg[i] * 100;
         const ctx = dayContext(ds, i, t, sigmaBarPct);
         if (counterTrendBlocked(side, ctx, policy)) { stats.blockedCT++; continue; }
-        const stopPct = protectiveStopPct(side, { sigmaBarPct, realizedBarPct: ctx.realizedBarPct, horizonBars: H }, policy);
+        const stopPct = protectiveStopPct(side, { sigmaBarPct, realizedBarPct: ctx.realizedBarPct, horizonBars: holdBars }, policy);
         const conv = Math.min(convMax, Math.max(0.85, 0.80 + convK * (Math.abs(e) / need)));
         const tm = isT1(i) ? (policy.sizeMultT1 ?? lev) : (policy.sizeMultT2 ?? 1);
         if (!(tm > 0)) continue;