neuroalpha 0.6.7 → 0.6.9

package/package.json

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

package/public/app.js

@@ -1099,6 +1099,18 @@ async function loadForecast(force, silent = false) {
           if (!label) label = '⛔ новости';
         }
       }
+      if (r.blockedByQuarantine) {
+        reasons.push(r.blockedByQuarantine);
+        if (!label) label = '⛔ карантин';
+      }
+      if (r.blockedByCooldown) {
+        reasons.push(r.blockedByCooldown);
+        if (!label) label = '⛔ пауза';
+      }
+      if (r.blockedByCorridor) {
+        reasons.push(r.blockedByCorridor);
+        if (!label) label = '⛔ коридор';
+      }
       if (r.liquid === false) {
         reasons.push('Ставки запрещены из-за низкой ликвидности бумаги');
         if (!label) label = '⛔ неликвид';
@@ -3008,6 +3020,7 @@ function renderBrokers() {
             })() : ''}
             <span class="k">Контроль автоследования:</span><span class="v">${ls ? (ls.autoFollowDetected ? '<b class="neg">обнаружено ✕ (торговля заблокирована)</b>' : '<b class="pos">не используется ✓ (счёт допущен)</b>') : '<span class="muted">не проверено</span>'}</span>
             <span class="k">Предохранители и настройки:</span><span class="v">${capSpecHtml} · дневной стоп <b>−${fmtNum(a.maxDailyDrawdownPct, 1)}%</b> · плечо <b>${fmtNum(a.maxLeverage || 1, 1)}×</b> · стоп по общей просадке <b>${a.maxDrawdownPct > 0 ? `−${fmtNum(a.maxDrawdownPct, 0)}%` : 'выкл.'}</b> · отступ лимитки <b>${fmtNum(a.limitOffsetPct, 2)}%</b>${a.broker === 'tbank' ? ` · стоп-заявки у брокера: <b>${a.brokerStops ? `<span class="pos">вкл.</span> (${Object.keys(a.brokerStopBySymbol || {}).length} активн.)` : 'выкл.'}</b> · кэш в LQDT: <b>${a.cashSweep ? '<span class="pos">вкл.</span>' : 'выкл.'}</b>` : ''}${a.baseRunLabel ? ` · эксперимент <b>${esc(a.baseRunLabel)}</b>` : ''}</span>
