neuroalpha 0.5.22 → 0.5.27

package/package.json

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

package/public/app.js

@@ -1079,20 +1079,36 @@ async function loadForecast(force, silent = false) {
       }
       return reasons.length ? { blocked: true, label, title: reasons.join(' · ') } : { blocked: false, label: '', title: '' };
     };
-    const sigBadge = (r, blk) => {
+    const sigBadge = (r, blk, crossed, pctOfThr, thrText, thrVal) => {
       if (r.signal) return '<span class="tag ok">купить</span>';
       if (r.shortSignal) return '<span class="tag no">шорт</span>';
-      if (blk?.blocked) return `<span class="tag blocked" title="${esc(blk.title)}">${esc(blk.label)}</span>`;
-      return '<span class="muted small">—</span>';
+      if (blk?.blocked && crossed) {
+        return `<span class="tag blocked" title="${esc(`Порог ${thrText} пройден (ожидание ${fmtPct(r.expectedPct, 2)}, ${pctOfThr}% порога), но вход заблокирован: ${blk.title}`)}">${esc(blk.label)}</span>`;
+      }
+      if (blk?.blocked && !crossed) {
+        const shortTag = blk.label.replace(/^⛔\s*/, '');
+        return `<span class="muted small" title="${esc(`Ожидание ${fmtPct(r.expectedPct, 2)} ниже порога ${thrText} (${pctOfThr}% от порога) — сигнала нет. Дополнительно по бумаге активен фильтр: ${blk.title}`)}">ниже порога · ${esc(shortTag)}</span>`;
+      }
+      if (pctOfThr >= 75) {
+        const gap = Math.max(0, (Number(thrVal) || 0) - Math.abs(Number(r.expectedPct) || 0));
+        return `<span class="tag mid" title="${esc(`Почти сигнал: ожидание ${fmtPct(r.expectedPct, 2)} достигло ${pctOfThr}% от порога ${thrText} (не хватает ${fmtNum(gap, 2)}%)`)}">почти (${pctOfThr}%)</span>`;
+      }
+      return `<span class="muted small" title="${esc(`Ожидание ${fmtPct(r.expectedPct, 2)} ниже порога ${thrText} (${pctOfThr}% от порога)`)}">—</span>`;
     };
     const row = (r, side) => {
       const blk = !r.signal && !r.shortSignal ? blockInfoOf(r, side) : { blocked: false };
-      const trCls = (r.signal || r.shortSignal) ? ' class="best"' : blk.blocked ? ` class="fc-blocked" title="${esc(blk.title)}"` : '';
       const isShort = side === 'short' || (side !== 'long' && r.expectedPct < 0);
       const isT1 = r.tier ? r.tier === 1 : TIER1_SET.has(r.symbol);
       const thrVal = isShort
         ? (r.shortThresholdPct ?? (isT1 ? shortThr : shortThrT2))
         : (r.buyThresholdPct ?? (isT1 ? buyThr : buyThrT2));
+      const pctOfThr = thrVal > 0 ? Math.round((Math.abs(Number(r.expectedPct) || 0) / thrVal) * 100) : 0;
+      const crossed = thrVal > 0 && Math.abs(Number(r.expectedPct) || 0) >= thrVal;
+      const trCls = (r.signal || r.shortSignal)
+        ? ' class="best"'
+        : (blk.blocked && crossed)
+          ? ` class="fc-blocked" title="${esc(`Порог пройден, но вход заблокирован: ${blk.title}`)}"`
+          : '';
       const thrFmt = Number(thrVal || 0).toLocaleString('ru-RU', { minimumFractionDigits: 2, maximumFractionDigits: 2 });
       const thrText = isShort ? `−${thrFmt}%` : `+${thrFmt}%`;
       const multStr = r.edgeMult ? `×${fmtNum(r.edgeMult, 2)}` : (isT1 ? '×1,00' : '×1,20');
@@ -1106,7 +1122,7 @@ async function loadForecast(force, silent = false) {
       <td class="num" style="white-space:nowrap">${r.price ? `${fmtNum(r.price, r.price < 1 ? 5 : r.price < 10 ? 3 : 2)} ₽` : '—'}</td>
       <td class="num ${cls(r.expectedPct)}" style="white-space:nowrap"><b>${fmtPct(r.expectedPct, 2)}</b></td>
       <td class="num" style="white-space:nowrap">${arrowOf(r)}</td>
-      <td style="text-align:center;white-space:nowrap">${sigBadge(r, blk)}</td>
+      <td style="text-align:center;white-space:nowrap">${sigBadge(r, blk, crossed, pctOfThr, thrText, thrVal)}</td>
       <td class="muted small" style="white-space:nowrap">${(r.influences || []).slice(0, 3).map((x) => `<span class="sym-link" data-sym="${esc(x.symbol)}" title="Сосед по карте рынка: вклад ${x.contribPct > 0 ? '+' : ''}${x.contribPct}%, близость ${x.closeness}">${esc(x.symbol)}</span>`).join(', ')}</td>
       <td class="num muted small" style="white-space:nowrap" title="${esc(thrTitle)}">${thrText}</td>
     </tr>`;
@@ -1119,9 +1135,41 @@ async function loadForecast(force, silent = false) {
     ].slice(0, 4);
     // общая сетка колонок для обеих таблиц: столбцы выровнены по всей высоте блока
     const fcTable = (title, rows, extraStyle = '', side = 'long') => `<table class="fc-table" style="table-layout:fixed;width:100%${extraStyle}">${colgroup}<thead><tr><th>${title}</th><th class="num">Цена</th><th class="num">Ожидание</th><th class="num">Динамика</th><th style="text-align:center">Сигнал</th><th>Под влиянием</th><th class="num" title="Индивидуальный порог входа с учётом ликвидности бумаги (1-й или 2–3-й эшелон) и тренда индекса">Порог</th></tr></thead><tbody>${rows.map((r) => row(r, side)).join('')}</tbody></table>`;
+    const nearList = Array.isArray(f.nearSignals) ? f.nearSignals : [];
+    const prevNearEl = $('#fc-near-box');
+    const nearOpenAttr = (!prevNearEl || prevNearEl.open) ? ' open' : '';
+    const nearHtml = nearList.length ? `<details id="fc-near-box"${nearOpenAttr} style="margin-top:12px;border-top:1px solid var(--line);padding-top:10px">
+      <summary style="font-weight:500">Журнал сигналов и почти-сигналов за неделю (≥75% порога) · ${nearList.filter((x) => x.status === 'signal').length} сигн., ${nearList.filter((x) => x.status === 'blocked').length} блок., ${nearList.filter((x) => x.status === 'near').length} почти</summary>
+      <div style="overflow-x:auto;margin-top:8px">
+        <table class="fc-table" style="width:100%">
+          <thead><tr><th>Дата · время МСК</th><th>Бумага</th><th>Направление</th><th class="num">Пик ожидания</th><th class="num">Порог</th><th class="num">К порогу</th><th>Статус и причина</th></tr></thead>
+          <tbody>${nearList.slice(0, 18).map((ep) => {
+            const dStr = ep.day ? `${ep.day.slice(8, 10)}.${ep.day.slice(5, 7)}` : '';
+            const tRange = ep.firstBar && ep.lastBar && ep.firstBar !== ep.lastBar ? `${ep.firstBar}–${ep.lastBar} (${ep.barsCount} св.)` : `${ep.peakBar || ep.lastBar || ''}`;
+            const isSh = ep.side === 'short';
+            const thrStr = `${isSh ? '−' : '+'}${fmtNum(ep.thresholdPct, 2)}%`;
+            const stBadge = ep.status === 'signal'
+              ? `<span class="tag ok">${isSh ? '✓ сигнал шорт' : '✓ сигнал купить'}</span>`
+              : ep.status === 'blocked'
+                ? '<span class="tag blocked">⛔ блок входа</span>'
+                : `<span class="tag mid">почти (${ep.peakRatioPct}%)</span>`;
+            const rowCls = ep.status === 'signal' ? ' class="best"' : ep.status === 'blocked' ? ' class="fc-blocked"' : '';
+            return `<tr${rowCls}>
+              <td class="muted small" style="white-space:nowrap">${esc(dStr)} ${esc(tRange)}</td>
+              <td style="white-space:nowrap"><span class="sym-link" data-sym="${esc(ep.symbol)}" title="Открыть досье акции ${esc(ep.symbol)}"><b>${esc(ep.symbol)}</b> <span class="muted small">${esc(ep.name || '')}</span></span></td>
+              <td class="${isSh ? 'neg' : 'pos'} small" style="white-space:nowrap">${isSh ? 'В шорт' : 'В покупку'}</td>
+              <td class="num ${cls(ep.peakExpectedPct)}" style="white-space:nowrap"><b>${fmtPct(ep.peakExpectedPct, 2)}</b></td>
+              <td class="num muted small" style="white-space:nowrap">${thrStr}</td>
+              <td class="num small" style="white-space:nowrap"><b>${ep.peakRatioPct}%</b></td>
+              <td class="small" style="white-space:normal">${stBadge} <span class="muted">${esc(ep.reasonText || '')}</span></td>
+            </tr>`;
+          }).join('')}</tbody>
+        </table>
+      </div>
+    </details>` : '';
     box.innerHTML = `<div style="overflow-x:auto">${fcTable('Сильнее рынка', shownRows.slice(0, 6), '', 'long')}
       ${fcTable('Слабее рынка', shortRows, ';margin-top:14px', 'short')}</div>
-      <p class="muted small">Ожидание — движение относительно рынка в целом (авто-пересчёт каждые 15 сек по живым ценам Мосбиржи). Точный индивидуальный порог каждой акции рассчитывается в колонке <b>«Порог»</b> с учётом её ликвидности (оборота торгов), волатильности свечи и тренда индекса. <span style="color:var(--blocked-fg)">Розовым</span> отмечены строки, по которым вход запрещён (запрет шорта у брокера, отсечка дивидендов, фильтр новостей или экстремальная свеча ±4,5%).</p>`;
+      <p class="muted small">Ожидание — движение относительно рынка в целом (авто-пересчёт каждые 15 сек по живым ценам Мосбиржи). Точный индивидуальный порог каждой акции рассчитывается в колонке <b>«Порог»</b> с учётом её ликвидности (оборота торгов), волатильности свечи и тренда индекса. <span style="color:var(--blocked-fg)">Розовым</span> выделяются только те бумаги, где ожидание <b>уже пробило порог</b>, но сделка остановлена защитным фильтром (если ожидание ещё ниже порога, фильтр указывается справочно рядом с «ниже порога»).</p>${nearHtml}`;
     if (state.brokers?.accounts?.length) renderBrokers();
   } catch (e) {
     if (!silent) box.innerHTML = `<span class="neg">Не получилось: ${esc(e.message)}</span>`;

package/server/api/routes.js

@@ -783,8 +783,8 @@ export function createRouter() {
       tierLabel: isTier1 ? '1-й эшелон (высокая ликвидность)' : '2-й эшелон',
       edgeMult: fcRow?.edgeMult ?? round(tierMult, 3),
       sigmaPct: fcRow?.sigmaPct ?? null,
-      buyThresholdPct: fcRow?.buyThresholdPct ?? round(Math.max((fc?.buyThresholdPct || 0.413) * tierMult, 0.30), 3),
-      shortThresholdPct: fcRow?.shortThresholdPct ?? round(Math.max((fc?.shortThresholdPct || 0.516) * tierMult, 0.31), 3),
+      buyThresholdPct: fcRow?.buyThresholdPct ?? round(Math.max((fc?.buyThresholdPct || 0.40) * tierMult, 0.30), 3),
+      shortThresholdPct: fcRow?.shortThresholdPct ?? round(Math.max((fc?.shortThresholdPct || 0.50) * tierMult, 0.31), 3),
       shortAllowedByBroker: shortableMap[sym] !== undefined ? Boolean(shortableMap[sym]) : null,
       specs: {
         lotSize: sp.lotSize,

package/server/brokers/index.js

@@ -118,15 +118,15 @@ export function roundToStep(price, minStep = 0.01, decimals = 2) {
   return Number(v.toFixed(Math.max(0, Math.min(6, decimals))));
 }
 
-// Снайперский расчёт лимитной цены (1-tick Limit):
-// отталкивается от живой секундной цены basePx и сдвигает её ровно на 1 минимальный шаг цены (minStep),
-// но не более заданного offsetPct, чтобы не переплачивать маркетмейкерам за пересечение спреда!
+// Снайперский расчёт лимитной цены:
+// отталкивается от живой секундной цены basePx и задаёт защитный предел исполнения по offsetPct (но не менее 1 минимального шага цены minStep),
+// а в момент фактической отправки в стакан sendOrderToBroker дополнительно подстраивает цену под лучший bid/ask живого стакана 1×1!
 export function sniperLimitPrice(basePx, dir, offsetPct = 0.02, sp = { minStep: 0.01, decimals: 2 }) {
   const step = sp.minStep > 0 ? sp.minStep : 0.01;
-  const maxOffRatio = Math.max(0, Math.min(0.0005, (Number(offsetPct) || 0.02) / 100));
+  const maxOffRatio = Math.max(0, Math.min(0.001, (Number(offsetPct) || 0.02) / 100));
   const byPct = basePx * (1 + dir * maxOffRatio);
   const byOneTick = basePx + dir * step;
-  const rawLimit = dir > 0 ? Math.min(byPct, byOneTick) : Math.max(byPct, byOneTick);
+  const rawLimit = dir > 0 ? Math.max(byPct, byOneTick) : Math.min(byPct, byOneTick);
   return roundToStep(rawLimit, step, sp.decimals);
 }
 
@@ -498,6 +498,7 @@ export function saveBrokerAccount(input = {}) {
     skipEdgeMinutes: input.skipEdgeMinutes !== undefined ? Boolean(input.skipEdgeMinutes) : (prev.skipEdgeMinutes ?? true),
     autoSchedule: input.autoSchedule !== undefined ? Boolean(input.autoSchedule) : (prev.autoSchedule ?? true),
     lastScheduledBarTs: strategyOrCapChanged ? 0 : (prev.lastScheduledBarTs || 0),
+    lastFullStepWallTs: strategyOrCapChanged ? 0 : (prev.lastFullStepWallTs || 0),
     // дневной стоп при сохранении настроек не снимается — только отдельным действием «Снять стоп до конца дня»
     haltedReason: prev.haltedReason || null,
     ddOverrideDay: prev.ddOverrideDay || null,
@@ -580,14 +581,16 @@ export function deleteBrokerAccount(id) {
 
 // ---------- адаптеры REST API брокеров (Т-Банк, Финам, Алор, БКС) ----------
 // HTTPS-клиент с поддержкой российских сертификатов НУЦ Минцифры РФ (invest-public-api.tinkoff.ru и др.) и пулом постоянных соединений Keep-Alive
-const BROKER_HTTPS_AGENT = new https.Agent({ keepAlive: true, maxSockets: 6, ca: TRUSTED_CA });
+const BROKER_HTTPS_AGENT = new https.Agent({ keepAlive: true, keepAliveInitialDelay: 10000, maxSockets: 6, timeout: 20000, ca: TRUSTED_CA });
 
 function brokerFetch(url, { method = 'GET', headers = {}, body = null, timeoutMs = 15000 } = {}) {
   return new Promise((resolve, reject) => {
     let settled = false;
+    let wallTimer = null;
     const done = (fn, val) => {
       if (settled) return;
       settled = true;
+      if (wallTimer) clearTimeout(wallTimer);
       fn(val);
     };
     const u = new URL(url);
@@ -622,6 +625,12 @@ function brokerFetch(url, { method = 'GET', headers = {}, body = null, timeoutMs
       res.on('error', (err) => done(reject, err));
       res.on('close', () => done(reject, new Error('Соединение закрыто до завершения ответа')));
     });
+    wallTimer = setTimeout(() => {
+      const err = new Error('Превышено время ожидания ответа от брокера');
+      req.destroy(err);
+      done(reject, err);
+    }, Math.max(1500, timeoutMs));
+    wallTimer.unref?.();
     req.on('timeout', () => { req.destroy(new Error('Превышено время ожидания ответа от брокера')); });
     req.on('error', (err) => done(reject, err));
     req.on('close', () => done(reject, new Error('Запрос закрыт до получения ответа')));
@@ -710,8 +719,9 @@ async function resolveTbankMetaMap(base, headers, keys = []) {
 // Возвращает живые секундные цены акций из T-Invest API (GetLastPrices, 0 секунд задержки), если у любого пользователя подключён счёт Т-Банка
 export async function fetchTbankRealtimePrices() {
   try {
-    // только токен владельца текущих данных — токены других пользователей не используются никогда
-    const tbAcc = loadRawAccounts().find((a) => a.broker === 'tbank' && a.token);
+    // только токен владельца текущих данных — токены других пользователей не используются никогда (предпочитаем боевой контур песочнице)
+    const rawAccs = loadRawAccounts();
+    const tbAcc = rawAccs.find((a) => a.broker === 'tbank' && a.token && !a.sandbox) || rawAccs.find((a) => a.broker === 'tbank' && a.token);
     if (!tbAcc?.token) return null;
     await ensureTbankShortableMap(tbAcc);
     const uidMap = kvGet('tbankShortableMap')?.uidMap || {};
@@ -744,7 +754,8 @@ export async function fetchTbankRealtimePrices() {
 // Возвращает свежие 10-минутные свечи акции из T-Invest API (GetCandles, 0 секунд задержки, без 20-минутного отставания бесплатного MOEX ISS)
 export async function fetchTbankCandles(symbol, fromTs, tillTs = Date.now(), { includeIncomplete = false } = {}) {
   try {
-    const tbAcc = loadRawAccounts().find((a) => a.broker === 'tbank' && a.token);
+    const rawAccs = loadRawAccounts();
+    const tbAcc = rawAccs.find((a) => a.broker === 'tbank' && a.token && !a.sandbox) || rawAccs.find((a) => a.broker === 'tbank' && a.token);
     if (!tbAcc?.token) return null;
     await ensureTbankShortableMap(tbAcc);
     const shortMap = kvGet('tbankShortableMap');
@@ -756,17 +767,18 @@ export async function fetchTbankCandles(symbol, fromTs, tillTs = Date.now(), { i
     // Для CANDLE_INTERVAL_10_MIN максимальный диапазон одного запроса в T-Invest API — 3 суток
     const safeFrom = Math.max(fromTs, tillTs - 3 * 86400000 + 60000);
     if (safeFrom >= tillTs) return null;
-    const r = await brokerFetch(`${base}/tinkoff.public.invest.api.contract.v1.MarketDataService/GetCandles`, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify({
-        instrumentId: uid,
-        from: new Date(safeFrom).toISOString(),
-        to: new Date(tillTs).toISOString(),
-        interval: 'CANDLE_INTERVAL_10_MIN',
-      }),
-      timeoutMs: 5000,
+    const url = `${base}/tinkoff.public.invest.api.contract.v1.MarketDataService/GetCandles`;
+    const body = JSON.stringify({
+      instrumentId: uid,
+      from: new Date(safeFrom).toISOString(),
+      to: new Date(tillTs).toISOString(),
+      interval: 'CANDLE_INTERVAL_10_MIN',
     });
+    let r = await brokerFetch(url, { method: 'POST', headers, body, timeoutMs: 5000 });
+    if (r.status === 429 || r.status >= 500) {
+      await new Promise((res) => setTimeout(res, 350 + Math.floor(Math.random() * 400)));
+      r = await brokerFetch(url, { method: 'POST', headers, body, timeoutMs: 5000 });
+    }
     if (!r.ok) return null;
     const j = await r.json();
     const out = [];
@@ -1771,7 +1783,7 @@ export async function prepareBrokerOrders(id, { onlyEntries = false } = {}) {
     if (aQty > 0) {
       const lots = Math.floor(aQty / sp.lotSize);
       const curGainPct = avgPx > 0 ? ((curPx - avgPx) / avgPx) * 100 : 0;
-      const hitHardStopLoss = curGainPct <= -5.0;
+      const hitHardStopLoss = curGainPct <= -5.0 || Boolean(autoAdapt && r.regimeCrash);
       const keepByForecast = onlyEntries ? (r.liquid && r.expectedPct > -needPct) : (r.liquid && r.expectedPct > curExitThr);
       const dg = divGuardOf(sym, curPx);
       const divExit = Boolean(dg?.exitLong);
@@ -1796,7 +1808,7 @@ export async function prepareBrokerOrders(id, { onlyEntries = false } = {}) {
     } else if (aQty < 0) {
       const lots = Math.floor(Math.abs(aQty) / sp.lotSize);
       const curGainPct = avgPx > 0 ? ((avgPx - curPx) / avgPx) * 100 : 0;
-      const hitHardStopLoss = curGainPct <= -4.5;
+      const hitHardStopLoss = curGainPct <= -4.5 || Boolean(autoAdapt && r.regimeSqueeze);
       const keepByForecast = onlyEntries ? (dir !== 'long' && r.liquid && r.expectedPct < needPct) : (dir !== 'long' && r.liquid && r.expectedPct < -curExitThr);
       const dg = divGuardOf(sym, curPx);
       const divExit = Boolean(dg?.exitShort);
@@ -1899,7 +1911,11 @@ export async function prepareBrokerOrders(id, { onlyEntries = false } = {}) {
     }
   }
   const freedRub = orders.filter((o) => o.action === 'sell').reduce((s, o) => s + o.amountRub, 0);
-  const cashLimit = acc.lastSync?.cashRub !== undefined ? acc.lastSync.cashRub + freedRub : budget;
+  const coverSpentRub = orders.filter((o) => o.action === 'cover').reduce((s, o) => s + o.amountRub, 0);
+  const openShortRub = [...heldMap.values()]
+    .filter((p) => rowMap.has(p.symbol) && algoQtyOf(p.symbol, p.qty) < 0 && !closing.has(p.symbol))
+    .reduce((s, p) => s + Math.abs(algoQtyOf(p.symbol, p.qty) * p.price), 0);
+  const cashLimit = acc.lastSync?.cashRub !== undefined ? acc.lastSync.cashRub + freedRub - coverSpentRub - openShortRub : budget;
   let availRub = Math.min(Math.max(0, budget * 0.99 - usedRub), Math.max(0, cashLimit));
 
     // 2) вход в лучшие сигналы (с учётом лотности Мосбиржи, свободного лимита и адаптивного отбора числа акций Dynamic Top-K)
@@ -2111,9 +2127,13 @@ export async function prepareBrokerOrders(id, { onlyEntries = false } = {}) {
     return brokersState();
   }
 
+  const batchNowTs = Date.now();
+  if (!onlyEntries) {
+    acc.lastFullStepWallTs = batchNowTs;
+  }
   acc.pendingBatch = {
-    id: `batch_${Date.now()}`,
-    createdAt: Date.now(),
+    id: `batch_${batchNowTs}`,
+    createdAt: batchNowTs,
     bar: fc.bar,
     budgetRub: budget,
     availRub: round(availRub, 0),
@@ -2190,19 +2210,35 @@ async function sendOrderToBroker(acc, ord) {
       if (bestBid > 0 && bestAsk >= bestBid) {
         const midPx = (bestBid + bestAsk) / 2;
         const spreadPct = ((bestAsk - bestBid) / midPx) * 100;
+        const step = sp.minStep || 0.01;
         const maxSpreadPct = ord.symbol === 'LQDT' ? 0.15 : Math.max(0.28, Math.abs(Number(ord.expectedPct) || 0.6) * 0.45);
         if (isEntry && spreadPct > maxSpreadPct) {
           logBrokerEvent(acc, 'spread_skip', `${ord.symbol}: спред ${round(spreadPct, 2)}% > порога ${round(maxSpreadPct, 2)}% (ожидание ${ord.expectedPct || 0}%)`);
           throw Object.assign(new Error(`Широкий спред в стакане ${ord.symbol} (${round(spreadPct, 2)}% > ${round(maxSpreadPct, 2)}%) — вход пропущен, чтобы не потерять на спреде`), { definitive: true });
         }
-        if (isEntry && ord.symbol !== 'LQDT') {
-          // Пассивный вход на середине спреда (или на 1 шаг внутри спреда от своей стороны), но не хуже расчётной limitPrice
-          const passivePx = isBuy
-            ? Math.min(finalLimitPx, roundToStep(Math.min(midPx, bestBid + (sp.minStep || 0.01)), sp.minStep, sp.decimals))
-            : Math.max(finalLimitPx, roundToStep(Math.max(midPx, bestAsk - (sp.minStep || 0.01)), sp.minStep, sp.decimals));
-          if (passivePx > 0) finalLimitPx = passivePx;
-        } else if (ord.symbol === 'LQDT') {
+        if (ord.symbol === 'LQDT') {
           finalLimitPx = roundToStep(isBuy ? bestAsk : bestBid, sp.minStep || 0.001, sp.decimals ?? 3);
+        } else if (!isEntry) {
+          // Закрывающие заявки (sell / cover): при нормальном спреде (<= 0,8%) ставим цену в лучшую встречную заявку стакана (bestBid / bestAsk),
+          // чтобы выход исполнялся мгновенно (за < 1 сек) и гарантированно освобождал кэш перед открытием новых позиций!
+          if (spreadPct <= 0.80) {
+            const mktExitPx = roundToStep(isBuy ? bestAsk : bestBid, step, sp.decimals);
+            if (mktExitPx > 0) finalLimitPx = isBuy ? Math.max(finalLimitPx, mktExitPx) : Math.min(finalLimitPx, mktExitPx);
+          }
+        } else {
+          // Входящие заявки (buy / short):
+          // • при узком спреде (<= 0,06% или <= 2 шагов цены — голубые фишки 1-го эшелона) берём по лучшей встречной цене в пределах защитного лимита finalLimitPx, чтобы не упускать движение;
+          // • при более широком спреде (2–3 эшелон) встаём на середине спреда (или на 1 шаг внутри спреда), не переплачивая маркетмейкеру!
+          const tightSpread = spreadPct <= 0.06 || (bestAsk - bestBid) <= 2.1 * step;
+          if (tightSpread) {
+            const activePx = roundToStep(isBuy ? bestAsk : bestBid, step, sp.decimals);
+            if (activePx > 0) finalLimitPx = isBuy ? Math.min(finalLimitPx, activePx) : Math.max(finalLimitPx, activePx);
+          } else {
+            const passivePx = isBuy
+              ? Math.min(finalLimitPx, roundToStep(Math.min(midPx, bestBid + step), step, sp.decimals))
+              : Math.max(finalLimitPx, roundToStep(Math.max(midPx, bestAsk - step), step, sp.decimals));
+            if (passivePx > 0) finalLimitPx = passivePx;
+          }
         }
       }
     }
@@ -2722,15 +2758,17 @@ registerBrokerHandlers({ execute: executeBrokerOrders, reject: rejectBrokerOrder
 // ---------- авто-расписание расчёта заявок по закрытию свечи (раз в горизонт прогноза) ----------
 let lastSeenBar = null;
 let schedulerBusy = false;
+let schedulerBusySince = 0;
 
 async function tickBrokerSchedule() {
-  if (schedulerBusy) return;
+  if (schedulerBusy && Date.now() - schedulerBusySince < 90000) return;
   if (!tradingGate().allowNew) return;
   const nowMsk = new Date(Date.now() + MSK);
   const dow = nowMsk.getUTCDay();
   const mins = nowMsk.getUTCHours() * 60 + nowMsk.getUTCMinutes();
   if (dow === 0 || dow === 6 || mins < 6 * 60 + 50 || mins > 23 * 60 + 55) return;
   schedulerBusy = true;
+  schedulerBusySince = Date.now();
   try {
     const latest = await latestBarTs('IMOEX', BAR_INTERVAL).catch(() => null);
     const isNewBar = Boolean(latest && latest !== lastSeenBar);
@@ -2751,14 +2789,21 @@ async function tickBrokerSchedule() {
           // Внутричасовой перехват H/5 (каждые 30 мин) активен в режимах VIP и Хозяин; на тарифах Инвестор и Профи шаг равен полному горизонту H
           const stepBars = ((plan.allowVipBoost || plan.isOwner) && autoAdapt) ? Math.max(3, Math.floor(H / 5)) : H;
           const minStepMs = stepBars * BAR_MS;
-          const lastRunWallTs = acc.pendingBatch?.executedAt || acc.pendingBatch?.createdAt || 0;
+          const lastFullWallTs = acc.lastFullStepWallTs || 0;
+          const lastAnyWallTs = acc.pendingBatch?.executedAt || acc.pendingBatch?.createdAt || 0;
+          const hasOpenAlgoPos = (acc.lastSync?.positions || []).some((p) => p.qty && p.symbol !== 'LQDT' && p.symbol !== 'TMON@' && p.symbol !== 'TMON' && p.symbol !== 'SBMM' && algoQtyFor(acc, p.symbol, p.qty) !== 0);
+          const nowTs = Date.now();
+          const nightExitDue = autoAdapt && hasOpenAlgoPos && shouldExitBeforeNight(nowTs, 0, 3, BAR_INTERVAL) && (!lastFullWallTs || !shouldExitBeforeNight(lastFullWallTs, 0, 3, BAR_INTERVAL) || (nowTs - lastFullWallTs >= 15 * 60000));
           const dueFullStep = Boolean(
-            latest &&
-            (latest - (acc.lastScheduledBarTs || 0) >= minStepMs) &&
-            !(lastRunWallTs > 0 && Date.now() - lastRunWallTs < minStepMs - 5 * 60000),
+            nightExitDue || (
+              latest &&
+              (latest - (acc.lastScheduledBarTs || 0) >= minStepMs) &&
+              !(lastFullWallTs > 0 && nowTs - lastFullWallTs < minStepMs - 5 * 60000)
+            ),
           );
           if (dueFullStep) {
-            acc.lastScheduledBarTs = latest;
+            acc.lastScheduledBarTs = latest || acc.lastScheduledBarTs || nowTs;
+            acc.lastFullStepWallTs = nowTs;
             saveRawAccounts(list);
             if (acc.token) await syncBrokerAccount(acc.id).catch(() => {});
             await prepareBrokerOrders(acc.id).catch(() => {});
@@ -2769,7 +2814,7 @@ async function tickBrokerSchedule() {
           const lqdtBaseQty = Number(acc.baselineQty?.LQDT || 0);
           const lqdtAvailRub = lqdtPos ? Math.max(0, (lqdtPos.qty - (acc.legacyMode === 'takeover' ? 0 : Math.max(0, lqdtBaseQty))) * (lqdtPos.price || 0)) : 0;
           const freeCashRub = Number(acc.lastSync?.cashRub ?? acc.maxCapitalRub ?? 0) + lqdtAvailRub;
-          if (acc.mode === 'auto' && acc.token && freeCashRub >= 15000 && Date.now() - lastRunWallTs >= 20000) {
+          if (acc.mode === 'auto' && acc.token && freeCashRub >= 15000 && nowTs - Math.max(lastFullWallTs, lastAnyWallTs) >= 20000) {
             await prepareBrokerOrders(acc.id, { onlyEntries: true }).catch(() => {});
           }
         }
@@ -3056,6 +3101,9 @@ async function checkIntradayProfitLock(accId) {
   for (const ord of lockOrders) {
     logBrokerEvent(acc, 'protective_stop', `${ord.reason}: ${ord.action} ${ord.symbol} ${ord.lots} л.`);
     try {
+      if (acc.brokerStopBySymbol?.[ord.symbol]) {
+        await closeBrokerStopBeforeExit(acc, ord.symbol);
+      }
       const r = await sendOrderToBroker(acc, ord);
       results.push({ symbol: ord.symbol, ok: true, orderId: r.orderId });
       delete acc.entryTsBySymbol[ord.symbol];
@@ -3068,10 +3116,10 @@ async function checkIntradayProfitLock(accId) {
   }
   acc.pendingBatch = {
     ...(acc.pendingBatch || {}),
-    id: `batch_tp_${execNowTs}`,
+    id: `batch_stop_${execNowTs}`,
     createdAt: execNowTs,
     executedAt: execNowTs,
-    bar: `${fmtBarMsk(execNowTs)} (Take-Profit)`,
+    bar: `${fmtBarMsk(execNowTs)} (Защитный стоп)`,
     orders: lockOrders,
     status: results.every((r) => r.ok) ? 'executed' : 'partial',
     results,
@@ -3084,9 +3132,12 @@ async function checkIntradayProfitLock(accId) {
 
 // Автоматическое периодическое фоновое обновление портфеля и контроль фиксации прибыли (раз в 25 секунд; история операций — раз в 2 минуты)
 let autoRefreshBusy = false;
+let autoRefreshBusySince = 0;
 async function tickBrokerAutoRefresh() {
-  if (autoRefreshBusy || schedulerBusy) return;
+  const now = Date.now();
+  if ((autoRefreshBusy && now - autoRefreshBusySince < 90000) || (schedulerBusy && now - schedulerBusySince < 45000)) return;
   autoRefreshBusy = true;
+  autoRefreshBusySince = now;
   try {
     const curYear = new Date(Date.now() + MSK).getUTCFullYear();
     const users = db.prepare('SELECT * FROM users').all();

package/server/data/moex.js

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

package/server/db.js

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