neuroalpha 0.6.10 → 0.6.12

package/server/brokers/index.js

@@ -13,7 +13,10 @@ import { barsFromHours, BAR_INTERVAL, BAR_MS } from '../model/dataset.js';
 import { forecastNow } from '../model/forecast.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 {
+  STRATEGY_POLICY, sessionEdgeWarning, evaluateProfitLock, protectiveStopPct, exitHoldRatio,
+  planSizingProfile, convictionMult, tierSizeMult, symbolCapRub, targetPositionRub, waterFillAllocations, MAX_LEVERAGE,
+} from '../model/policy.js';
 import { MODELS } from '../model/models.js';
 import { blockingNews } from '../news/index.js';
 import { round, MSK, DAY, fmtBarMsk } from '../util.js';
@@ -2093,32 +2096,25 @@ export async function prepareBrokerOrders(id, { onlyEntries = false, scheduledBa
     return isStockQuarantined(q.cnt, q.pnlPct / 100, edgeRatio);
   };
   const slots = dir === 'long' ? K : 2 * K;
-  // Фильтр мощности слота по тарифу:
-  // • Инвестор: 1 счёт до 1 млн ₽, только покупки (без шортов), консервативный слот до 24% капитала
-  // • Профи: до 5 счетов по 1 млн ₽, покупки + шорты, базовый слот до 28% капитала
-  // • VIP: счета и сумма по договору, покупки + шорты, слот до 48% капитала
-  // • Хозяин: Conviction Sizing до 75% капитала
+  // Профиль мощности слотов и индивидуальных потолков по тарифу (единый с бэктестом, server/model/policy.js):
+  // • Инвестор: 1 счёт до 1 млн ₽, только покупки (без шортов), слот до 58% T1 / 14% T2
+  // • Профи: до 5 счетов по 1 млн ₽, покупки + шорты, плечо до 3×, слот до 52% T1 / 12% T2
+  // • VIP: счета и сумма по договору, Conviction Sizing до 75% T1 / 14% T2
+  // • Хозяин: живой Conviction Sizing до 92% T1 лонг / 70% T1 шорт (с сублинейным ростом по плечу)
   const isOwnerPlan = Boolean(plan.isOwner || plan.id === 'owner');
+  const sizingProfile = planSizingProfile(isOwnerPlan ? 'owner' : (vipBoost ? 'vip' : (plan.id || 'investor')), dir);
   let slotRub;
-  if (isOwnerPlan && autoAdapt) {
-    const maxSlotWeight = Math.min(0.45, Math.max(1 / K, 1.8 / K));
-    slotRub = budget * maxSlotWeight;
-  } else if (vipBoost && autoAdapt) {
-    const maxSlotWeight = Math.min(0.40, Math.max(1 / K, 1.4 / K));
-    slotRub = budget * maxSlotWeight;
+  if (autoAdapt) {
+    slotRub = budget * sizingProfile.slotW;
   } else if (plan.id === 'pro') {
     slotRub = budget * Math.min(0.28, 1.15 / Math.max(2, slots));
   } else {
     slotRub = budget * Math.min(0.24, 1.05 / Math.max(3, K + 1));
   }
-  // (Потолки доходности по тарифам и «дроссель» размера позиций удалены: тарифы различаются возможностями,
-  // а не обещанной доходностью — реалистичная доходность определяется стресс-тестом, а не тарифом.)
   const needPct = Math.max(0.01, Number(fc.thresholdPct || 0));
   const convOf = (r) => {
     if (!autoAdapt || !r.expectedPct) return 1;
-    if (isOwnerPlan) return Math.min(1.65, Math.max(0.85, 0.80 + 0.30 * (Math.abs(r.expectedPct) / needPct)));
-    if (vipBoost) return Math.min(1.30, Math.max(0.85, 0.80 + 0.25 * (Math.abs(r.expectedPct) / needPct)));
-    return 1;
+    return convictionMult(Math.abs(r.expectedPct) / needPct, sizingProfile);
   };
   const heldMap = new Map((acc.lastSync?.positions || []).map((p) => [p.symbol, p]));
   const rowMap = new Map((fc.rows || []).map((r) => [r.symbol, r]));
@@ -2315,67 +2311,21 @@ export async function prepareBrokerOrders(id, { onlyEntries = false, scheduledBa
   let usedRub = [...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)
     + (onlyEntries ? activePendingOrders.reduce((s, o) => s + Math.abs(Number(o.amountRub) || 0), 0) : 0);
 
-  // Ротация остывшей позиции в мощного нового лидера (Opportunity Rotation):
-  // если на счёте занято >65% бюджета, а на рынке появился новый лидер с прогнозом >= +0.55% (в 2.4 раза сильнее текущей остывшей бумаги),
-  // освобождаем слот под лидера, чтобы капитал не застревал в вялых позициях
-  if (!onlyEntries && autoAdapt && usedRub > budget * 0.65 * (marginSizing ? leverage : 1) && (buyCands.length > 0 || shortCands.length > 0)) {
-    const bestNewPct = Math.max(
-      buyCands.length ? Math.abs(buyCands[0].expectedPct || 0) : 0,
-      shortCands.length ? Math.abs(shortCands[0].expectedPct || 0) : 0,
-    );
-    if (bestNewPct >= needPct * 2.2) {
-      let weakestSym = null, weakestEdge = Infinity;
-      for (const [sym, pos] of heldMap) {
-        if (closing.has(sym) || !rowMap.has(sym)) continue;
-        const aQ = algoQtyOf(sym, pos.qty);
-        if (!aQ) continue;
-        const rCur = rowMap.get(sym);
-        const curSignedPct = aQ > 0 ? (rCur.expectedPct || 0) : -(rCur.expectedPct || 0);
-        if (curSignedPct < exitThresholdPct * 0.90 && curSignedPct < weakestEdge && bestNewPct > Math.max(needPct, curSignedPct) * 2.4) {
-          weakestEdge = curSignedPct;
-          weakestSym = sym;
-        }
-      }
-      if (weakestSym) {
-        const wPos = heldMap.get(weakestSym);
-        const wRow = rowMap.get(weakestSym);
-        const wSp = specs[weakestSym] || { lotSize: 1, minStep: 0.01, decimals: 2 };
-        const wAq = algoQtyOf(weakestSym, wPos.qty);
-        const wLots = Math.floor(Math.abs(wAq) / wSp.lotSize);
-        const wPx = Number(wRow?.price || wPos.price) || 0;
-        if (wLots >= 1 && wPx > 0) {
-          const isLongPos = wAq > 0;
-          const limPx = sniperLimitPrice(wPx, isLongPos ? -1 : 1, acc.limitOffsetPct, wSp);
-          orders.push({
-            symbol: weakestSym,
-            action: isLongPos ? 'sell' : 'cover',
-            lotSize: wSp.lotSize,
-            lots: wLots,
-            shares: wLots * wSp.lotSize,
-            refPrice: wPx,
-            limitPrice: limPx,
-            amountRub: round(wLots * wSp.lotSize * limPx, 2),
-            reason: `Ротация капитала из остывшей бумаги (${wRow?.expectedPct > 0 ? '+' : ''}${wRow?.expectedPct}%) в нового сильного лидера (${bestNewPct}%)`,
-          });
-          closing.add(weakestSym);
-          if (isLongPos) activeLongs = Math.max(0, activeLongs - 1);
-          else activeShorts = Math.max(0, activeShorts - 1);
-          usedRub = Math.max(0, usedRub - Math.abs(wAq * wPos.price));
-        }
-      }
-    }
-  }
-  const freedRub = orders.filter((o) => o.action === 'sell').reduce((s, o) => s + o.amountRub, 0);
-  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 = marginSizing
-    ? Math.max(0, budget * 0.99 * leverage - usedRub)
-    : Math.min(Math.max(0, budget * 0.99 - usedRub), Math.max(0, cashLimit));
+  const recomputeAvailRub = () => {
+    const freed = orders.filter((o) => o.action === 'sell').reduce((s, o) => s + o.amountRub, 0);
+    const coverSpent = orders.filter((o) => o.action === 'cover').reduce((s, o) => s + o.amountRub, 0);
+    const trimmedShortRub = orders.filter((o) => o.action === 'cover' && o.isTrim).reduce((s, o) => s + o.amountRub, 0);
+    const openShortRub = Math.max(0, [...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) - trimmedShortRub);
+    const cashLim = acc.lastSync?.cashRub !== undefined ? acc.lastSync.cashRub + freed - coverSpent - openShortRub : budget;
+    return marginSizing
+      ? Math.max(0, budget * 0.99 * leverage - usedRub)
+      : Math.min(Math.max(0, budget * 0.99 - usedRub), Math.max(0, cashLim));
+  };
+  let availRub = recomputeAvailRub();
 
-    // 2) вход в лучшие сигналы (с учётом лотности Мосбиржи, свободного лимита и адаптивного отбора числа акций Dynamic Top-K)
+  // 2) вход в лучшие сигналы (с учётом лотности Мосбиржи, свободного лимита и адаптивного отбора числа акций Dynamic Top-K)
   const rawNewBuys = buyCands.filter((r) => !(algoQtyOf(r.symbol, heldMap.get(r.symbol)?.qty || 0) > 0 && !closing.has(r.symbol)) && !(onlyEntries && activeOrderSymbols.has(r.symbol)));
   // Не открываем шорт по тикеру, в котором ещё лежит непроданный остаток старого портфеля (baseQty > 0), чтобы брокер не превратил шорт в продажу старой позиции
   const rawNewShorts = shortCands.filter((r) => {
@@ -2395,30 +2345,53 @@ export async function prepareBrokerOrders(id, { onlyEntries = false, scheduledBa
   const newBuys = buyExhaustion.ready;
   const newShorts = shortExhaustion.ready;
   const deferredByImpulse = [...buyExhaustion.deferred, ...shortExhaustion.deferred];
-  const totalNew = newBuys.length + newShorts.length;
-  const activeTotal = Math.max(2, activeLongs + activeShorts + totalNew);
-  const dynSlotRub = (isOwnerPlan && autoAdapt)
-    ? budget * Math.min(0.45, Math.max(slotRub / Math.max(1, budget), 1.8 / Math.min(slots, activeTotal + 1)))
-    : (vipBoost && autoAdapt)
-      ? budget * Math.min(0.40, Math.max(slotRub / Math.max(1, budget), 1.5 / Math.min(slots, activeTotal + 1)))
-      : slotRub;
+  const dynSlotRub = slotRub;
+
+  const netPickWeight = (r) => {
+    const rawPct = Math.abs(r.expectedPct || 0);
+    if (!autoAdapt) return Math.max(0.01, rawPct);
+    const roundTripCostPct = TIER1_LIQUID_SYMBOLS.has(r.symbol) ? 0.13 : 0.25;
+    return Math.max(0.01, rawPct - roundTripCostPct);
+  };
+  const calcDesiredNewRub = (r, side) => {
+    const isTier1 = TIER1_LIQUID_SYMBOLS.has(r.symbol);
+    const posSide = side === 'short' ? 'short' : 'long';
+    const tierMult = autoAdapt ? tierSizeMult(r.symbol, leverage, posSide) : 1;
+    const barTurnoverRub = !isTier1 ? recentBarTurnoverRub(r.symbol) : 0;
+    const stopPct = protectiveStopPct(posSide);
+    const effSlotRub = (params.modelAllocMode === 'invvol' && r.weight ? dynSlotRub * r.weight : dynSlotRub) * tierMult;
+    const targetRub = autoAdapt
+      ? targetPositionRub({ symbol: r.symbol, side: posSide, budget: budget * tierMult, slotRub: effSlotRub, conv: convOf(r), stopPct, barTurnoverRub, profile: sizingProfile })
+      : Math.min(symbolCapRub(r.symbol, posSide, budget * tierMult, barTurnoverRub), effSlotRub);
+    return { targetRub, tierMult, stopPct };
+  };
+
+  const combinedNew = [
+    ...newBuys.map((r) => ({ r, side: 'buy' })),
+    ...newShorts.map((r) => ({ r, side: 'short' })),
+  ];
+  if (autoAdapt && combinedNew.length > 1) {
+    combinedNew.sort((a, b) => netPickWeight(b.r) - netPickWeight(a.r));
+  }
+  const preparedNew = combinedNew.map(({ r, side }) => {
+    const { targetRub, tierMult, stopPct } = calcDesiredNewRub(r, side);
+    return { r, side, weight: netPickWeight(r), targetRub, tierMult, stopPct };
+  }).filter((x) => x.targetRub > 5000);
+  const totalDesiredNewRub = preparedNew.reduce((s, x) => s + x.targetRub, 0);
 
   // В режиме «Плавный переход» (smooth):
-  // • высвобождаем кэш из старого портфеля как под новые ПОКУПКИ, так и под новые ШОРТЫ (чтобы шорты открывались полным рабочим слотом dynSlotRub, а не на остаток копеек);
-  // • даже если прямо сейчас нет нового входа, но свободного кэша на счёте меньше 1 рабочего слота, плавно продаём на каждом шаге по 1–2 самые слабые старые акции с отрицательным прогнозом (expectedPct <= -0.02%), заранее формируя рублёвый резерв;
-  // • сортируем кандидатов строго по худшему прогнозу ИИ (сначала акции с отрицательным ожиданием, среди близких — позиции в плюсе или с минимальным убытком), до 4 бумаг за шаг при активном сигнале.
+  // • высвобождаем кэш из старого портфеля как под новые ПОКУПКИ, так и под новые ШОРТЫ;
+  // • даже если прямо сейчас нет нового входа, но свободного кэша на счёте меньше 1 рабочего слота, плавно продаём на каждом шаге по 1–2 самые слабые старые акции с отрицательным прогнозом (expectedPct <= -0.02%).
   if (legacyMode === 'smooth' && smoothSellPool.length > 0) {
-    const activeEntries = [...newBuys, ...newShorts];
-    const neededForSignalsRub = activeEntries.reduce((s, r) => s + (params.modelAllocMode === 'invvol' && r.weight ? dynSlotRub * r.weight : dynSlotRub) * convOf(r), 0);
+    const activeEntries = preparedNew.map((x) => x.r);
     const hasWeakLegacy = smoothSellPool.some((x) => (x.r.expectedPct || 0) <= -0.02);
     const proactiveReserveRub = (!activeEntries.length && hasWeakLegacy && availRub < slotRub) ? slotRub : 0;
-    const targetNeedRub = Math.max(neededForSignalsRub, proactiveReserveRub);
+    const targetNeedRub = Math.max(totalDesiredNewRub, proactiveReserveRub);
     let shortfall = Math.min(Math.max(0, budget * 0.99 - usedRub), targetNeedRub) - availRub;
     if (shortfall > 1000) {
       smoothSellPool.sort((a, b) => {
         const ea = Number(a.r.expectedPct || 0);
         const eb = Number(b.r.expectedPct || 0);
-        // Сначала бумаги с явно худшим прогнозом (разница > 0.03%), при близком прогнозе — сначала плюсовые/околонулевые
         if (Math.abs(ea - eb) > 0.03) return ea - eb;
         return ((b.pos.pnlRub >= 0 ? 1 : 0) - (a.pos.pnlRub >= 0 ? 1 : 0)) || (ea - eb);
       });
@@ -2445,27 +2418,15 @@ export async function prepareBrokerOrders(id, { onlyEntries = false, scheduledBa
       }
     }
   }
-  let remNew = totalNew;
-  const combinedNew = [
-    ...newBuys.map((r) => ({ r, side: 'buy' })),
-    ...newShorts.map((r) => ({ r, side: 'short' })),
-  ];
-  // Если включено «Свободные рубли в LQDT» (cashSweep) и для новых сигналов не хватает свободных рублей,
-  // сначала автоматически продаём нужное число паёв фонда ликвидности LQDT, которые открыла стратегия (сверх неприкосновенного baselineQty)
-  if (!collateral && acc.cashSweep && acc.broker === 'tbank' && combinedNew.length > 0 && !closing.has('LQDT') && !activeOrderSymbols.has('LQDT')) {
+
+  // Если включено «Свободные рубли в LQDT» (cashSweep) и счёт без залогового плеча (!collateral), при нехватке рублей продаём нужное число паёв LQDT
+  if (!collateral && acc.cashSweep && acc.broker === 'tbank' && preparedNew.length > 0 && !closing.has('LQDT') && !activeOrderSymbols.has('LQDT')) {
     const lqdtPos = heldMap.get('LQDT');
     const lqdtAlgoQty = lqdtPos ? algoQtyOf('LQDT', lqdtPos.qty) : 0;
     if (lqdtAlgoQty > 0 && lqdtPos.price > 0) {
       const lqdtSp = specs.LQDT || { lotSize: 1, minStep: 0.001, decimals: 3 };
       const lqdtLots = Math.floor(lqdtAlgoQty / lqdtSp.lotSize);
-      const neededForNewRub = combinedNew.reduce((s, { r, side }) => {
-        const isT1 = TIER1_LIQUID_SYMBOLS.has(r.symbol);
-        const rawCap = budget * (side === 'short' ? (isT1 ? 0.35 : 0.18) : (isT1 ? 0.45 : 0.22));
-        const barTurnRub = !isT1 ? recentBarTurnoverRub(r.symbol) : 0;
-        const liqCap = (!isT1 && barTurnRub > 0) ? Math.max(45000, Math.min(rawCap, barTurnRub * 0.12)) : rawCap;
-        return s + Math.min(liqCap, (params.modelAllocMode === 'invvol' && r.weight ? dynSlotRub * r.weight : dynSlotRub) * convOf(r));
-      }, 0);
-      const needFromLqdtRub = Math.min(Math.max(0, budget * 0.99 - usedRub), neededForNewRub) - availRub;
+      const needFromLqdtRub = Math.min(Math.max(0, budget * 0.99 - usedRub), totalDesiredNewRub) - availRub;
       if (lqdtLots >= 1 && needFromLqdtRub > 1500) {
         const limPx = sniperLimitPrice(lqdtPos.price, -1, 0.03, lqdtSp);
         const lotVal = limPx * lqdtSp.lotSize;
@@ -2474,46 +2435,114 @@ export async function prepareBrokerOrders(id, { onlyEntries = false, scheduledBa
         orders.push({
           symbol: 'LQDT', action: 'sell', lotSize: lqdtSp.lotSize, lots: sellLots, shares: sellLots * lqdtSp.lotSize,
           refPrice: lqdtPos.price, limitPrice: limPx, amountRub,
-          reason: `Высвобождение ${fmtRubSimple(amountRub)} ₽ из фонда денежного рынка LQDT под сигнал стратегии (${combinedNew.map((x) => x.r.symbol).join(', ')})`,
+          reason: `Высвобождение ${fmtRubSimple(amountRub)} ₽ из фонда денежного рынка LQDT под сигнал стратегии (${preparedNew.map((x) => x.r.symbol).join(', ')})`,
         });
         closing.add('LQDT');
         availRub += amountRub;
       }
     }
   }
-  if (autoAdapt && combinedNew.length > 1) {
-    combinedNew.sort((a, b) => Math.abs(b.r.expectedPct || 0) - Math.abs(a.r.expectedPct || 0));
-  }
-  let remWeightSum = combinedNew.reduce((s, x) => s + Math.max(0.01, Math.abs(x.r.expectedPct || 0)), 0);
-
-  // Жёсткий предохранитель концентрации на одну бумагу в реальном стакане брокера:
-  // • для ликвидных бумаг 1-го эшелона: до 45% счёта на один лонг и до 35% счёта на один шорт;
-  // • для бумаг 2–3 эшелона (MRKC, MRKZ, NKHP, AQUA, FESH, FEES и др.): до 22% счёта на один лонг и до 18% на один шорт,
-  //   чтобы крупная заявка не выкупала тонкий стакан против самой себя и всегда оставляла капитал на 3–4 бумаги!
-  const maxLongTier1Rub = budget * 0.45;
-  const maxShortTier1Rub = budget * 0.35;
-  const maxLongTier2Rub = budget * 0.22;
-  const maxShortTier2Rub = budget * 0.18;
-
-  for (const { r, side } of combinedNew) {
-    const wCur = Math.max(0.01, Math.abs(r.expectedPct || 0));
-    const propShare = autoAdapt && remWeightSum > 0 ? availRub * (wCur / remWeightSum) : availRub / Math.max(1, remNew);
-    remWeightSum = Math.max(0, remWeightSum - wCur);
-    remNew--;
+
+  // Двухступенчатое динамическое потеснение под новый сильный сигнал 1-го эшелона (единое с server/model/simulator.js):
+  // в режиме auto работает и на быстрых внутрисвечных входах, а в режиме confirm — на плановых 30-минутных шагах (!onlyEntries),
+  // ротируя остывшие позиции либо частично подрезая позицию 2-го эшелона (с сохранением entryTs и peakPrice оставшихся лотов).
+  if (autoAdapt && STRATEGY_POLICY.crowdOut !== false && (acc.mode === 'auto' || !onlyEntries) && preparedNew.length > 0) {
+    const bestT1 = preparedNew.find((x) => TIER1_LIQUID_SYMBOLS.has(x.r.symbol));
+    const minChunkRub = Math.max(45000, budget * (STRATEGY_POLICY.crowdMinPct ?? 0.06));
+    let shortfall = totalDesiredNewRub - availRub;
+    if (bestT1 && shortfall >= minChunkRub) {
+      const minHoldMs = (STRATEGY_POLICY.crowdMinMin ?? 20) * 60000;
+      const rotBufPct = STRATEGY_POLICY.crowdRotBufPct ?? 0.08;
+      const trimBufPct = STRATEGY_POLICY.crowdTrimBufPct ?? 0.12;
+      const elig = [];
+      for (const [sym, pos] of heldMap) {
+        if (closing.has(sym) || activeOrderSymbols.has(sym) || !rowMap.has(sym)) continue;
+        const aQ = algoQtyOf(sym, pos.qty);
+        if (!aQ) continue;
+        // На безналичном счёте без маржиналки закрытие шорта тратит кэш, а не высвобождает его под покупку
+        if (!marginSizing && aQ < 0) continue;
+        const entryAt = Number(acc.entryTsBySymbol?.[sym]) || 0;
+        if (entryAt > 0 && nowTs - entryAt < minHoldMs) continue;
+        const sp = specs[sym] || { lotSize: 1, minStep: 0.01, decimals: 2 };
+        const totalLots = Math.floor(Math.abs(aQ) / sp.lotSize);
+        const rCur = rowMap.get(sym);
+        const px = Number(rCur?.price || pos.price) || 0;
+        if (totalLots < 1 || !(px > 0)) continue;
+        const isLongPos = aQ > 0;
+        const curSignedPct = isLongPos ? Number(rCur?.expectedPct || 0) : -Number(rCur?.expectedPct || 0);
+        const thrEntryPct = isLongPos ? reqBuyEdgeOf(sym) : reqShortEdgeOf(sym);
+        const heldIsT1 = TIER1_LIQUID_SYMBOLS.has(sym);
+        elig.push({ sym, pos, rCur, sp, totalLots, px, isLongPos, curSignedPct, thrEntryPct, heldIsT1, posRub: totalLots * sp.lotSize * px, tierRank: heldIsT1 ? 1 : 0 });
+      }
+      elig.sort((a, b) => (a.tierRank - b.tierRank) || (a.curSignedPct - b.curSignedPct));
+
+      for (const el of elig) {
+        if (shortfall < minChunkRub * 0.5) break;
+        const coolRatio = el.heldIsT1 ? (STRATEGY_POLICY.crowdCoolRatioT1 ?? 0.45) : (STRATEGY_POLICY.crowdCoolRatioT2 ?? 0.80);
+        const cooled = el.curSignedPct < el.thrEntryPct * coolRatio;
+        const netAdvPct = bestT1.weight - Math.max(0, el.curSignedPct);
+        const limPx = sniperLimitPrice(el.px, el.isLongPos ? -1 : 1, acc.limitOffsetPct, el.sp);
+        const lotVal = limPx * el.sp.lotSize;
+        if (!(lotVal > 0)) continue;
+
+        let lotsToClose = 0;
+        let fullRotate = false;
+        if (cooled && netAdvPct >= rotBufPct) {
+          if (!el.heldIsT1 || el.curSignedPct < el.thrEntryPct * 0.35 || el.posRub - shortfall < minChunkRub) {
+            lotsToClose = el.totalLots;
+            fullRotate = true;
+          } else {
+            const maxTrimRub = el.posRub - minChunkRub;
+            const trimRub = Math.min(shortfall, maxTrimRub);
+            if (trimRub >= minChunkRub) lotsToClose = Math.min(el.totalLots - 1, Math.max(1, Math.ceil(trimRub / lotVal)));
+          }
+        } else if (!cooled && !el.heldIsT1 && netAdvPct >= trimBufPct && el.posRub >= minChunkRub * 1.5) {
+          const maxTrimRub = el.posRub - minChunkRub;
+          const trimRub = Math.min(shortfall, maxTrimRub);
+          if (trimRub >= minChunkRub) lotsToClose = Math.min(el.totalLots - 1, Math.max(1, Math.ceil(trimRub / lotVal)));
+        }
+        if (lotsToClose >= 1) {
+          const isTrim = !fullRotate && lotsToClose < el.totalLots;
+          const amountRub = round(lotsToClose * el.sp.lotSize * limPx, 2);
+          const freedExpRub = lotsToClose * el.sp.lotSize * el.pos.price;
+          orders.push({
+            symbol: el.sym,
+            action: el.isLongPos ? 'sell' : 'cover',
+            lotSize: el.sp.lotSize,
+            lots: lotsToClose,
+            shares: lotsToClose * el.sp.lotSize,
+            refPrice: el.px,
+            limitPrice: limPx,
+            amountRub,
+            isTrim,
+            urgentExit: true,
+            reason: isTrim
+              ? `Частичное потеснение (${lotsToClose} из ${el.totalLots} лот., прогноз ${el.rCur?.expectedPct > 0 ? '+' : ''}${el.rCur?.expectedPct}%) под сильный сигнал 1-го эшелона ${bestT1.r.symbol} (${bestT1.r.expectedPct > 0 ? '+' : ''}${bestT1.r.expectedPct}%)`
+              : `Ротация капитала из остывшей бумаги (${el.rCur?.expectedPct > 0 ? '+' : ''}${el.rCur?.expectedPct}%) в флагман 1-го эшелона ${bestT1.r.symbol} (${bestT1.r.expectedPct > 0 ? '+' : ''}${bestT1.r.expectedPct}%)`,
+          });
+          if (!isTrim) {
+            closing.add(el.sym);
+            if (el.isLongPos) activeLongs = Math.max(0, activeLongs - 1);
+            else activeShorts = Math.max(0, activeShorts - 1);
+          }
+          usedRub = Math.max(0, usedRub - freedExpRub);
+          availRub = recomputeAvailRub();
+          shortfall = totalDesiredNewRub - availRub;
+        }
+      }
+    }
+  }
+
+  // Итеративное распределение свободного ресурса методом перелива (waterFillAllocations в policy.js):
+  // кандидаты с узким потолком (2-й эшелон / лимит 15% от 10-минутного оборота свечи) забирают ровно свой потолок,
+  // а весь оставшийся лимит без холостого простоя переливается флагманским лидерам 1-го эшелона.
+  const allocSums = autoAdapt
+    ? waterFillAllocations(preparedNew, availRub)
+    : Float64Array.from(preparedNew.map((x) => Math.min(x.targetRub, availRub / Math.max(1, preparedNew.length))));
+  for (let idx = 0; idx < preparedNew.length; idx++) {
+    const { r, side, targetRub, tierMult, stopPct } = preparedNew[idx];
     const isTier1 = TIER1_LIQUID_SYMBOLS.has(r.symbol);
-    // множитель размера по эшелону: 1-й эшелон — плечо счёта, 2–3-й — половинный размер (policy.js)
-    const tierMult = autoAdapt ? tierSizeMult(r.symbol, leverage) : 1;
-    const rawSideCapRub = tierMult * (side === 'short'
-      ? (isTier1 ? maxShortTier1Rub : maxShortTier2Rub)
-      : (isTier1 ? maxLongTier1Rub : maxLongTier2Rub));
-    // Лимит от реального 10-минутного оборота стакана (Liquidity Cap): во 2-м эшелоне не входим объёмом больше 12% от 10-минутного оборота биржи,
-    // чтобы заявка не становилась «стенкой» для стаканных роботов и исполнялась целиком без проскальзывания
-    const barTurnoverRub = !isTier1 ? recentBarTurnoverRub(r.symbol) : 0;
-    const sideCapRub = (!isTier1 && barTurnoverRub > 0)
-      ? Math.max(45000, Math.min(rawSideCapRub, barTurnoverRub * 0.12))
-      : rawSideCapRub;
-    const rawSum = Math.min(sideCapRub, (params.modelAllocMode === 'invvol' && r.weight ? dynSlotRub * r.weight : dynSlotRub) * tierMult * convOf(r));
-    const sum = Math.min(rawSum, propShare, availRub);
+    const sum = Math.min(allocSums[idx], availRub);
     const refPx = r.price || specs[r.symbol]?.lastPrice || 0;
     const effOffsetPct = isTier1 ? Math.min(Number(acc.limitOffsetPct) || 0.05, 0.06) : Math.min(Number(acc.limitOffsetPct) || 0.04, 0.04);
     const ord = calcLotOrder(r.symbol, sum, refPx, side, effOffsetPct, specs);
@@ -2527,8 +2556,8 @@ export async function prepareBrokerOrders(id, { onlyEntries = false, scheduledBa
           bar: fc.bar, expectedPct: r.expectedPct,
           thresholdPct: side === 'buy' ? reqBuyEdgeOf(r.symbol) : reqShortEdgeOf(r.symbol),
           edgeMult: r.edgeMult, sigmaBarPct: r.sigmaPct, lastMovePct: r.lastMovePct, selfPct: r.selfPct,
-          marketDown: Boolean(fc.marketDown), conv: round(convOf(r), 3), budgetRub: budget, targetRub: round(rawSum, 0), leverage, tierMult, collateral,
-          stopPct: protectiveStopPct(side === 'buy' ? 'long' : 'short'), day: r.day || null, onlyEntries: Boolean(onlyEntries),
+          marketDown: Boolean(fc.marketDown), conv: round(convOf(r), 3), budgetRub: budget, targetRub: round(targetRub, 0), leverage, tierMult, collateral,
+          stopPct, day: r.day || null, onlyEntries: Boolean(onlyEntries),
         },
         reason: side === 'buy'
           ? `Покупка (${MODELS[params.modelType]?.label || params.modelType}): ожидание ${r.expectedPct > 0 ? '+' : ''}${r.expectedPct}% за ${params.modelHorizon} ч`
@@ -2786,7 +2815,7 @@ async function sendOrderToBroker(acc, ord) {
           //   при узком спреде (<= 0,10% или <= 2 шагов) ставим ровно в лучшую встречную цену (bestAsk / bestBid),
           //   а при широком спреде встаём на середине спреда (midPx), не переплачивая стаканным роботам!
           const tightExitSpread = spreadPct <= 0.10 || (bestAsk - bestBid) <= 2.1 * step;
-          if (ord.isStopLoss && spreadPct <= 0.80) {
+          if ((ord.isStopLoss || ord.urgentExit) && spreadPct <= (ord.isStopLoss ? 0.80 : 0.35)) {
             const mktExitPx = roundToStep(isBuy ? bestAsk : bestBid, step, sp.decimals);
             if (mktExitPx > 0) finalLimitPx = isBuy ? Math.max(finalLimitPx, mktExitPx) : Math.min(finalLimitPx, mktExitPx);
           } else if (tightExitSpread) {
@@ -3178,10 +3207,12 @@ export async function executeBrokerOrders(id, { _lockHeld = false } = {}) {
           delete acc.entryFailReasonBySymbol[ord.symbol];
         } else if (ord.action === 'sell' || ord.action === 'cover') {
           hadExits = true;
-          delete acc.entryTsBySymbol[ord.symbol];
-          delete acc.peakPriceBySymbol[ord.symbol];
-          if (ord.symbol !== 'LQDT') {
-            acc.exitCooldownBySymbol[ord.symbol] = ord.isStopLoss ? execNowTs : (execNowTs - 30 * 60000);
+          if (!ord.isTrim) {
+            delete acc.entryTsBySymbol[ord.symbol];
+            delete acc.peakPriceBySymbol[ord.symbol];
+            if (ord.symbol !== 'LQDT') {
+              acc.exitCooldownBySymbol[ord.symbol] = ord.isStopLoss ? execNowTs : (execNowTs - 30 * 60000);
+            }
           }
         }
       } catch (e) {
@@ -3516,8 +3547,9 @@ 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;
+          const canEnterOrCrowd = freeCashRub >= 15000 || (acc.marginEnabled && (Number(acc.maxLeverage) || 1) > 1) || hasOpenAlgoPos;
           const marketActiveNow = Boolean(latest && nowTs - latest <= 25 * 60000);
-          if (marketActiveNow && acc.mode === 'auto' && acc.token && !acc.haltedReason && !(acc.skipEdgeMinutes && sessionEdgeWarning(nowTs)) && freeCashRub >= 15000 && nowTs - Math.max(lastFullWallTs, lastAnyWallTs) >= 20000) {
+          if (marketActiveNow && acc.mode === 'auto' && acc.token && !acc.haltedReason && !(acc.skipEdgeMinutes && sessionEdgeWarning(nowTs)) && canEnterOrCrowd && nowTs - Math.max(lastFullWallTs, lastAnyWallTs) >= 20000) {
             await prepareBrokerOrders(acc.id, { onlyEntries: true }).catch(() => {});
           }
         }

package/server/model/edge.js

@@ -8,12 +8,13 @@
 export const ENTRY_EDGE_MULT = 1.60;
 export const TIER2_EDGE_MULT = 1.20;
 
-// Голубые фишки и наиболее ликвидные акции 1-го эшелона Мосбиржи (глубокий стакан, минимальный спред):
-// высоковолатильные бумаги со спредом 2-го эшелона (SMLT, PIKK, POSI, AFKS, VKCO, CBOM, BSPB, SVCB) идут по порогу TIER2_EDGE_MULT.
+// Голубые фишки и наиболее ликвидные акции 1-го эшелона Мосбиржи (глубокий стакан, минимальный спред, нулевая частота срабатывания 7%-го стопа):
+// бумаги с повышенным хвостовым риском и широким спредом (SMLT, PIKK, POSI, AFKS, VKCO, SPBE, UGLD, HEAD, CBOM) идут по правилам 2-го эшелона (TIER2_EDGE_MULT).
 export const TIER1_LIQUID_SYMBOLS = new Set([
   'SBER', 'SBERP', 'LKOH', 'GAZP', 'T', 'YDEX', 'ROSN', 'NVTK', 'GMKN', 'PLZL',
   'VTBR', 'TATN', 'TATNP', 'SNGS', 'SNGSP', 'ALRS', 'CHMF', 'NLMK', 'MAGN', 'MOEX',
-  'OZON', 'HEAD', 'PHOR', 'AFLT', 'MTSS', 'IRAO', 'TRNFP', 'RUAL', 'FLOT', 'X5',
+  'OZON', 'PHOR', 'AFLT', 'MTSS', 'IRAO', 'TRNFP', 'RUAL', 'FLOT', 'X5',
+  'MTLR', 'BSPB', 'RTKM', 'SVCB',
 ]);
 
 export function symbolEdgeMult(symbol, { sigma = 0, avgSigma = 0, avgBarValRub = 0 } = {}) {