+            ${a.quarantinedStocks?.length ? `<span class="k">Карантин бумаг:</span><span class="v" title="Временное ограничение после убыточных сделок (с затуханием ~15 торговых дней): обычные сигналы пропускаются, допускаются только усиленные сигналы ≥110% от порога">${a.quarantinedStocks.map((q) => `<b>${esc(q.symbol)}</b> <span class="neg">(${fmtNum(q.pnlPct, 2)}%, до ${esc(q.untilText)})</span>`).join(' · ')} <span class="muted small">— пропуск сигналов &lt;110% порога</span></span>` : ''}
             ${a.executionAudit ? `<span class="k">Реальные издержки (сверка):</span><span class="v" title="Сверка фактических сделок счёта (после отключения автоследования) с ориентиром стресс-теста">комиссия <b>${fmtNum(a.executionAudit.commPct, 3)}%</b>${a.executionAudit.slipAllPct !== null ? ` · проскальзывание к сигналу <b>${a.executionAudit.slipAllPct > 0 ? '+' : ''}${fmtNum(a.executionAudit.slipAllPct, 3)}%</b>${a.executionAudit.slipTier1Pct !== null ? ` (1-й эш. ${a.executionAudit.slipTier1Pct > 0 ? '+' : ''}${fmtNum(a.executionAudit.slipTier1Pct, 3)}%${a.executionAudit.slipTier2Pct !== null ? `, 2–3-й эш. ${a.executionAudit.slipTier2Pct > 0 ? '+' : ''}${fmtNum(a.executionAudit.slipTier2Pct, 3)}%` : ''})` : ''}` : ''} · итого <b class="${a.executionAudit.totalCostPerSidePct <= a.executionAudit.breakEvenTargetPct ? 'pos' : 'neg'}">${fmtNum(a.executionAudit.totalCostPerSidePct, 3)}%/сторона</b> (порог безубыточности стресс-теста ≤ ${fmtNum(a.executionAudit.breakEvenTargetPct, 3)}%, закрыто ${a.executionAudit.closedCount} поз.${a.executionAudit.profitFactorGross !== null ? `, PF до ком. ${fmtNum(a.executionAudit.profitFactorGross, 2)}` : ''})</span>` : ''}
           </div>
           ${hasPortfolioSnapshot ? `<div class="kpis">
@@ -3978,8 +3991,13 @@ const helpCache = new Map();
 // ---------- журнал исполнения по счёту ----------
 const EVENT_LABELS = {
   order_sent: ['заявка отправлена', ''],
-  order_expired: ['заявка снята (>12 мин)', 'muted'],
+  order_expired: ['заявка снята', 'muted'],
   spread_skip: ['пропуск входа (широкий спред)', 'mid'],
+  signal_skip: ['сигнал пропущен фильтром', 'mid'],
+  order_skip: ['вход не отправлен (устарел/вне окна)', 'muted'],
+  entry_day_block: ['блок входа до конца дня (коридор)', 'neg'],
+  profit_lock: ['фиксация прибыли (Take-Profit)', 'pos'],
+  news_exit: ['выход по важной новости', 'mid'],
   order_error: ['ошибка заявки', 'neg'],
   protective_stop: ['защитный стоп', 'neg'],
   protective_stop_error: ['ошибка защитного стопа', 'neg'],

package/server/brokers/index.js

@@ -11,7 +11,7 @@ import { getSettings, normalizeParams } from '../settings.js';
 import { latestBarTs, registerRealtimeCandleFetcher } 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, isStockQuarantined, canEnterIntraday, shouldExitBeforeNight } from '../model/edge.js';
+import { TIER1_LIQUID_SYMBOLS, QUARANTINE_OVERRIDE_RATIO, symbolEdgeMult, isStockQuarantined, computeAccountQuarantine, canEnterIntraday, shouldExitBeforeNight } from '../model/edge.js';
 import { liveDividendGuard } from '../model/dividends.js';
 import { STRATEGY_POLICY, sessionEdgeWarning, evaluateProfitLock, protectiveStopPct, exitHoldRatio, tierSizeMult, MAX_LEVERAGE } from '../model/policy.js';
 import { MODELS } from '../model/models.js';
@@ -489,10 +489,42 @@ function publicAccount(a) {
     };
   }
   const executionAudit = computeExecutionAudit(a);
+  const heldAlgoSet = new Set((a.lastSync?.positions || []).filter((p) => p.qty !== 0 && algoQtyFor(a, p.symbol, p.qty) !== 0).map((p) => p.symbol));
+  const quarantinedStocks = [...computeAccountQuarantine(a.lastHistory?.operations, heldAlgoSet).values()];
   // Токен брокера никогда не покидает сервер: в браузер, события WebSocket и ответы ИИ уходит только маска
   const { token: rawToken, ...rest } = a;
   const tok = String(rawToken || '').trim();
-  return { ...rest, lastSync, executionAudit, hasToken: Boolean(tok), tokenMask: tok ? `${tok.slice(0, 2)}…${tok.slice(-4)}` : '', baseRunLabel };
+  return { ...rest, lastSync, executionAudit, quarantinedStocks, hasToken: Boolean(tok), tokenMask: tok ? `${tok.slice(0, 2)}…${tok.slice(-4)}` : '', baseRunLabel };
+}
+
+export function getActiveAccountSignalFilters(nowTs = Date.now()) {
+  try {
+    const list = loadRawAccounts();
+    const acc = list.find((a) => a.mode === 'auto' || a.mode === 'confirm') || list[0];
+    if (!acc) return null;
+    const heldSet = new Set((acc.lastSync?.positions || []).filter((p) => p.qty !== 0 && algoQtyFor(acc, p.symbol, p.qty) !== 0).map((p) => p.symbol));
+    const quarantinedMap = computeAccountQuarantine(acc.lastHistory?.operations, heldSet, nowTs);
+    const cooldownMap = new Map();
+    for (const [sym, ts] of Object.entries(acc.exitCooldownBySymbol || {})) {
+      const remMin = Math.ceil((60 * 60000 - (nowTs - ts)) / 60000);
+      if (remMin > 0) cooldownMap.set(sym, `Пауза после недавнего выхода (${remMin} мин)`);
+    }
+    for (const [sym, ts] of Object.entries(acc.entryFailCooldownBySymbol || {})) {
+      const remMin = Math.ceil((5 * 60000 - (nowTs - ts)) / 60000);
+      if (remMin > 0 && !cooldownMap.has(sym)) {
+        const why = acc.entryFailReasonBySymbol?.[sym] || 'отказ шлюза брокера';
+        cooldownMap.set(sym, `Пауза ${remMin} мин после отказа (${why})`);
+      }
+    }
+    const todayMsk = new Date(nowTs + MSK).toISOString().slice(0, 10);
+    const dayBlockMap = new Map();
+    for (const [sym, b] of Object.entries(acc.entryDayBlockBySymbol || {})) {
+      if (b?.day === todayMsk) dayBlockMap.set(sym, b);
+    }
+    return { accountId: acc.id, accountName: acc.name, quarantinedMap, cooldownMap, dayBlockMap };
+  } catch {
+    return null;
+  }
 }
 
 export function brokersState() {
@@ -1802,6 +1834,29 @@ const isExitOrder = (o) => o.action === 'sell' || o.action === 'cover';
 const ACCOUNT_LOCK_TTL_MS = 75000;
 const accountBusyLocks = new Map(); // id -> { since, token }
 const entryImpulseWatch = new Map(); // `${accId}:${symbol}:${side}` -> { firstTs, lastTs, lastPx, extremePx }
+const loggedSignalSkips = new Map(); // `${accId}:${barKey}:${symbol}:${side}` -> ts
+
+function recordSignalSkipOnce(acc, fc, r, side, reason) {
+  if (!acc || !r?.symbol) return;
+  const barKey = String(fc?.barTs || String(fc?.bar || '').slice(0, 16) || Math.floor(Date.now() / (10 * 60000)));
+  const k = `${acc.id}:${barKey}:${r.symbol}:${side}`;
+  if (loggedSignalSkips.has(k)) return;
+  loggedSignalSkips.set(k, Date.now());
+  if (loggedSignalSkips.size > 600) {
+    const cutoff = Date.now() - 6 * 3600000;
+    for (const [ek, ets] of loggedSignalSkips) if (ets < cutoff) loggedSignalSkips.delete(ek);
+  }
+  const thr = side === 'short' ? r.shortThresholdPct : r.buyThresholdPct;
+  const ratioPct = thr > 0 ? Math.round((Math.abs(Number(r.expectedPct) || 0) / thr) * 100) : 0;
+  logBrokerEvent(acc, 'signal_skip', `${side === 'short' ? 'short' : 'buy'} ${r.symbol} (${r.expectedPct > 0 ? '+' : ''}${r.expectedPct}%, порог ${thr}%, ${ratioPct}%): ${reason}`);
+  logTradeDecision(acc, {
+    symbol: r.symbol,
+    action: 'skip',
+    refPrice: r.price,
+    reason,
+    decision: { bar: fc?.bar || '', side, expectedPct: r.expectedPct, thresholdPct: thr, ratioPct },
+  });
+}
 
 // Фильтр затухания минутного импульса перед входом (Impulse Exhaustion):
 // не даёт продавать в шорт посередине вертикально растущей минутной свечи (или покупать в полёт падающего ножа),
@@ -1940,7 +1995,7 @@ export async function prepareBrokerOrders(id, { onlyEntries = false, scheduledBa
   hub.emit({ type: 'trading:pulse', kind: 'broker_calc', ts: Date.now(), accountId: acc.id, name: acc.name, text: `Пересчёт заявок по счёту «${acc.name}»…` });
   // При плановом шаге снимаем старые неисполненные заявки со стакана, а при быстром доборе (onlyEntries) не трогаем уже стоящие свежие заявки!
   if (!onlyEntries && acc.token && acc.mode !== 'readonly' && acc.broker === 'tbank' && acc.lastSync?.activeOrders?.length > 0) {
-    await cancelBrokerOrder(id, 'all').catch(() => {});
+    await cancelBrokerOrder(id, 'all', 'не исполнена к плановому шагу').catch(() => {});
     list = loadRawAccounts();
     acc = list.find((x) => x.id === id) || acc;
   } else if (acc.token && (!acc.lastSync || Date.now() - (acc.lastSync.at || 0) > 45000)) {
@@ -2000,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 || {};
@@ -2022,33 +2078,20 @@ export async function prepareBrokerOrders(id, { onlyEntries = false, scheduledBa
   const todayMsk = new Date(nowTs + MSK).toISOString().slice(0, 10);
   const entryDayBlockMap = acc.entryDayBlockBySymbol || {};
   const isDayBlocked = (sym, side) => entryDayBlockMap[sym]?.day === todayMsk && entryDayBlockMap[sym]?.side === side;
-  // Самообучение на истории реальных сделок счёта (адаптивный карантин убыточных бумаг, единый с research.js):
-  // если за последние 15 торговых дней по бумаге накоплен убыток (< -1.2% за >= 2 сделки или одиночный пролив < -2.5%),
-  // временно исключаем такую бумагу из новых входов!
-  const quarantined = new Set();
-  if (autoAdapt && Array.isArray(acc.lastHistory?.operations)) {
-    const cutoffTs = nowTs - 21 * DAY;
-    const recentOps = acc.lastHistory.operations
-      .filter((op) => op.date >= cutoffTs && op.symbol && (op.kind === 'buy' || op.kind === 'sell' || op.kind === 'fee'))
-      .sort((a, b) => a.date - b.date);
-    const heldNowSet = new Set((acc.lastSync?.positions || []).filter((p) => p.qty !== 0).map((p) => p.symbol));
-    const statBySym = {};
-    for (const op of recentOps) {
-      if (heldNowSet.has(op.symbol)) continue; // считаем только полностью закрытые цепочки сделок
-      const st = statBySym[op.symbol] || (statBySym[op.symbol] = { buys: 0, sells: 0, buyRub: 0, netRub: 0 });
-      const pay = Number(op.paymentRub) || 0;
-      if (op.kind === 'buy') { st.buys++; st.buyRub += Math.abs(pay); st.netRub += pay; }
-      else if (op.kind === 'sell') { st.sells++; st.netRub += pay; }
-      else if (op.kind === 'fee') { st.netRub += pay; }
-    }
-    for (const [sym, st] of Object.entries(statBySym)) {
-      const closedRounds = Math.min(st.buys, st.sells);
-      const netPct = st.buyRub > 10000 ? (st.netRub / st.buyRub) : 0;
-      if (st.buyRub > 10000 && isStockQuarantined(closedRounds, netPct)) {
-        quarantined.add(sym);
-      }
-    }
-  }
+  // Самообучение на истории реальных сделок счёта (адаптивный карантин убыточных бумаг, единый с simulator.js / research.js):
+  // если по закрытым FIFO-кругам накоплен убыток (< -1.2% за >= 2 сделки или одиночный пролив < -2.5%, с затуханием QUARANTINE_DECAY),
+  // бумага пропускает обычные сигналы, но пропускает усиленные сигналы >= 110% индивидуального порога (QUARANTINE_OVERRIDE_RATIO).
+  const heldNowSet = new Set((acc.lastSync?.positions || []).filter((p) => p.qty !== 0 && algoQtyFor(acc, p.symbol, p.qty) !== 0).map((p) => p.symbol));
+  const quarantinedMap = autoAdapt
+    ? computeAccountQuarantine(acc.lastHistory?.operations, heldNowSet, nowTs, Number(params.commissionPct) || 0.04)
+    : new Map();
+  const isQuarantinedFor = (r, side) => {
+    const q = quarantinedMap.get(r.symbol);
+    if (!q) return false;
+    const reqEdge = side === 'short' ? reqShortEdgeOf(r.symbol) : reqBuyEdgeOf(r.symbol);
+    const edgeRatio = reqEdge > 0 ? Math.abs(Number(r.expectedPct) || 0) / reqEdge : 0;
+    return isStockQuarantined(q.cnt, q.pnlPct / 100, edgeRatio);
+  };
   const slots = dir === 'long' ? K : 2 * K;
   // Фильтр мощности слота по тарифу:
   // • Инвестор: 1 счёт до 1 млн ₽, только покупки (без шортов), консервативный слот до 24% капитала
@@ -2084,6 +2127,11 @@ export async function prepareBrokerOrders(id, { onlyEntries = false, scheduledBa
   const isRawSignalRow = (r) => (r.signal && r.expectedPct >= reqBuyEdgeOf(r.symbol)) || (rawDir !== 'long' && r.shortSignal && r.expectedPct <= -reqShortEdgeOf(r.symbol));
   const cooldownSkipped = fc.rows.filter((r) => isRawSignalRow(r) && isExitCooldown(r.symbol));
   const entryFailSkipped = fc.rows.filter((r) => isRawSignalRow(r) && !isExitCooldown(r.symbol) && isEntryFailCooldown(r.symbol));
+  const quarantineSkipped = fc.rows.filter((r) => {
+    if (!isRawSignalRow(r) || isInCooldown(r.symbol)) return false;
+    const side = r.expectedPct < 0 ? 'short' : 'buy';
+    return !isDayBlocked(r.symbol, side) && isQuarantinedFor(r, side);
+  });
   // Дивидендный предохранитель (общие правила с бэктестом, server/model/dividends.js)
   const divGuardOf = (sym, px) => liveDividendGuard(sym, Number(px) || specs[sym]?.lastPrice || 0, nowTs);
   const divBlocked = [];
@@ -2093,10 +2141,10 @@ export async function prepareBrokerOrders(id, { onlyEntries = false, scheduledBa
     || (isOnImpulseWatch(acc.id, r.symbol, 'buy', nowTs) && r.liquid && r.inIndex !== false && !r.buyBlockedByDip && !r.buyBlockedByOverheat && !r.buyBlockedByDiv && !r.buyBlockedByNews && r.expectedPct >= reqBuyEdgeOf(r.symbol) * IMPULSE_WATCH_HOLD_RATIO);
   const canShortRow = (r) => (r.shortSignal && r.expectedPct <= -reqShortEdgeOf(r.symbol))
     || (isOnImpulseWatch(acc.id, r.symbol, 'short', nowTs) && r.liquid && r.inIndex !== false && r.shortAllowed !== false && !r.shortBlockedBySqueeze && !r.shortBlockedByDiv && !r.shortBlockedByNews && r.expectedPct <= -reqShortEdgeOf(r.symbol) * IMPULSE_WATCH_HOLD_RATIO);
-  const buyCands = !entryTimeOk ? [] : fc.rows.filter((r) => canBuyRow(r) && !isInCooldown(r.symbol) && !isDayBlocked(r.symbol, 'buy') && !quarantined.has(r.symbol) && !nb?.get(r.symbol)?.bad)
+  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') && !quarantined.has(r.symbol) && !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 = [];
@@ -2146,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,
@@ -2537,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) {
@@ -2559,7 +2607,10 @@ export async function prepareBrokerOrders(id, { onlyEntries = false, scheduledBa
         : '';
       const dayBlocked = fc.rows.filter((r) => (r.signal && isDayBlocked(r.symbol, 'buy')) || (r.shortSignal && isDayBlocked(r.symbol, 'short')));
       const dayBlockNote = dayBlocked.length ? ` Сигнал ${dayBlocked.map((r) => `${r.symbol} (${r.expectedPct > 0 ? '+' : ''}${r.expectedPct}%)`).join(', ')} пропущен до конца дня: брокер отклонил вход из-за ценового коридора — бумага у планки Мосбиржи.` : '';
-      const cdNote = dayBlockNote + (cooldownSkipped.length ? ` Сигнал ${cooldownSkipped.map((r) => `${r.symbol} (${r.expectedPct > 0 ? '+' : ''}${r.expectedPct}%)`).join(', ')} временно пропущен: действует пауза (30–60 мин) после недавнего выхода из позиции, чтобы не перезаходить в отыгранный импульс и не платить повторную комиссию.` : '');
+      const qNote = quarantineSkipped.length
+        ? ` Сигнал ${quarantineSkipped.map((r) => { const q = quarantinedMap.get(r.symbol); const thr = r.expectedPct < 0 ? reqShortEdgeOf(r.symbol) : reqBuyEdgeOf(r.symbol); const pct = thr > 0 ? Math.round((Math.abs(r.expectedPct) / thr) * 100) : 0; return `${r.symbol} (${r.expectedPct > 0 ? '+' : ''}${r.expectedPct}%, ${pct}% порога, карантин ${q?.pnlPct ?? ''}% до ${q?.untilText || '—'})`; }).join(', ')} пропущен: по бумаге в карантине принимаются только усиленные сигналы ≥${Math.round(QUARANTINE_OVERRIDE_RATIO * 100)}% порога.`
+        : '';
+      const cdNote = dayBlockNote + qNote + (cooldownSkipped.length ? ` Сигнал ${cooldownSkipped.map((r) => `${r.symbol} (${r.expectedPct > 0 ? '+' : ''}${r.expectedPct}%)`).join(', ')} временно пропущен: действует пауза (30–60 мин) после недавнего выхода из позиции, чтобы не перезаходить в отыгранный импульс и не платить повторную комиссию.` : '');
       const buyThrT2 = round(minBuyEdgePct * symbolEdgeMult('__T2__'), 2);
       const shortThrT2 = round(minShortEdgePct * symbolEdgeMult('__T2__'), 2);
       const thrRangeStr = dir !== 'long'
@@ -2570,6 +2621,22 @@ export async function prepareBrokerOrders(id, { onlyEntries = false, scheduledBa
         : `На свече ${fc.bar} ни одна доступная бумага не превысила индивидуальный порог выгоды (${thrRangeStr})${noShortNote}.`;
     }
   }
+  if (entryTimeOk) {
+    for (const r of quarantineSkipped) {
+      const q = quarantinedMap.get(r.symbol);
+      recordSignalSkipOnce(acc, fc, r, r.expectedPct < 0 ? 'short' : 'buy', q?.reasonText || 'карантин счёта после убыточных сделок');
+    }
+    for (const r of cooldownSkipped) {
+      recordSignalSkipOnce(acc, fc, r, r.expectedPct < 0 ? 'short' : 'buy', 'пауза после недавнего выхода из позиции');
+    }
+    for (const r of entryFailSkipped) {
+      recordSignalSkipOnce(acc, fc, r, r.expectedPct < 0 ? 'short' : 'buy', `пауза 5 мин после ошибки приёма у брокера (${entryFailReasonMap[r.symbol] || 'отказ шлюза'})`);
+    }
+    for (const r of fc.rows) {
+      if (r.signal && isDayBlocked(r.symbol, 'buy')) recordSignalSkipOnce(acc, fc, r, 'buy', 'вход заблокирован до конца дня (граница ценового коридора 30099)');
+      if (r.shortSignal && isDayBlocked(r.symbol, 'short')) recordSignalSkipOnce(acc, fc, r, 'short', 'вход заблокирован до конца дня (граница ценового коридора 30099)');
+    }
+  }
   if (divBlocked.length) {
     diagNote = `${diagNote ? `${diagNote} ` : ''}Перед дивидендной отсечкой пропущены сигналы: ${[...new Set(divBlocked)].join(', ')}.`;
   }
@@ -3158,7 +3225,7 @@ export async function executeBrokerOrders(id, { _lockHeld = false } = {}) {
   }
 }
 
-export async function cancelBrokerOrder(id, orderId = null) {
+export async function cancelBrokerOrder(id, orderId = null, reason = null) {
   const list = loadRawAccounts();
   const acc = list.find((x) => x.id === id);
   if (!acc) throw new Error('Счёт не найден');
@@ -3168,22 +3235,44 @@ export async function cancelBrokerOrder(id, orderId = null) {
     const headers = { Authorization: `Bearer ${acc.token}`, 'Content-Type': 'application/json' };
     const accountId = acc.accountId || acc.lastSync?.accountId;
     if (!accountId) throw new Error('Не определён ID счёта');
+    const activeByOrdId = new Map((acc.lastSync?.activeOrders || []).map((o) => [String(o.orderId), o]));
     if (orderId && orderId !== 'all') {
       const r = await brokerFetch(`${base}/tinkoff.public.invest.api.contract.v1.OrdersService/CancelOrder`, {
         method: 'POST', headers, body: JSON.stringify({ accountId, orderId: String(orderId) }), timeoutMs: 10000,
       });
       if (!r.ok) throw new Error(`T-Invest CancelOrder: HTTP ${r.status}`);
+      const ao = activeByOrdId.get(String(orderId));
+      const remLots = ao ? Math.max(0, (Number(ao.lotsRequested) || 0) - (Number(ao.lotsExecuted) || 0)) : 0;
+      logBrokerEvent(acc, 'order_expired', `${ao?.symbol || 'заявка'}: снята (${reason || 'вручную'}${remLots ? `, ${remLots} л. по ${ao.price} ₽` : ''}) · ${orderId}`);
     } else {
       const rOrd = await brokerFetch(`${base}/tinkoff.public.invest.api.contract.v1.OrdersService/GetOrders`, {
         method: 'POST', headers, body: JSON.stringify({ accountId }), timeoutMs: 10000,
       });
       if (rOrd.ok) {
         const jOrd = await rOrd.json();
-        await Promise.all((jOrd.orders || []).map((o) => (
-          o.orderId ? brokerFetch(`${base}/tinkoff.public.invest.api.contract.v1.OrdersService/CancelOrder`, {
+        const rawOrders = jOrd.orders || [];
+        const isScheduledCleanup = reason === 'не исполнена к плановому шагу';
+        const nowMs = Date.now();
+        const toCancel = rawOrders.filter((o) => {
+          if (!o?.orderId) return false;
+          // Свежую заявку (< 90 с), только что выставленную быстрым добором перед границей шага, не сбиваем на первой же минуте
+          if (isScheduledCleanup && o.orderDate && nowMs - Date.parse(o.orderDate) < 90000) return false;
+          return true;
+        });
+        const metaCache = kvGet('tbankInstMeta') || {};
+        await Promise.all(toCancel.map((o) => (
+          brokerFetch(`${base}/tinkoff.public.invest.api.contract.v1.OrdersService/CancelOrder`, {
             method: 'POST', headers, body: JSON.stringify({ accountId, orderId: String(o.orderId) }), timeoutMs: 10000,
-          }).catch(() => null) : null
+          }).catch(() => null)
         )));
+        for (const o of toCancel) {
+          const ao = activeByOrdId.get(String(o.orderId));
+          const m = metaCache[o.ticker] || metaCache[o.figi] || metaCache[o.instrumentUid] || {};
+          const sym = ao?.symbol || m.ticker || o.ticker || o.figi || 'заявка';
+          const remLots = Math.max(0, (Number(o.lotsRequested) || 0) - (Number(o.lotsExecuted) || 0));
+          const px = ao?.price || round(qVal(o.initialSecurityPrice), 4);
+          logBrokerEvent(acc, 'order_expired', `${sym}: снята (${reason || 'вручную'}${remLots ? `, ${remLots} л.${px ? ` по ${px} ₽` : ''}` : ''}) · ${o.orderId}`);
+        }
       }
     }
     return syncBrokerAccount(id);
@@ -3395,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/edge.js

@@ -101,9 +101,125 @@ export function computeTokenEdgeMults(tokens, sigma, fromIdx = 0, tillIdx = 0) {
   return out;
 }
 
-// Затухание штрафных счётчиков карантина на 30-минутном шаге (период полураспада ~15 торговых дней: 0,9985^(15×33) ≈ 0,48)
+// Затухание штрафных счётчиков карантина на 30-минутном шаге (период полураспада ~15 торговых дней: 0,9985^(15×33) ≈ 0,48).
+// Сильный сигнал (≥110% от индивидуального порога входа) пробивает карантин: проверка 11.11.2026 в лаборатории правил (06.2024–11.2026)
+// показала рост CAGR на обеих половинах периода (при плече 3×: 61,9%/54,6% по половинам против 58,6%/52,1%, просадка 6,3% против 6,4%).
 export const QUARANTINE_DECAY = 0.9985;
-export const isStockQuarantined = (cnt, pnl) => (cnt >= 2 && pnl < -0.012) || pnl < -0.025;
+export const QUARANTINE_OVERRIDE_RATIO = 1.10;
+export const isStockQuarantined = (cnt, pnl, edgeRatio = 0) => {
+  if (edgeRatio >= QUARANTINE_OVERRIDE_RATIO) return false;
+  return (cnt >= 2 && pnl < -0.012) || pnl < -0.025;
+};
+
+// Расчёт карантина по истории реальных сделок счёта (FIFO-круги с затуханием QUARANTINE_DECAY и коэффициентом 0,90 на сделку —
+// единая формула с simulator.js, research.js и live.js, без искажения от частичных исполнений и продаж старого портфеля).
+const NON_STOCK_TICKERS = new Set(['LQDT', 'TMON@', 'TMON', 'SBMM']);
+export function computeAccountQuarantine(operations, heldSymbols = new Set(), nowTs = Date.now(), feeSidePct = 0.04) {
+  const out = new Map();
+  if (!Array.isArray(operations) || !operations.length) return out;
+  const cutoffTs = nowTs - 45 * DAY;
+  const recent = operations
+    .filter((o) => o && o.date >= cutoffTs && o.symbol && !NON_STOCK_TICKERS.has(o.symbol) && (o.kind === 'buy' || o.kind === 'sell') && o.qty > 0 && o.price > 0)
+    .sort((a, b) => a.date - b.date);
+  if (!recent.length) return out;
+  const roundTripFee = 2 * ((Number(feeSidePct) || 0.04) / 100);
+  const queues = new Map();
+  const rawTrips = [];
+  for (const op of recent) {
+    const sym = op.symbol;
+    const dir = op.kind === 'buy' ? 'long' : 'short';
+    let q = queues.get(sym);
+    // Несопоставленные остатки старше 18 часов — это односторонние продажи/покупки начального портфеля, а не внутридневные сделки
+    if (q && q.lots.length) {
+      q.lots = q.lots.filter((l) => op.date - l.ts <= 18 * 3600000);
+      if (!q.lots.length) q = null;
+    }
+    if (!q || !q.lots.length || q.side === dir) {
+      if (!q || !q.lots.length) q = { side: dir, lots: [] };
+      q.lots.push({ qty: op.qty, px: op.price, ts: op.date });
+      queues.set(sym, q);
+    } else {
+      let rem = op.qty;
+      while (rem > 0 && q.lots.length) {
+        const e = q.lots[0];
+        const take = Math.min(rem, e.qty);
+        const gross = q.side === 'long' ? (op.price / e.px - 1) : (1 - op.price / e.px);
+        const net = gross - roundTripFee;
+        rawTrips.push({ symbol: sym, side: q.side, alloc: take * e.px, entryTs: e.ts, exitTs: op.date, net });
+        e.qty -= take;
+        rem -= take;
+        if (e.qty <= 0) q.lots.shift();
+      }
+      if (rem > 0) {
+        q = { side: dir, lots: [{ qty: rem, px: op.price, ts: op.date }] };
+        queues.set(sym, q);
+      }
+    }
+  }
+  // Объединяем частичные исполнения одной и той же заявки (вход или выход в пределах 5 минут) в один круг сделки
+  const mergedBySym = new Map();
+  for (const t of rawTrips) {
+    if (t.alloc < 2000) continue;
+    const list = mergedBySym.get(t.symbol) || [];
+    const prev = list.length ? list[list.length - 1] : null;
+    if (prev && prev.side === t.side && (Math.abs(t.exitTs - prev.exitTs) <= 5 * 60000 || Math.abs(t.entryTs - prev.entryTs) <= 5 * 60000)) {
+      const totAlloc = prev.alloc + t.alloc;
+      prev.net = (prev.net * prev.alloc + t.net * t.alloc) / totAlloc;
+      prev.alloc = totAlloc;
+      prev.exitTs = Math.max(prev.exitTs, t.exitTs);
+    } else {
+      list.push({ ...t });
+      mergedBySym.set(t.symbol, list);
+    }
+  }
+  const STEP_MS = 30 * 60000;
+  const TRADING_SHARE = 15.5 / 24;
+  for (const [sym, trips] of mergedBySym) {
+    if (heldSymbols && heldSymbols.has(sym)) continue;
+    let pnl = 0, cnt = 0, prevExitTs = 0;
+    for (const t of trips) {
+      if (prevExitTs > 0) {
+        const dtSteps = Math.max(0, (t.exitTs - prevExitTs) / STEP_MS) * TRADING_SHARE;
+        const d = Math.pow(QUARANTINE_DECAY, dtSteps);
+        pnl *= d;
+        cnt *= d;
+      }
+      pnl = pnl * 0.90 + t.net;
+      cnt += 1;
+      prevExitTs = t.exitTs;
+    }
+    if (prevExitTs > 0) {
+      const tailSteps = Math.max(0, (nowTs - prevExitTs) / STEP_MS) * TRADING_SHARE;
+      const dTail = Math.pow(QUARANTINE_DECAY, tailSteps);
+      pnl *= dTail;
+      cnt *= dTail;
+    }
+    if (isStockQuarantined(cnt, pnl, 0)) {
+      let expSteps = 0;
+      for (let s = 1; s <= 2500; s++) {
+        const d = Math.pow(QUARANTINE_DECAY, s);
+        if (!isStockQuarantined(cnt * d, pnl * d, 0)) { expSteps = s; break; }
+      }
+      const untilTs = Math.round(nowTs + expSteps * STEP_MS / TRADING_SHARE);
+      const untilIso = new Date(untilTs + 3 * 3600000).toISOString();
+      const untilText = `${untilIso.slice(8, 10)}.${untilIso.slice(5, 7)}`;
+      const pnlPct = Math.round(pnl * 10000) / 100;
+      const lastTrip = trips[trips.length - 1];
+      out.set(sym, {
+        symbol: sym,
+        cnt: Math.round(cnt * 100) / 100,
+        pnlPct,
+        tradesCount: trips.length,
+        lastExitTs: prevExitTs,
+        lastSide: lastTrip?.side || 'long',
+        untilTs,
+        untilText,
+        reasonText: `Карантин счёта после убытка ${pnlPct}% (до ${untilText} пропускаются сигналы слабее ${Math.round(QUARANTINE_OVERRIDE_RATIO * 100)}% порога)`,
+      });
+    }
+  }
+  return out;
+}
 
 // Граница вечерней сессии Мосбиржи (последняя 10-минутная свеча 23:40–23:50 МСК):
 // не открываем новые внутридневные позиции, когда до конца торгов остаётся меньше горизонта H, и закрываем позиции перед ночью

package/server/model/forecast.js

@@ -4,12 +4,12 @@ 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 { ENTRY_EDGE_MULT, TIER2_EDGE_MULT, TIER1_LIQUID_SYMBOLS, symbolEdgeMult, computeTokenEdgeMults, REGIME_SHOCK_1D, REGIME_CRASH_30M, canEnterIntraday, isMarketDown } from './edge.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 } from '../brokers/index.js';
+import { fetchTbankRealtimePrices, getActiveAccountSignalFilters } from '../brokers/index.js';
 import { kvGet, kvSet } from '../db.js';
 import { hub } from '../hub.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)));
@@ -504,12 +505,29 @@ function buildPredictionRows(ds, p, idx, f, u, fitted, chosen, H, effMinEdge, au
   return { f, u, fitted, chosen, threshold, needL, needS, marketDown: bear, rows };
 }
 
-// Новости и защитные блокировки (сквиз, запрет шорта у брокера, дивидендная отсечка, новостной фильтр) — в прогнозе «сейчас»
+// Новости и защитные блокировки (сквиз, запрет шорта у брокера, дивидендная отсечка, новостной фильтр, карантин/пауза счёта) — в прогнозе «сейчас»
+function formatNearSignalsList(episodesMap) {
+  return [...episodesMap.values()]
+    .sort((a, b) => (b.lastBarTs - a.lastBarTs) || (b.peakRatioPct - a.peakRatioPct))
+    .slice(0, 120)
+    .map((ep) => {
+      const cleanReasons = ep.status === 'signal' ? [] : (ep.reasons || []);
+      const gapPct = round(Math.max(0, ep.thresholdPct - Math.abs(ep.peakExpectedPct)), 2);
+      const reasonText = ep.status === 'signal'
+        ? 'Порог пройден — сигнал сформирован'
+        : ep.status === 'blocked'
+          ? `Порог пройден, но вход закрыт: ${cleanReasons.join(' · ') || 'защитный фильтр'}`
+          : `Ниже порога на ${gapPct}%${cleanReasons.length ? ` (также активен фильтр: ${cleanReasons.join(' · ')})` : ''}`;
+      return { ...ep, reasons: cleanReasons, gapPct, reasonText };
+    });
+}
+
 function withNews(result, p) {
   const nm = p.newsEnabled ? newsForSymbols(24) : null;
   const nb = p.newsFilter ? blockingNews(6) : null;
   const shortableMap = kvGet('tbankShortableMap')?.map || null;
   const nowTs = Date.now();
+  const accFilters = getActiveAccountSignalFilters(nowTs);
   const baseBuyThr = result.buyThresholdPct ?? result.thresholdPct ?? 0.40;
   const baseShortThr = result.shortThresholdPct ?? result.thresholdPct ?? 0.50;
   if (result.buyThresholdTier2Pct === undefined) result.buyThresholdTier2Pct = round(Math.max(baseBuyThr * TIER2_EDGE_MULT, 0.30), 3);
@@ -582,29 +600,124 @@ function withNews(result, p) {
     const ratio = effThr > 0 ? Math.abs(Number(r.expectedPct) || 0) / effThr : 0;
     r.thresholdRatioPct = Math.round(ratio * 100);
     r.crossedThreshold = ratio >= 1;
+
+    // Учёт фильтров живого счёта (карантин после убыточных сделок, пауза после выхода, дневной блок 30099):
+    const qInfo = accFilters?.quarantinedMap?.get(r.symbol);
+    if (qInfo) {
+      r.quarantineInfo = qInfo;
+      if (isStockQuarantined(qInfo.cnt, qInfo.pnlPct / 100, ratio)) {
+        r.blockedByQuarantine = qInfo.reasonText;
+        r.signal = false;
+        r.shortSignal = false;
+      } else {
+        delete r.blockedByQuarantine;
+      }
+    } else {
+      delete r.quarantineInfo;
+      delete r.blockedByQuarantine;
+    }
+    const cdWhy = accFilters?.cooldownMap?.get(r.symbol);
+    if (cdWhy) {
+      r.blockedByCooldown = cdWhy;
+      r.signal = false;
+      r.shortSignal = false;
+    } else {
+      delete r.blockedByCooldown;
+    }
+    const wantSide = r.expectedPct < 0 ? 'short' : 'buy';
+    const dayBlk = accFilters?.dayBlockMap?.get(r.symbol);
+    if (dayBlk && dayBlk.side === wantSide) {
+      r.blockedByCorridor = 'Вход заблокирован до конца дня: цена у границы ценового коридора Мосбиржи (код 30099)';
+      if (wantSide === 'buy') r.signal = false;
+      else r.shortSignal = false;
+    } else {
+      delete r.blockedByCorridor;
+    }
   }
-  // Если в сохранённом кэше список был обрезан прежним лимитом (40), пересобираем полный список из накопленных записей
+  // Если в сохранённом кэше список ещё не загружен или был обрезан, восстанавливаем его
   const saved = !nearSignalsCache.episodesMap.size ? kvGet('nearSignalsLog') : null;
-  if (saved?.entries?.length && (saved.list?.length || 0) < Math.min(120, saved.entries.length)) {
+  if (saved?.entries?.length && !nearSignalsCache.episodesMap.size) {
     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 };
+  // Живое пополнение журнала сегодняшними внутрисвечными сигналами и почти-сигналами (чтобы входы внутри 10-мин свечи сразу попадали в журнал)
+  if (nearSignalsCache.episodesMap.size > 0 && Array.isArray(result.rows)) {
+    const liveTs = result.liveTs || nowTs;
+    const slotBarTs = Math.floor(liveTs / BAR_MS) * BAR_MS;
+    const barMskIso = new Date(slotBarTs + MSK).toISOString();
+    const dayStr = barMskIso.slice(0, 10);
+    const timeStr = barMskIso.slice(11, 16);
+    const rankOf = (st) => (st === 'signal' ? 3 : st === 'blocked' ? 2 : 1);
+    let liveUpdated = false;
+    for (const row of result.rows) {
+      if (row.inIndex === false || (row.thresholdRatioPct || 0) < 75) continue;
+      const side = row.expectedPct < 0 ? 'short' : 'long';
+      const thr = side === 'short' ? row.shortThresholdPct : row.buyThresholdPct;
+      const crossed = Boolean(row.crossedThreshold);
+      const reasons = [];
+      if (side === 'short') {
+        if (p.modelDirection === 'long') reasons.push('режим «только в рост»');
+        if (row.shortBlockedBySqueeze) reasons.push('защита от сквиза');
+        if (row.shortBlockedByTime) reasons.push('вне окна шорта по времени сессии');
+        if (row.shortBlockedByBroker) reasons.push('запрет шорта у брокера');
+        if (row.shortBlockedByDiv) reasons.push(`отсечка дивидендов (${row.shortBlockedByDiv})`);
+        if (row.shortBlockedByNews) reasons.push(`фильтр новостей (${row.shortBlockedByNews})`);
+      } else {
+        if (row.buyBlockedByDip) reasons.push('защита от обвала свечи');
+        if (row.buyBlockedByOverheat) reasons.push(`перегрев +${row.buyBlockedByOverheat}%`);
+        if (row.buyBlockedByDiv) reasons.push(`отсечка дивидендов (${row.buyBlockedByDiv})`);
+        if (row.buyBlockedByNews) reasons.push(`фильтр новостей (${row.buyBlockedByNews})`);
+      }
+      if (row.blockedByQuarantine) reasons.push(`карантин счёта (${row.quarantineInfo?.pnlPct ?? ''}%)`);
+      if (row.blockedByCooldown) reasons.push(row.blockedByCooldown);
+      if (row.blockedByCorridor) reasons.push('ценовой коридор 30099');
+      if (row.liquid === false) reasons.push('низкая ликвидность');
+      const isSignal = crossed && reasons.length === 0 && Boolean(side === 'long' ? row.signal : row.shortSignal);
+      const status = isSignal ? 'signal' : crossed ? 'blocked' : 'near';
+      const pctNow = row.thresholdRatioPct || 0;
+      const epKey = `${dayStr}:${row.symbol}:${side}`;
+      const prev = nearSignalsCache.episodesMap.get(epKey);
+      if (!prev) {
+        nearSignalsCache.episodesMap.set(epKey, {
+          day: dayStr, firstBar: timeStr, lastBar: timeStr, firstBarTs: slotBarTs, lastBarTs: slotBarTs,
+          peakBar: timeStr, barsCount: 1, symbol: row.symbol, name: row.name, side, price: row.price,
+          peakExpectedPct: row.expectedPct, thresholdPct: thr, peakRatioPct: pctNow,
+          status, reasons: status === 'signal' ? [] : reasons,
         });
+        liveUpdated = true;
+      } else {
+        if (slotBarTs > prev.lastBarTs) {
+          prev.lastBar = timeStr;
+          prev.lastBarTs = slotBarTs;
+          prev.barsCount += 1;
+          liveUpdated = true;
+        }
+        if (rankOf(status) > rankOf(prev.status) || (rankOf(status) === rankOf(prev.status) && pctNow > prev.peakRatioPct)) {
+          prev.peakExpectedPct = row.expectedPct;
+          prev.thresholdPct = thr;
+          prev.peakRatioPct = Math.max(prev.peakRatioPct, pctNow);
+          prev.peakBar = timeStr;
+          prev.price = row.price;
+          prev.status = status;
+          prev.reasons = status === 'signal' ? [] : (reasons.length ? reasons : prev.reasons);
+          liveUpdated = true;
+        }
+      }
     }
-    const savedNear = nearSignalsCache.list?.length ? nearSignalsCache.list : (kvGet('nearSignalsLog')?.list || []);
-    result.nearSignals = savedNear;
+    if (liveUpdated) {
+      nearSignalsCache.list = formatNearSignalsList(nearSignalsCache.episodesMap);
+      kvSet('nearSignalsLog', {
+        key: nearSignalsCache.key,
+        scannedBarTs: nearSignalsCache.scannedBarTs,
+        entries: [...nearSignalsCache.episodesMap.entries()],
+        list: nearSignalsCache.list,
+      });
+    }
+  }
+  if (nearSignalsCache.episodesMap.size && !nearSignalsCache.list.length) {
+    nearSignalsCache.list = formatNearSignalsList(nearSignalsCache.episodesMap);
+  }
+  if (nearSignalsCache.list.length || !Array.isArray(result.nearSignals) || !result.nearSignals.length) {
+    result.nearSignals = nearSignalsCache.list.length ? nearSignalsCache.list : (kvGet('nearSignalsLog')?.list || []);
   }
   return result;
 }
@@ -624,7 +737,7 @@ async function updateNearSignalsJournal(ds, p, last, key) {
         key,
         scannedBarTs: saved.scannedBarTs,
         episodesMap: new Map(saved.entries),
-        list: saved.list || [],
+        list: [],
       };
     } else {
       nearSignalsCache = { key, scannedBarTs: 0, episodesMap: new Map(), list: [] };
@@ -695,7 +808,7 @@ async function updateNearSignalsJournal(ds, p, last, key) {
           thresholdPct: thr,
           peakRatioPct: Math.round(ratio * 100),
           status,
-          reasons,
+          reasons: status === 'signal' ? [] : reasons,
         });
       } else {
         prev.lastBar = timeStr;
@@ -709,14 +822,14 @@ async function updateNearSignalsJournal(ds, p, last, key) {
           prev.peakBar = timeStr;
           prev.price = row.price;
           prev.status = status;
-          if (reasons.length) prev.reasons = reasons;
+          prev.reasons = status === 'signal' ? [] : (reasons.length ? reasons : prev.reasons);
         } else if (pctNow > prev.peakRatioPct) {
           prev.peakExpectedPct = row.expectedPct;
           prev.thresholdPct = thr;
           prev.peakRatioPct = pctNow;
           prev.peakBar = timeStr;
         }
-        if (reasons.length && !prev.reasons?.length) prev.reasons = reasons;
+        if (prev.status !== 'signal' && reasons.length && !prev.reasons?.length) prev.reasons = reasons;
       }
     }
     nearSignalsCache.scannedBarTs = barTs;
@@ -724,18 +837,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, 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 list = formatNearSignalsList(nearSignalsCache.episodesMap);
     nearSignalsCache.list = list;
     kvSet('nearSignalsLog', {
       key,
@@ -838,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);
@@ -415,9 +417,8 @@ class LiveEngine {
       };
       const exitRatio = autoAdapt ? 0.95 : Number(p.modelExitRatio ?? 0.5);
       const mktDown = p.modelMarketFilter === 'ma' && r.marketDown;
-      const quarantined = new Set();
+      const stMap = new Map();
       if (autoAdapt && s.trades.length >= 1) {
-        const stMap = new Map();
         for (const t of s.trades) {
           // затухание прошлых штрафов с возрастом сделки (~15 торговых дней полураспада)
           const ageSteps = Math.max(0, (ts - (t.exitTs || ts)) / (stepBars * BAR_MS));
@@ -427,7 +428,6 @@ class LiveEngine {
           cur.cnt += wDecay;
           stMap.set(t.symbol, cur);
         }
-        for (const [sym, st] of stMap) if (isStockQuarantined(st.cnt, st.pnl)) quarantined.add(sym);
       }
       for (const [sym, h] of s.held) {
         if (autoAdapt && shouldExitBeforeNight(ts, h.entryTs, stepBars, BAR_INTERVAL)) {
@@ -444,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) => {
@@ -452,7 +452,10 @@ class LiveEngine {
         const out = [];
         for (const x of list) {
           if (out.length >= lim) break;
-          if (quarantined.has(x.symbol)) { step.decisions.push({ action: 'skip', symbol: x.symbol, text: 'Пропущена: в карантине после серии убыточных сделок' }); continue; }
+          const qSt = stMap.get(x.symbol);
+          const thrPct = side === 'buy' ? (x.buyThresholdPct || r.buyThresholdPct || r.thresholdPct) : (x.shortThresholdPct || r.shortThresholdPct || r.thresholdPct);
+          const edgeRatio = thrPct > 0 ? Math.abs(x.expectedPct || 0) / thrPct : 0;
+          if (qSt && isStockQuarantined(qSt.cnt, qSt.pnl, edgeRatio)) { step.decisions.push({ action: 'skip', symbol: x.symbol, text: 'Пропущена: в карантине после серии убыточных сделок' }); continue; }
           const b = nb?.get(x.symbol)?.[side === 'buy' ? 'bad' : 'good'];
           if (b) { step.decisions.push({ action: 'skip', symbol: x.symbol, text: `Пропущена: ${side === 'buy' ? 'плохая' : 'хорошая'} новость — ${b.gist}` }); continue; }
           out.push(x);
@@ -461,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

@@ -393,7 +393,7 @@ async function run(runId, p, state) {
     const countSide = (side) => [...held.values()].filter((h) => h.side === side).length;
     // Самообучение правил по прошлым закрытым сделкам (временный карантин «акций-убийц» с затуханием и авто-калибровка порога выхода)
     const stockPnl = new Float64Array(N), stockCnt = new Float64Array(N);
-    const stockAllowed = (i) => !autoAdapt || !isStockQuarantined(stockCnt[i], stockPnl[i]);
+    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 maxSlotWeight = dir === 'long' ? Math.min(0.58, Math.max(1 / K, 1.8 / K)) : Math.min(0.75, 3.0 / (2 * K));
@@ -459,7 +459,7 @@ 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 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)));
       let order, entries;
@@ -480,8 +480,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 || !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 candL = (mktDown || !timeOk) ? [] : [...pr.keys()].filter((i) => edge(i) > needL * symMult[i] && canOpenAt(i, edge(i) / (needL * symMult[i])) && okLong(i)).sort((a, b) => pr[b] - pr[a]);
+        const candS = !timeOk ? [] : [...pr.keys()].filter((i) => edge(i) < -needS * symMult[i] && canOpenAt(i, (-edge(i)) / (needS * symMult[i])) && okShort(i)).sort((a, b) => pr[a] - pr[b]);
         // Вытеснение слабой/остывшей позиции новым мощным лидером (Opportunity Rotation):
         // если капитал заперт в позиции с ослабевшим ожиданием (< 0.55 * exitNeed), а на текущей свече появился лидер в 2.4 раза сильнее порога,
         // освобождаем слот под лидера, чтобы ни одна фаза не застревала в слабых бумагах
@@ -522,7 +522,7 @@ async function run(runId, p, state) {
           if (shocked || !(e > req) || !liquid(i, t)) closePos(i, h, tIn, false, shocked ? 'Защита от экстремального обвала' : '');
         }
         const needL = autoAdapt && bear ? need * 1.25 : need;
-        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 rawCand = (mktDown || !timeOk) ? [] : [...pr.keys()].filter((i) => edge(i) > needL * symMult[i] && canOpenAt(i, edge(i) / (needL * symMult[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]);
@@ -1118,7 +1118,7 @@ async function runStabilityLoop(targetId, runRow, st) {
       const borrowFee = (h, t) => h.alloc * (p.modelShortFeePct / 100) * ((tsOf(t) - tsOf(h.entryT)) / 3600000 / 24 / 365);
       const countSide = (side) => [...held.values()].filter((h) => h.side === side).length;
       const stockPnl = new Float64Array(N), stockCnt = new Float64Array(N);
-      const stockAllowed = (i) => !autoAdapt || !isStockQuarantined(stockCnt[i], stockPnl[i]);
+      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 maxSlotWeight = dir === 'long' ? Math.min(0.58, Math.max(1 / K, 1.8 / K)) : Math.min(0.75, 3.0 / (2 * K));
@@ -1159,7 +1159,7 @@ 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 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 edge = (i) => pr[i] * sg[i] * Math.sqrt(H);
@@ -1174,8 +1174,8 @@ async function runStabilityLoop(targetId, runRow, st) {
           }
           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) => 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 candL = (mktDown || !timeOk) ? [] : [...pr.keys()].filter((i) => edge(i) > needL * symMult[i] && canOpenAt(i, edge(i) / (needL * symMult[i])) && okLong(i)).sort((a, b) => pr[b] - pr[a]);
+          const candS = !timeOk ? [] : [...pr.keys()].filter((i) => edge(i) < -needS * symMult[i] && canOpenAt(i, (-edge(i)) / (needS * symMult[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);
@@ -1201,7 +1201,7 @@ async function runStabilityLoop(targetId, runRow, st) {
             if (shocked || !(e > req) || !liquid(i, t)) closePos(i, h, tIn);
           }
           const needL = autoAdapt && bear ? need * 1.25 : need;
-          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 rawCand = (mktDown || !timeOk) ? [] : [...pr.keys()].filter((i) => edge(i) > needL * symMult[i] && canOpenAt(i, edge(i) / (needL * symMult[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]);

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,22 +276,24 @@ 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) => !held.has(i) && cooldownUntil[i] <= t && liquid(i) && (!tokens[i].inIndex || tokens[i].inIndex[t] === 1) && !isStockQuarantined(stockCnt[i], stockPnl[i]) && (policy.tier2 !== false || isT1(i));
+      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 = [];
       const candS = [];
       for (let i = 0; i < N; i++) {
         const e = edge(i);
-        if (e > Math.max(needL * mult[i] * tierScale(i), minEdgeL)) {
-          if (!baseOk(i)) continue;
+        const thrL = Math.max(needL * mult[i] * tierScale(i), minEdgeL);
+        const thrS = Math.max(needS * mult[i] * tierScale(i), minEdgeS);
+        if (e > thrL) {
+          if (!baseOk(i, e / thrL)) continue;
           const fl = flags(i);
           if (fl.dipBlock || fl.overheat || divRule(i, t)?.blockLong) continue;
           candL.push(i);
-        } else if (dir !== 'long' && e < -Math.max(needS * mult[i] * tierScale(i), minEdgeS)) {
-          if (!baseOk(i)) continue;
+        } 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);
@@ -333,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;

package/server/strategist/index.js

@@ -23,9 +23,11 @@ const MAX_STEPS = 20;
 const MSK = 3 * 3600000;
 const fmtTs = (ts) => new Date(ts + MSK).toISOString().slice(0, 16).replace('T', ' ');
 const fmtClockMsk = (ts) => new Date(ts + MSK).toISOString().slice(11, 16);
-// Общие вопросы о состоянии торгов («как дела», «что происходит») требуют проверки фактических данных, а не ответа по календарю
+// Общие вопросы о состоянии торгов («как дела», «что происходит») и вопросы по акциям/сигналам требуют вызова свежих инструментов, а не чтения старых реплик диалога
 const STATUS_QUESTION_RE = /^(?:ну\s+)?(?:как\s+(?:дела|делишки|торговля|идут\s+торги|сч[её]т|успехи)|что\s+(?:происходит|нового))(?:[\s!?.,]|$)/i;
+const STOCK_OR_SIGNAL_QUESTION_RE = /(?:почему\s+не\s+(?:покупа|бер|взял|вошл|шорт|прода|откры)|почему\s+пропустил|что\s+(?:по|с)\s+\S+|сигнал\s+по|прогноз\s+по|как\s+вчера|вчерашн)/i;
 const isStatusQuestion = (text = '') => STATUS_QUESTION_RE.test(String(text || '').trim());
+const isStockOrSignalQuestion = (text = '') => STOCK_OR_SIGNAL_QUESTION_RE.test(String(text || '').trim());
 const fmtPct = (v) => (v === null || v === undefined ? '—' : `${v > 0 ? '+' : ''}${v}%`);
 
 // Человекочитаемое имя сессии по первому вопросу пользователя или теме запроса
@@ -208,6 +210,15 @@ function systemPrompt() {
     if (!noTools && isStatusQuestion(lastUser?.content)) {
       statusQuestionHint = `\n## Указание для текущего запроса
 Пользователь задал общий вопрос о состоянии. Прежде чем отвечать, **ОБЯЗАТЕЛЬНО** вызови \`get_brokers_status\` и \`get_broker_operations\` с \`{"period": "today"}\` (если счета подключены). Ответь по фактическим данным: идут ли торги, какие позиции открыты, какие сделки уже были сегодня и с каким результатом. Не говори «торги ещё не начались», если в данных есть сделки.
+`;
+    } else if (!noTools && isStockOrSignalQuestion(lastUser?.content)) {
+      statusQuestionHint = `\n## Указание для текущего запроса
+Пользователь спрашивает о конкретной бумаге, сигнале, пропуске входа или итогах торгов. **КАТЕГОРИЧЕСКИ ЗАПРЕЩЕНО** отвечать по прошлым сообщениям или старым вызовам инструментов в истории чата!
+Прежде чем отвечать, **ОБЯЗАТЕЛЬНО** вызови свежие инструменты прямо сейчас:
+- \`model_forecast\` (передай \`symbol\` с тикером или названием компании, если речь о конкретной акции, например \`{"symbol": "SMLT"}\` или \`{"symbol": "Самолет"}\`),
+- \`get_brokers_status\` (чтобы проверить активные фильтры счёта: \`карантин_бумаг_на_счёте\`, \`последние_события_исполнения\`, \`подготовленный_пакет_заявок\`),
+- и при вопросе о вчерашних/сегодняшних сделках — \`get_broker_operations\`.
+В ответе называй точный индивидуальный порог акции из поля \`порог_покупки_проц\` / \`порог_шорта_проц\` свежего вызова \`model_forecast\` и проверяй поля \`заблокирована_карантином_счёта\`, \`заблокирована_паузой_после_выхода\`, \`заблокирована_ценовым_коридором\` и \`эпизоды_выбранной_акции_в_журнале\`.
 `;
     }
   } catch { /* ignore */ }
