neuroalpha 0.5.27 → 0.5.29

package/server/brokers/index.js

@@ -79,13 +79,29 @@ export const BROKER_META = [
 
 // ---------- справочник лотов и шага цены Мосбиржи (TQBR) ----------
 const SPECS_URL = 'https://iss.moex.com/iss/engines/stock/markets/shares/boards/TQBR/securities.json?iss.meta=off&iss.only=securities,marketdata';
+
+function withWallTimeout(promise, ms, label = 'Превышено время ожидания') {
+  let timer = null;
+  return Promise.race([
+    promise,
+    new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new Error(label)), ms);
+      timer.unref?.();
+    }),
+  ]).finally(() => {
+    if (timer) clearTimeout(timer);
+  });
+}
+
 export async function ensureBoardSpecs() {
   const cached = kvGet('moexSpecs');
   if (cached?.specs && cached?.v === 2 && Date.now() - cached.at < DAY) return cached.specs;
   try {
-    const r = await fetch(SPECS_URL, { signal: AbortSignal.timeout(25000) });
-    if (!r.ok) throw new Error(`HTTP ${r.status}`);
-    const j = await r.json();
+    const j = await withWallTimeout((async () => {
+      const r = await fetch(SPECS_URL, { signal: AbortSignal.timeout(25000) });
+      if (!r.ok) throw new Error(`HTTP ${r.status}`);
+      return r.json();
+    })(), 26000, 'Таймаут загрузки справочника TQBR');
     const sc = j.securities.columns, mc = j.marketdata.columns;
     const is = (k) => sc.indexOf(k), im = (k) => mc.indexOf(k);
     const prices = new Map();
@@ -489,6 +505,7 @@ export function saveBrokerAccount(input = {}) {
     lastHistory: acctChanged ? null : (prev.lastHistory || null),
     entryTsBySymbol: acctChanged ? {} : (prev.entryTsBySymbol || {}),
     exitCooldownBySymbol: acctChanged ? {} : (prev.exitCooldownBySymbol || {}),
+    entryFailCooldownBySymbol: acctChanged ? {} : (prev.entryFailCooldownBySymbol || {}),
     peakPriceBySymbol: acctChanged ? {} : (prev.peakPriceBySymbol || {}),
     baseRunId: nextBaseRunId,
     // жёсткие предохранители (недоступны для изменения ИИ-Стратегом)
@@ -751,8 +768,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 } = {}) {
+// Возвращает свежие свечи акции из T-Invest API (GetCandles, 0 секунд задержки, без 20-минутного отставания бесплатного MOEX ISS)
+export async function fetchTbankCandles(symbol, fromTs, tillTs = Date.now(), { includeIncomplete = false, intervalMin = 10 } = {}) {
   try {
     const rawAccs = loadRawAccounts();
     const tbAcc = rawAccs.find((a) => a.broker === 'tbank' && a.token && !a.sandbox) || rawAccs.find((a) => a.broker === 'tbank' && a.token);
@@ -764,15 +781,17 @@ export async function fetchTbankCandles(symbol, fromTs, tillTs = Date.now(), { i
     const lotSize = Math.max(1, Number(shortMap?.specMap?.[symbol]?.lotSize) || 1);
     const base = tbAcc.sandbox ? 'https://sandbox-invest-public-api.tinkoff.ru/rest' : 'https://invest-public-api.tinkoff.ru/rest';
     const headers = { Authorization: `Bearer ${tbAcc.token}`, 'Content-Type': 'application/json' };
-    // Для CANDLE_INTERVAL_10_MIN максимальный диапазон одного запроса в T-Invest API — 3 суток
-    const safeFrom = Math.max(fromTs, tillTs - 3 * 86400000 + 60000);
+    const is1m = Number(intervalMin) === 1;
+    // Для CANDLE_INTERVAL_1_MIN максимальный диапазон одного запроса в T-Invest API — 1 сутки, для CANDLE_INTERVAL_10_MIN — 3 суток
+    const maxSpanMs = is1m ? (86400000 - 60000) : (3 * 86400000 - 60000);
+    const safeFrom = Math.max(fromTs, tillTs - maxSpanMs);
     if (safeFrom >= tillTs) return null;
     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',
+      interval: is1m ? 'CANDLE_INTERVAL_1_MIN' : 'CANDLE_INTERVAL_10_MIN',
     });
     let r = await brokerFetch(url, { method: 'POST', headers, body, timeoutMs: 5000 });
     if (r.status === 429 || r.status >= 500) {
@@ -965,10 +984,13 @@ async function syncTbank(acc) {
       }
     }
   }
-  let marginEnabled = false;
-  let marginInfo = null;
+  const p = await rPort.json();
+  const hasShortPos = (p.positions || []).some((pos) => qVal(pos.quantity) < 0);
+  let marginEnabled = Boolean(acc.lastSync?.marginEnabled || hasShortPos);
+  let marginInfo = acc.lastSync?.marginInfo || null;
   if (accountType === 'ACCOUNT_TYPE_TINKOFF_IIS' || accountType === 'ACCOUNT_TYPE_INVEST_BOX') {
     marginEnabled = false;
+    marginInfo = null;
   } else if (rMargin?.ok) {
     marginEnabled = true;
     const jMar = await rMargin.json().catch(() => null);
@@ -990,9 +1012,11 @@ async function syncTbank(acc) {
     }
   } else if (rMargin) {
     const mTxt = await rMargin.text().catch(() => '');
-    marginEnabled = !mTxt.includes('30051') && !/margin.*disabled/i.test(mTxt) ? false : false;
+    if (mTxt.includes('30051') || /margin.*disabled/i.test(mTxt)) {
+      marginEnabled = false;
+      marginInfo = null;
+    }
   }
-  const p = await rPort.json();
   const jOrd = rOrd?.ok ? await rOrd.json().catch(() => null) : null;
   let rawOrders = jOrd?.orders || [];
 
@@ -1464,10 +1488,17 @@ export async function syncBrokerAccount(id) {
     }
     const prevDay = acc.lastSync?.day === today ? acc.lastSync.dayStartRub : data.totalRub;
     const dayStartRub = prevDay > 0 ? prevDay : data.totalRub;
-    const ddPct = dayStartRub > 0 ? round(((dayStartRub - data.totalRub) / dayStartRub) * 100, 2) : 0;
+    const rawDdPct = dayStartRub > 0 ? round(((dayStartRub - data.totalRub) / dayStartRub) * 100, 2) : 0;
+    // Защита от ложного срабатывания стопа (−99%) при утреннем клиринге брокера, когда API временно отдаёт totalAmountPortfolio ≈ cashRub без оценки бумаг
+    const prevTotalRub = Number(acc.lastSync?.totalRub || 0);
+    const isGlitchZeroPortfolio = rawDdPct >= 50 && prevTotalRub > 50000 && data.totalRub < prevTotalRub * 0.5 && (data.positions || []).some((p) => p.qty !== 0);
+    if (isGlitchZeroPortfolio) {
+      data.totalRub = prevTotalRub;
+    }
+    const ddPct = isGlitchZeroPortfolio ? (Number(acc.lastSync?.dayDrawdownPct) || 0) : rawDdPct;
     if (data.autoFollowDetected || /автослед|сигнал|copy|follow|comon/i.test(acc.name || '')) {
       acc.haltedReason = 'Заблокировано: на счёте обнаружено Автоследование (использование счетов автоследования запрещено Публичной офертой и правилами платформы)';
-    } else if (ddPct >= acc.maxDailyDrawdownPct && acc.ddOverrideDay !== today) {
+    } else if (!isGlitchZeroPortfolio && ddPct >= acc.maxDailyDrawdownPct && acc.ddOverrideDay !== today) {
       // Требуем подтверждения просадки на 2 синхронизациях подряд (защита от секундного переходного состояния API брокера в момент исполнения лимитной заявки)
       acc.ddBreachCount = (acc.ddBreachCount || 0) + 1;
       if (acc.ddBreachCount >= 2) {
@@ -1562,7 +1593,34 @@ export async function freezeBrokerBaseline(id) {
   return st;
 }
 
-// ---------- предохранитель времени сессии (первые и последние 10 минут торгов МСК) ----------
+// Оценка срабатывания скользящего Take-Profit и защиты заработанной прибыли от отката в минус (по лучшей цене с момента входа peakPx)
+function evaluateProfitLock(sym, side, avgPx, curPx, peakPx, roundTripFeePct = 0.10) {
+  if (!(avgPx > 0 && curPx > 0)) return null;
+  const isLong = side === 'long';
+  const curGainPct = isLong ? ((curPx - avgPx) / avgPx) * 100 : ((avgPx - curPx) / avgPx) * 100;
+  const effPeakPx = peakPx > 0
+    ? (isLong ? Math.max(peakPx, avgPx, curPx) : Math.min(peakPx, avgPx, curPx))
+    : (isLong ? Math.max(avgPx, curPx) : Math.min(avgPx, curPx));
+  const peakGainPct = isLong ? ((effPeakPx - avgPx) / avgPx) * 100 : ((avgPx - effPeakPx) / avgPx) * 100;
+  const tierMult = symbolEdgeMult(sym);
+  // 1) Скользящий Take-Profit при сильном перевыполнении цели (от +1.20% на 1-м эшелоне и от +1.44% на 2-м эшелоне):
+  // фиксируем не менее 70% набранного хода (или при откате на 0.45% с вершины)
+  if (peakGainPct >= 1.20 * tierMult) {
+    const trailFloorPct = Math.max(peakGainPct * 0.70, peakGainPct - 0.45, roundTripFeePct + 0.25);
+    if (curGainPct <= trailFloorPct && curGainPct >= roundTripFeePct + 0.10) {
+      return `Фиксация прибыли (Take-Profit: пик +${round(peakGainPct, 2)}% → +${round(curGainPct, 2)}%)`;
+    }
+  }
+  // 2) Защита заработанного плюса / безубытка (от +0.75% на 1-м эшелоне и от +0.90% на 2-м эшелоне):
+  // не позволяем плюсовой сделке развернуться обратно в убыток
+  if (peakGainPct >= 0.75 * tierMult) {
+    const breakevenFloorPct = Math.max(roundTripFeePct + 0.18, peakGainPct * 0.40);
+    if (curGainPct <= breakevenFloorPct) {
+      return `Защита прибыли от отката (пик +${round(peakGainPct, 2)}% → фиксация +${round(curGainPct, 2)}%)`;
+    }
+  }
+  return null;
+}
 function sessionEdgeWarning(now = Date.now()) {
   const d = new Date(now + MSK);
   const mins = d.getUTCHours() * 60 + d.getUTCMinutes();
@@ -1574,17 +1632,45 @@ function sessionEdgeWarning(now = Date.now()) {
 }
 
 // ---------- формирование и исполнение пакета лимитных заявок ----------
-const accountBusyLocks = new Set();
+const ACCOUNT_LOCK_TTL_MS = 75000;
+const accountBusyLocks = new Map(); // id -> { since, token }
+
+function isAccountBusy(id) {
+  const cur = accountBusyLocks.get(id);
+  if (!cur) return false;
+  if (Date.now() - cur.since >= ACCOUNT_LOCK_TTL_MS) {
+    accountBusyLocks.delete(id);
+    return false;
+  }
+  return true;
+}
+
+function acquireAccountLock(id) {
+  if (isAccountBusy(id)) return null;
+  const token = Symbol(id);
+  accountBusyLocks.set(id, { since: Date.now(), token });
+  return token;
+}
 
-export async function prepareBrokerOrders(id, { onlyEntries = false } = {}) {
-  if (accountBusyLocks.has(id)) return brokersState();
-  accountBusyLocks.add(id);
+function releaseAccountLock(id, token) {
+  const cur = accountBusyLocks.get(id);
+  if (cur && (!token || cur.token === token)) {
+    accountBusyLocks.delete(id);
+  }
+}
+
+export async function prepareBrokerOrders(id, { onlyEntries = false, scheduledBarTs = 0 } = {}) {
+  const lockToken = acquireAccountLock(id);
+  if (!lockToken) return brokersState();
   try {
   let list = loadRawAccounts();
   let acc = list.find((x) => x.id === id);
   if (!acc) throw new Error('Счёт не найден');
   if (acc.haltedReason) throw new Error(acc.haltedReason);
   const edgeWarn = acc.skipEdgeMinutes ? sessionEdgeWarning() : null;
+  if (onlyEntries && edgeWarn) {
+    return brokersState();
+  }
 
   const plan = effectivePlan(currentUser());
   if ((plan.maxBrokerAccounts ?? 0) < 1) {
@@ -1602,11 +1688,11 @@ export async function prepareBrokerOrders(id, { onlyEntries = false } = {}) {
     acc = list.find((x) => x.id === id) || acc;
   }
   const params = normalizeParams(getSettings());
-  const [fc, rawSpecs, shortableMap] = await Promise.all([
+  const [fc, rawSpecs, shortableMap] = await withWallTimeout(Promise.all([
     forecastNow(params),
     ensureBoardSpecs(),
     ensureTbankShortableMap(acc),
-  ]);
+  ]), 55000, 'Превышено время ожидания расчёта прогноза');
   const specs = { ...rawSpecs };
   if (acc.broker === 'tbank') {
     const tbSpecs = kvGet('tbankShortableMap')?.specMap || {};
@@ -1649,6 +1735,7 @@ export async function prepareBrokerOrders(id, { onlyEntries = false } = {}) {
   const timeOk = !autoAdapt || canEnterIntraday(nowTs, H, BAR_INTERVAL);
   const entryTsMap = acc.entryTsBySymbol || {};
   const exitCooldownMap = acc.exitCooldownBySymbol || {};
+  const entryFailMap = acc.entryFailCooldownBySymbol || {};
   // Спред-фильтр реального стакана по эшелонам ликвидности: для 2–3 эшелона порог выше в TIER2_EDGE_MULT раз.
   // Отдельного вечернего ужесточения нет: проверка 23.10.2026 (первые 70% и последние 30% истории) показала,
   // что порог ×1,25 после 19:00 МСК снижает итог на обеих частях — правила совпадают с бэктестом.
@@ -1658,7 +1745,10 @@ export async function prepareBrokerOrders(id, { onlyEntries = false } = {}) {
   const minShortEdgePct = round(baseShortNeedPct, 3);
   const reqBuyEdgeOf = (sym) => rowMap.get(sym)?.buyThresholdPct ?? round(Math.max(minBuyEdgePct * symbolEdgeMult(sym), 0.30), 3);
   const reqShortEdgeOf = (sym) => rowMap.get(sym)?.shortThresholdPct ?? round(Math.max(minShortEdgePct * symbolEdgeMult(sym), 0.31), 3);
-  const isInCooldown = (sym) => autoAdapt && exitCooldownMap[sym] && (nowTs - exitCooldownMap[sym] < 60 * 60000);
+  const isInCooldown = (sym) => Boolean(
+    (autoAdapt && exitCooldownMap[sym] && (nowTs - exitCooldownMap[sym] < 60 * 60000)) ||
+    (entryFailMap[sym] && (nowTs - entryFailMap[sym] < 5 * 60000)),
+  );
   // Самообучение на истории реальных сделок счёта (адаптивный карантин убыточных бумаг, единый с research.js):
   // если за последние 15 торговых дней по бумаге накоплен убыток (< -1.2% за >= 2 сделки или одиночный пролив < -2.5%),
   // временно исключаем такую бумагу из новых входов!
@@ -1756,11 +1846,12 @@ export async function prepareBrokerOrders(id, { onlyEntries = false } = {}) {
   const smoothSellPool = [];
   const peakMap = acc.peakPriceBySymbol || {};
   const roundTripFeePct = 2 * ((Number(params.commissionPct) || 0.04) + (Number(params.slippagePct) || 0.01));
-  // 1) закрытие бумаг стратегии (покупок и шортов):
+  // 1) закрытие бумаг стратегии (покупок и шортов) на плановом шаге (!onlyEntries):
   // • по фиксации реальной прибыли (Take-Profit / Trailing Stop от лучшей достигнутой цены peakPrice, чтобы не отдавать заработанный плюс в минус!),
   // • либо если прогноз ослаб ниже порога выхода curExitThr.
+  // В быстром цикле добора (onlyEntries) закрывающие заявки не формируются — сопровождение и выходы идут строго по плановому шагу (и защитным стопам).
   // Облигации, фонды (LQDT/TMOS) и бумаги вне словаря MOEXBMI (!rowMap.has(sym)) не затрагиваются никогда
-  for (const [sym, pos] of heldMap) {
+  for (const [sym, pos] of (onlyEntries ? [] : heldMap)) {
     if (!pos.qty) continue;
     const r = rowMap.get(sym);
     if (!r) continue;
@@ -1773,30 +1864,39 @@ export async function prepareBrokerOrders(id, { onlyEntries = false } = {}) {
     const lastHistEntryTs = lastHistEntryOp?.date || 0;
     const effEntryTs = Math.max(entryTsMap[sym] || 0, lastHistEntryTs);
     const heldMs = effEntryTs > 0 ? Math.max(0, nowTs - effEntryTs) : 0;
-    // Как в эталонном симуляторе (research.js): первые 65 минут после открытия позиции действует мягкий порог удержания (0.35),
-    // чтобы не резать сделку от рыночного шума каждые 30 минут; затем включается плотный порог фиксации (0.95) с учётом эшелона
+    const heldMin = heldMs / 60000;
+    const horizonMin = Math.max(90, effHorizon * 60);
+    // Плавный переход порога удержания от мягкого (0.35 до 45 мин) к плотному (0.95 к концу горизонта 2.5 ч) без резкой «ступеньки» на 65-й минуте
     const symMult = r.edgeMult || symbolEdgeMult(sym);
-    const curExitThr = round(((autoAdapt && heldMs <= 65 * 60000) ? earlyExitThresholdPct : exitThresholdPct) * symMult, 3);
+    const rampProgress = autoAdapt ? (heldMin <= 45 ? 0 : Math.min(1, (heldMin - 45) / (horizonMin - 45))) : 1;
+    const rampedExitThr = earlyExitThresholdPct + (exitThresholdPct - earlyExitThresholdPct) * rampProgress;
+    const curExitThr = round(rampedExitThr * symMult, 3);
+    const softExitThr = round(earlyExitThresholdPct * symMult, 3);
     const nightExit = !onlyEntries && autoAdapt && shouldExitBeforeNight(nowTs, effEntryTs, stepBars, BAR_INTERVAL);
     const curPx = Number(r.price || pos.price) || 0;
     const avgPx = Number(pos.avgPrice) > 0 ? Number(pos.avgPrice) : (Number(lastHistEntryOp?.price) || curPx);
     if (aQty > 0) {
       const lots = Math.floor(aQty / sp.lotSize);
       const curGainPct = avgPx > 0 ? ((curPx - avgPx) / avgPx) * 100 : 0;
+      const profitLockReason = autoAdapt ? evaluateProfitLock(sym, 'long', avgPx, curPx, Number(peakMap[sym]) || 0, roundTripFeePct) : null;
       const hitHardStopLoss = curGainPct <= -5.0 || Boolean(autoAdapt && r.regimeCrash);
-      const keepByForecast = onlyEntries ? (r.liquid && r.expectedPct > -needPct) : (r.liquid && r.expectedPct > curExitThr);
+      // Если горизонт 2.5 ч ещё не вышел и прогноз смотрит в сторону лонга (> softExitThr), не режем позицию на локальном минутном откате в мелкий минус
+      const holdThroughMinorDip = autoAdapt && heldMin < horizonMin && r.liquid && r.expectedPct > softExitThr && curGainPct >= -1.0 && curGainPct < roundTripFeePct + 0.12;
+      const keepByForecast = onlyEntries ? (r.liquid && r.expectedPct > -needPct) : (r.liquid && (r.expectedPct > curExitThr || holdThroughMinorDip));
       const dg = divGuardOf(sym, curPx);
       const divExit = Boolean(dg?.exitLong);
-      const keep = keepByForecast && !hitHardStopLoss && !divExit && !nightExit;
+      const keep = keepByForecast && !profitLockReason && !hitHardStopLoss && !divExit && !nightExit;
       if (lots >= 1 && !keep) {
         const limitPrice = sniperLimitPrice(curPx, -1, acc.limitOffsetPct, sp);
         const exitReason = hitHardStopLoss
           ? `Защитный стоп-лосс позиции (${round(curGainPct, 2)}%)`
-          : divExit
-            ? `Дивидендная отсечка ${dg.exDate} (дивиденд ${dg.yieldPct}%): закрытие покупки в последний день с правом, чтобы не терять 13% налога с дивиденда`
-            : nightExit
-              ? 'Закрытие внутридневной позиции перед ночным клирингом (защита от утреннего гэпа)'
-              : `Выход из покупки: ожидание ${r.expectedPct > 0 ? '+' : ''}${r.expectedPct}% ниже порога удержания +${curExitThr}%`;
+          : profitLockReason
+            ? profitLockReason
+            : divExit
+              ? `Дивидендная отсечка ${dg.exDate} (дивиденд ${dg.yieldPct}%): закрытие покупки в последний день с правом, чтобы не терять 13% налога с дивиденда`
+              : nightExit
+                ? 'Закрытие внутридневной позиции перед ночным клирингом (защита от утреннего гэпа)'
+                : `Выход из покупки: ожидание ${r.expectedPct > 0 ? '+' : ''}${r.expectedPct}% ниже порога удержания +${curExitThr}%`;
         orders.push({
           symbol: sym, action: 'sell', lotSize: sp.lotSize, lots, shares: lots * sp.lotSize,
           refPrice: curPx, limitPrice, amountRub: round(lots * sp.lotSize * limitPrice, 2),
@@ -1808,20 +1908,25 @@ 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 profitLockReason = autoAdapt ? evaluateProfitLock(sym, 'short', avgPx, curPx, Number(peakMap[sym]) || 0, roundTripFeePct) : null;
       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);
+      // Если горизонт 2.5 ч ещё не вышел и прогноз смотрит в сторону шорта (< -softExitThr), не закрываем шорт на минутном шипе в мелкий минус
+      const holdThroughMinorSpike = autoAdapt && heldMin < horizonMin && dir !== 'long' && r.liquid && r.expectedPct < -softExitThr && curGainPct >= -1.0 && curGainPct < roundTripFeePct + 0.12;
+      const keepByForecast = onlyEntries ? (dir !== 'long' && r.liquid && r.expectedPct < needPct) : (dir !== 'long' && r.liquid && (r.expectedPct < -curExitThr || holdThroughMinorSpike));
       const dg = divGuardOf(sym, curPx);
       const divExit = Boolean(dg?.exitShort);
-      const keep = keepByForecast && !hitHardStopLoss && !divExit && !nightExit;
+      const keep = keepByForecast && !profitLockReason && !hitHardStopLoss && !divExit && !nightExit;
       if (lots >= 1 && !keep) {
         const limitPrice = sniperLimitPrice(curPx, 1, acc.limitOffsetPct, sp);
         const exitReason = hitHardStopLoss
           ? `Защитный стоп-лосс шорта от выноса вверх (${round(curGainPct, 2)}%)`
-          : divExit
-            ? `Дивидендная отсечка ${dg.exDate} (дивиденд ${dg.yieldPct}%): закрытие шорта в последний день с правом, чтобы брокер не списал компенсацию дивиденда`
-            : nightExit
-              ? 'Закрытие короткой позиции перед ночным клирингом (защита от утреннего гэпа и платы за перенос)'
-              : `Закрытие шорта: ожидание ${r.expectedPct > 0 ? '+' : ''}${r.expectedPct}% выше порога удержания −${curExitThr}%`;
+          : profitLockReason
+            ? profitLockReason
+            : divExit
+              ? `Дивидендная отсечка ${dg.exDate} (дивиденд ${dg.yieldPct}%): закрытие шорта в последний день с правом, чтобы брокер не списал компенсацию дивиденда`
+              : nightExit
+                ? 'Закрытие короткой позиции перед ночным клирингом (защита от утреннего гэпа и платы за перенос)'
+                : `Закрытие шорта: ожидание ${r.expectedPct > 0 ? '+' : ''}${r.expectedPct}% выше порога удержания −${curExitThr}%`;
         orders.push({
           symbol: sym, action: 'cover', lotSize: sp.lotSize, lots, shares: lots * sp.lotSize,
           refPrice: curPx, limitPrice, amountRub: round(lots * sp.lotSize * limitPrice, 2),
@@ -2128,11 +2233,21 @@ export async function prepareBrokerOrders(id, { onlyEntries = false } = {}) {
   }
 
   const batchNowTs = Date.now();
+  const batchOrderSig = (arr) => (Array.isArray(arr) ? arr.map((o) => `${o.action}:${o.symbol}:${o.lots}`).join('|') : '');
+  const prevPending = acc.pendingBatch;
+  const curBatchSig = batchOrderSig(orders);
+  const isDuplicatePending = Boolean(
+    curBatchSig &&
+    prevPending?.status === 'pending' &&
+    batchOrderSig(prevPending.orders) === curBatchSig &&
+    batchNowTs - (prevPending.createdAt || 0) < 2 * 3600000,
+  );
   if (!onlyEntries) {
     acc.lastFullStepWallTs = batchNowTs;
+    if (scheduledBarTs > 0) acc.lastScheduledBarTs = scheduledBarTs;
   }
   acc.pendingBatch = {
-    id: `batch_${batchNowTs}`,
+    id: isDuplicatePending && prevPending?.id ? prevPending.id : `batch_${batchNowTs}`,
     createdAt: batchNowTs,
     bar: fc.bar,
     budgetRub: budget,
@@ -2149,16 +2264,18 @@ export async function prepareBrokerOrders(id, { onlyEntries = false } = {}) {
     results: [],
   };
   saveRawAccounts(list);
-  notifyBrokerBatch(currentUserId(), acc, acc.pendingBatch).catch(() => {});
   if (acc.mode === 'auto' && !edgeWarn && acc.token && orders.length) {
     return await executeBrokerOrders(id, { _lockHeld: true });
   }
+  if (acc.mode === 'confirm' && orders.length && !isDuplicatePending) {
+    notifyBrokerBatch(currentUserId(), acc, acc.pendingBatch).catch(() => {});
+  }
   const st = brokersState();
   hub.emit({ type: 'brokers:update', state: st });
   hub.emit({ type: 'trading:pulse', kind: 'broker_done', ts: Date.now(), accountId: acc.id, name: acc.name, ordersCount: orders.length });
   return st;
   } finally {
-    accountBusyLocks.delete(id);
+    releaseAccountLock(id, lockToken);
   }
 }
 
@@ -2258,7 +2375,7 @@ async function sendOrderToBroker(acc, ord) {
       for (const ao of jActive?.orders || []) {
         const sameInst = ao.instrumentUid === instrumentId || ao.figi === instrumentId || ao.ticker === ord.symbol;
         const sameDir = String(ao.direction || '').includes(wantDir);
-        if (sameInst && sameDir && ao.orderId) {
+        if (sameInst && (sameDir || !isEntry) && ao.orderId) {
           await brokerFetch(`${base}/tinkoff.public.invest.api.contract.v1.OrdersService/CancelOrder`, {
             method: 'POST', headers, body: JSON.stringify({ accountId: acc.accountId, orderId: ao.orderId }), timeoutMs: 8000,
           }).catch(() => null);
@@ -2474,12 +2591,13 @@ async function sendOrderToBroker(acc, ord) {
 }
 
 export async function executeBrokerOrders(id, { _lockHeld = false } = {}) {
+  let lockToken = null;
   if (!_lockHeld) {
     // Счёт может быть занят пересчётом заявок (после перезапуска — обучением прогноза): ждём до 15 с, а не молча пропускаем
     const waitUntil = Date.now() + 15000;
-    while (accountBusyLocks.has(id) && Date.now() < waitUntil) await new Promise((r) => setTimeout(r, 300));
-    if (accountBusyLocks.has(id)) throw new Error('Счёт сейчас занят пересчётом заявок — повторите через минуту');
-    accountBusyLocks.add(id);
+    while (isAccountBusy(id) && Date.now() < waitUntil) await new Promise((r) => setTimeout(r, 300));
+    lockToken = acquireAccountLock(id);
+    if (!lockToken) throw new Error('Счёт сейчас занят пересчётом заявок — повторите через минуту');
   }
   try {
     const list = loadRawAccounts();
@@ -2501,8 +2619,10 @@ export async function executeBrokerOrders(id, { _lockHeld = false } = {}) {
     saveRawAccounts(list);
     const prevResults = new Map((batch.results || []).filter((r) => r.ok && r.clientOrderId).map((r) => [r.clientOrderId, r]));
     const results = [];
+    const newlySentOrders = [];
     acc.entryTsBySymbol = acc.entryTsBySymbol || {};
     acc.exitCooldownBySymbol = acc.exitCooldownBySymbol || {};
+    acc.entryFailCooldownBySymbol = acc.entryFailCooldownBySymbol || {};
     acc.peakPriceBySymbol = acc.peakPriceBySymbol || {};
     const execNowTs = Date.now();
     const exitOrders = batch.orders.filter((o) => o.action === 'sell' || o.action === 'cover');
@@ -2530,11 +2650,21 @@ export async function executeBrokerOrders(id, { _lockHeld = false } = {}) {
           }
         }
         const r = await sendOrderToBroker(acc, ord);
+        if (r.lots > 0) {
+          ord.lots = r.lots;
+          ord.shares = r.lots * (ord.lotSize || 1);
+        }
+        if (r.limitPrice > 0) {
+          ord.limitPrice = r.limitPrice;
+          ord.amountRub = round((ord.shares || ord.lots) * r.limitPrice, 2);
+        }
         results.push({ symbol: ord.symbol, ok: true, orderId: r.orderId, clientOrderId: ord.clientOrderId });
+        newlySentOrders.push(ord);
         if (ord.action === 'buy' || ord.action === 'short') {
           acc.entryTsBySymbol[ord.symbol] = execNowTs;
           acc.peakPriceBySymbol[ord.symbol] = Number(ord.limitPrice || ord.refPrice) || 0;
           delete acc.exitCooldownBySymbol[ord.symbol];
+          delete acc.entryFailCooldownBySymbol[ord.symbol];
         } else if (ord.action === 'sell' || ord.action === 'cover') {
           hadExits = true;
           delete acc.entryTsBySymbol[ord.symbol];
@@ -2547,6 +2677,9 @@ export async function executeBrokerOrders(id, { _lockHeld = false } = {}) {
         ord.sendAttempts = (ord.sendAttempts || 0) + 1;
         if (e.definitive) ord.clientOrderId = crypto.randomUUID();
         else ord.uncertainSend = true;
+        if (ord.action === 'buy' || ord.action === 'short') {
+          acc.entryFailCooldownBySymbol[ord.symbol] = execNowTs;
+        }
         results.push({ symbol: ord.symbol, ok: false, error: e.message, uncertain: !e.definitive });
         logBrokerEvent(acc, 'order_error', `${ord.action} ${ord.symbol} ${ord.lots} л.: ${e.message}`);
       }
@@ -2555,6 +2688,9 @@ export async function executeBrokerOrders(id, { _lockHeld = false } = {}) {
     batch.results = results;
     batch.executedAt = Date.now();
     saveRawAccounts(list);
+    if (acc.mode === 'auto' && newlySentOrders.length > 0) {
+      notifyBrokerBatch(currentUserId(), acc, { ...batch, orders: newlySentOrders }).catch(() => {});
+    }
     await syncBrokerAccount(id).catch(() => {});
     if (acc.broker === 'tbank' && acc.token) {
       await fetchBrokerHistory(id).catch(() => {});
@@ -2563,7 +2699,7 @@ export async function executeBrokerOrders(id, { _lockHeld = false } = {}) {
     hub.emit({ type: 'brokers:update', state: st });
     return st;
   } finally {
-    if (!_lockHeld) accountBusyLocks.delete(id);
+    if (!_lockHeld && lockToken) releaseAccountLock(id, lockToken);
   }
 }
 
@@ -2789,24 +2925,27 @@ 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 lastFullWallTs = acc.lastFullStepWallTs || 0;
-          const lastAnyWallTs = acc.pendingBatch?.executedAt || acc.pendingBatch?.createdAt || 0;
+          const rawLastFullWallTs = acc.lastFullStepWallTs || 0;
+          const batchCreatedTs = acc.pendingBatch?.createdAt || 0;
+          const lastAnyWallTs = acc.pendingBatch?.executedAt || batchCreatedTs || 0;
+          // Если отметка шага была записана без фактического обновления pendingBatch, не считаем такой шаг состоявшимся
+          const lastFullWallTs = batchCreatedTs >= rawLastFullWallTs - 60000 ? rawLastFullWallTs : batchCreatedTs;
+          const lastSchedBarTs = batchCreatedTs >= rawLastFullWallTs - 60000 ? (acc.lastScheduledBarTs || 0) : 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(
             nightExitDue || (
               latest &&
-              (latest - (acc.lastScheduledBarTs || 0) >= minStepMs) &&
+              (latest - lastSchedBarTs >= minStepMs) &&
               !(lastFullWallTs > 0 && nowTs - lastFullWallTs < minStepMs - 5 * 60000)
             ),
           );
           if (dueFullStep) {
-            acc.lastScheduledBarTs = latest || acc.lastScheduledBarTs || nowTs;
-            acc.lastFullStepWallTs = nowTs;
-            saveRawAccounts(list);
+            if (isAccountBusy(acc.id)) continue;
+            const stepBarTs = latest || acc.lastScheduledBarTs || nowTs;
             if (acc.token) await syncBrokerAccount(acc.id).catch(() => {});
-            await prepareBrokerOrders(acc.id).catch(() => {});
+            await prepareBrokerOrders(acc.id, { scheduledBarTs: stepBarTs }).catch(() => {});
             continue;
           }
           // Мгновенный перехват новых сигналов «купить» / «шорт» при наличии свободных рублей или резерва в LQDT (каждые 20 секунд, не дожидаясь конца 30-минутного шага!):
@@ -2814,7 +2953,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 && nowTs - Math.max(lastFullWallTs, lastAnyWallTs) >= 20000) {
+          if (acc.mode === 'auto' && acc.token && !(acc.skipEdgeMinutes && sessionEdgeWarning(nowTs)) && freeCashRub >= 15000 && nowTs - Math.max(lastFullWallTs, lastAnyWallTs) >= 20000) {
             await prepareBrokerOrders(acc.id, { onlyEntries: true }).catch(() => {});
           }
         }
@@ -2920,12 +3059,12 @@ async function reconcileBrokerStops(accId) {
     return;
   }
   if (!acc.lastSync?.ok) return;
-  if (accountBusyLocks.has(accId)) return; // идёт исполнение пакета — сверимся в следующий раз
-  accountBusyLocks.add(accId);
+  const lockToken = acquireAccountLock(accId);
+  if (!lockToken) return; // идёт исполнение пакета — сверимся в следующий раз
   try {
-    await reconcileBrokerStopsLocked(list, acc);
+    await withWallTimeout(reconcileBrokerStopsLocked(list, acc), 35000, 'Превышено время сверки стоп-заявок');
   } finally {
-    accountBusyLocks.delete(accId);
+    releaseAccountLock(accId, lockToken);
   }
 }
 
@@ -3044,8 +3183,7 @@ async function checkIntradayProfitLock(accId) {
     if (!sym || pos.instrumentType === 'etf' || pos.instrumentType === 'bond' || sym === 'LQDT' || sym === 'TMON@' || sym === 'TMON' || sym === 'SBMM') continue;
     const aQty = algoQtyOf(sym, pos.qty);
     if (!aQty) continue;
-    // позицию уже защищает стоп-заявка у брокера — внутренний стоп не дублируем
-    if (acc.brokerStops && acc.brokerStopBySymbol?.[sym]) continue;
+    const hasBrokerHardStop = Boolean(acc.brokerStops && acc.brokerStopBySymbol?.[sym]);
     // Если по этой бумаге в стакане УЖЕ висит закрывающая заявка (sell для лонга или buy для шорта) — не дублируем
     const wantCloseDir = aQty > 0 ? 'sell' : 'buy';
     if ((acc.lastSync?.activeOrders || []).some((o) => o.symbol === sym && o.direction === wantCloseDir)) continue;
@@ -3062,26 +3200,30 @@ async function checkIntradayProfitLock(accId) {
       const lots = Math.floor(aQty / sp.lotSize);
       if (lots < 1) continue;
       const curGainPct = ((curPx - avgPx) / avgPx) * 100;
-      const hitHardStopLoss = curGainPct <= -BROKER_STOP_LONG_PCT;
-      if (hitHardStopLoss) {
+      const profitLockReason = evaluateProfitLock(sym, 'long', avgPx, curPx, Number(peakMap[sym]) || 0, roundTripFeePct);
+      const hitHardStopLoss = !hasBrokerHardStop && curGainPct <= -BROKER_STOP_LONG_PCT;
+      if (hitHardStopLoss || profitLockReason) {
         const limitPrice = sniperLimitPrice(curPx, -1, acc.limitOffsetPct, sp);
         lockOrders.push({
           symbol: sym, action: 'sell', lotSize: sp.lotSize, lots, shares: lots * sp.lotSize,
           refPrice: curPx, limitPrice, amountRub: round(lots * sp.lotSize * limitPrice, 2),
-          reason: `Авто-стоп позиции (${round(curGainPct, 2)}%)`,
+          reason: hitHardStopLoss ? `Авто-стоп позиции (${round(curGainPct, 2)}%)` : profitLockReason,
+          isStopLoss: hitHardStopLoss,
         });
       }
     } else if (aQty < 0) {
       const lots = Math.floor(Math.abs(aQty) / sp.lotSize);
       if (lots < 1) continue;
       const curGainPct = ((avgPx - curPx) / avgPx) * 100;
-      const hitHardStopLoss = curGainPct <= -BROKER_STOP_SHORT_PCT;
-      if (hitHardStopLoss) {
+      const profitLockReason = evaluateProfitLock(sym, 'short', avgPx, curPx, Number(peakMap[sym]) || 0, roundTripFeePct);
+      const hitHardStopLoss = !hasBrokerHardStop && curGainPct <= -BROKER_STOP_SHORT_PCT;
+      if (hitHardStopLoss || profitLockReason) {
         const limitPrice = sniperLimitPrice(curPx, 1, acc.limitOffsetPct, sp);
         lockOrders.push({
           symbol: sym, action: 'cover', lotSize: sp.lotSize, lots, shares: lots * sp.lotSize,
           refPrice: curPx, limitPrice, amountRub: round(lots * sp.lotSize * limitPrice, 2),
-          reason: `Авто-стоп шорта от выноса вверх (${round(curGainPct, 2)}%)`,
+          reason: hitHardStopLoss ? `Авто-стоп шорта от выноса вверх (${round(curGainPct, 2)}%)` : profitLockReason,
+          isStopLoss: hitHardStopLoss,
         });
       }
     }
@@ -3089,6 +3231,7 @@ async function checkIntradayProfitLock(accId) {
 
   if (!lockOrders.length) return;
   const results = [];
+  const sentLockOrders = [];
   const execNowTs = Date.now();
   acc.entryTsBySymbol = acc.entryTsBySymbol || {};
   acc.exitCooldownBySymbol = acc.exitCooldownBySymbol || {};
@@ -3099,16 +3242,25 @@ async function checkIntradayProfitLock(accId) {
     await cancelBrokerOrder(accId, co.orderId).catch(() => {});
   }
   for (const ord of lockOrders) {
-    logBrokerEvent(acc, 'protective_stop', `${ord.reason}: ${ord.action} ${ord.symbol} ${ord.lots} л.`);
+    logBrokerEvent(acc, ord.isStopLoss ? 'protective_stop' : 'profit_lock', `${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);
+      if (r.lots > 0) {
+        ord.lots = r.lots;
+        ord.shares = r.lots * (ord.lotSize || 1);
+      }
+      if (r.limitPrice > 0) {
+        ord.limitPrice = r.limitPrice;
+        ord.amountRub = round((ord.shares || ord.lots) * r.limitPrice, 2);
+      }
       results.push({ symbol: ord.symbol, ok: true, orderId: r.orderId });
+      sentLockOrders.push(ord);
       delete acc.entryTsBySymbol[ord.symbol];
       delete acc.peakPriceBySymbol[ord.symbol];
-      acc.exitCooldownBySymbol[ord.symbol] = execNowTs;
+      if (ord.isStopLoss) acc.exitCooldownBySymbol[ord.symbol] = execNowTs;
     } catch (e) {
       results.push({ symbol: ord.symbol, ok: false, error: e.message });
       logBrokerEvent(acc, 'protective_stop_error', `${ord.symbol}: ${e.message}`);
@@ -3119,12 +3271,15 @@ async function checkIntradayProfitLock(accId) {
     id: `batch_stop_${execNowTs}`,
     createdAt: execNowTs,
     executedAt: execNowTs,
-    bar: `${fmtBarMsk(execNowTs)} (Защитный стоп)`,
+    bar: `${fmtBarMsk(execNowTs)} (Фиксация прибыли / Защита)`,
     orders: lockOrders,
     status: results.every((r) => r.ok) ? 'executed' : 'partial',
     results,
   };
   saveRawAccounts(list);
+  if (sentLockOrders.length > 0) {
+    notifyBrokerBatch(currentUserId(), acc, { ...acc.pendingBatch, orders: sentLockOrders }).catch(() => {});
+  }
   await syncBrokerAccount(accId).catch(() => {});
   const st = brokersState();
   hub.emit({ type: 'brokers:update', state: st });
@@ -3151,7 +3306,9 @@ async function tickBrokerAutoRefresh() {
           if (acc.broker === 'tbank' && (acc.brokerStops || Object.keys(acc.brokerStopBySymbol || {}).length)) {
             await reconcileBrokerStops(acc.id).catch((e) => logBrokerEvent(acc, 'broker_stop_error', `сверка: ${e.message}`));
           }
-          if (acc.broker === 'tbank' && (!acc.lastHistory?.at || Date.now() - acc.lastHistory.at >= 120000)) {
+          const latestEntryTs = Math.max(0, ...Object.values(acc.entryTsBySymbol || {}).map(Number).filter(Number.isFinite));
+          const historyNeedSync = !acc.lastHistory?.at || Date.now() - acc.lastHistory.at >= 45000 || (latestEntryTs > (acc.lastHistory.at || 0));
+          if (acc.broker === 'tbank' && historyNeedSync) {
             await fetchBrokerHistory(acc.id, { year: curYear }).catch(() => {});
           }
           // Поддерживаем живой кэш прогноза всегда горячим в памяти сервера (даже когда браузер свёрнут)