@@ -355,7 +366,14 @@ function buildContext(convId) {
     }
     if (m.role === 'tool') {
       let content = m.content || '';
-      if (!lastToolIdx.includes(idx) && content.length > 1500) content = `${content.slice(0, 1500)}… (сокращено)`;
+      const ageMs = m.ts ? (Date.now() - m.ts) : 0;
+      const isStaleLiveTool = ageMs > 15 * 60000;
+      if (isStaleLiveTool) {
+        const stamp = m.ts ? fmtTs(m.ts) : 'ранее';
+        content = `[УСТАРЕВШИЙ СНИМОК ИНСТРУМЕНТА от ${stamp} МСК — НЕ ИСПОЛЬЗУЙ КАК ТЕКУЩИЕ ДАННЫЕ, вызови инструмент заново!] ${content.slice(0, 380)}…`;
+      } else if (!lastToolIdx.includes(idx) && content.length > 1500) {
+        content = `${content.slice(0, 1500)}… (сокращено)`;
+      }
       out.push({ role: 'tool', tool_call_id: m.tool_call_id, content });
       openIds.delete(m.tool_call_id);
       if (!openIds.size) { out.push(...deferred); deferred.length = 0; }

package/server/strategist/tools.js

@@ -5,7 +5,7 @@ import { getRun, listRuns } from '../db.js';
 import { analyzeRun, compareRuns, recentRuns } from './analytics.js';
 import { forecastNow } from '../model/forecast.js';
 import { listNews } from '../news/index.js';
-import { BROKER_META, brokersState, discoverBrokerAccounts, saveBrokerAccount, syncBrokerAccount, prepareBrokerOrders, fetchBrokerHistory } from '../brokers/index.js';
+import { BROKER_META, brokersState, listBrokerEvents, discoverBrokerAccounts, saveBrokerAccount, syncBrokerAccount, prepareBrokerOrders, fetchBrokerHistory } from '../brokers/index.js';
 import { fmtBarMsk, fmtDayMsk, MSK, DAY, round } from '../util.js';
 import { tradingSessionStatus } from '../session.js';
 
@@ -68,6 +68,17 @@ export const TOOLS = {
           ...(a.entryTsBySymbol?.[p.symbol] ? { время_входа_робота_мск: fmtBarMsk(a.entryTsBySymbol[p.symbol]) } : {}),
         })),
         активные_заявки_в_стакане: a.lastSync?.activeOrders || [],
+        карантин_бумаг_на_счёте: (a.quarantinedStocks || []).map((q) => ({
+          тикер: q.symbol,
+          накопленный_результат_проц: q.pnlPct,
+          до_даты: q.untilText,
+          правило: q.reasonText,
+        })),
+        последние_события_исполнения: listBrokerEvents(a.id, 15).map((ev) => ({
+          время_мск: fmtBarMsk(ev.ts),
+          тип: ev.kind,
+          описание: ev.text,
+        })),
         подготовленный_пакет_заявок: a.pendingBatch ? {
           свеча: a.pendingBatch.bar,
           статус: a.pendingBatch.status,
@@ -239,6 +250,13 @@ export const TOOLS = {
             цена: op.price || 0,
             сумма_руб: op.paymentRub,
           })),
+          события_заявок_и_пропусков_за_период: listBrokerEvents(a.id, 120)
+            .filter((ev) => {
+              const dIso = new Date((ev.ts || 0) + MSK).toISOString().slice(0, 10);
+              return dIso >= startIso && dIso <= endIso;
+            })
+            .reverse()
+            .map((ev) => ({ время_мск: fmtBarMsk(ev.ts), тип: ev.kind, описание: ev.text })),
           ...(prevActiveDay ? { подсказка: `За период ${periodLabel} операций не было; ближайший предыдущий день со сделками: ${prevActiveDay}` } : {}),
         };
       });
@@ -299,12 +317,17 @@ export const TOOLS = {
           ...(x.shortBlockedByBroker ? { шорт_запрещён_брокером: true } : {}),
           ...(x.shortBlockedByDiv ? { шорт_заблокирован_дивидендами: x.shortBlockedByDiv } : {}),
           ...(x.shortBlockedByNews ? { шорт_заблокирован_новостями: x.shortBlockedByNews } : {}),
+          ...(x.blockedByQuarantine ? { заблокирована_карантином_счёта: x.blockedByQuarantine } : (x.quarantineInfo ? { карантин_пробит_сильным_сигналом: `${x.quarantineInfo.reasonText} — сигнал ≥110% порога допущен` } : {})),
+          ...(x.blockedByCooldown ? { заблокирована_паузой_после_выхода: x.blockedByCooldown } : {}),
+          ...(x.blockedByCorridor ? { заблокирована_ценовым_коридором: x.blockedByCorridor } : {}),
           ликвидна: x.liquid,
           влияют_соседи: (x.influences || []).map((n) => `${n.symbol} (${n.contribPct > 0 ? '+' : ''}${n.contribPct}%, близость ${n.closeness})`),
         };
       };
       const symUp = symbol ? String(symbol).toUpperCase().trim() : '';
-      const targetRow = symUp ? r.rows.find((x) => x.symbol === symUp) : null;
+      const targetRow = symUp
+        ? (r.rows.find((x) => x.symbol === symUp) || r.rows.find((x) => String(x.name || '').toUpperCase().includes(symUp)))
+        : null;
       return {
         result: {
           текущее_время_мск: fmtBarMsk(Date.now()),
@@ -315,7 +338,10 @@ export const TOOLS = {
           порог_шорта_1_эшелон_проц: -shortThr,
           порог_шорта_2_эшелон_проц: -shortThrT2,
           тренд_индекса: r.marketDown ? 'падающий (облегчён шорт, ужесточён лонг)' : 'растущий (стандартный лонг, ужесточён шорт)',
-          ...(targetRow ? { выбранная_акция: pick(targetRow) } : {}),
+          ...(targetRow ? {
+            выбранная_акция: pick(targetRow),
+            эпизоды_выбранной_акции_в_журнале: (r.nearSignals || []).filter((e) => e.symbol === targetRow.symbol),
+          } : {}),
           сильнее_рынка: r.rows.slice(0, top).map(pick),
           слабее_рынка: r.rows.slice(-Math.min(6, top)).reverse().map(pick),
           журнал_почти_сигналов_за_неделю: (r.nearSignals || []).slice(0, 12),