neuroalpha 0.6.11 → 0.6.13

package/docs//320/230/320/235/320/241/320/242/320/240/320/243/320/232/320/246/320/230/320/257.md

@@ -69,9 +69,10 @@
 
 В разделе **«Прогноз сейчас»** каждые **45 секунд** по живым котировкам Мосбиржи обновляются две таблицы: **«Сильнее рынка»** (кандидаты в покупку) и **«Слабее рынка»** (кандидаты в шорт).
 
-- **Разделение на 1-й и 2-й эшелоны ликвидности:**
-  - **1-й эшелон (33 наиболее ликвидные акции Мосбиржи):** низкие потери в стакане (`0,065%` на сторону = `0,13%` за полный круг со всеми комиссиями), базовый порог входа `~+0,40%`, размер позиции масштабируется на полное плечо счёта (до `50%` бюджета в лонг и до `38%` в шорт).
-  - **2–3-й эшелон (остальные ~92 акции):** более широкий спред в стакане (`0,125%` на сторону = `0,25%` за полный круг), порог входа повышен в `1,20×` (`~+0,48%`), размер позиции масштабируется от плеча асимметрично (`max(0,50, 0,38 × плечо)` для лонга и `max(0,35, 0,22 × плечо)` для шорта) и ограничен `15%` от реального 10-минутного оборота свечи.
+- **Разделение на 1-й и 2-й эшелоны ликвидности, перелив капитала и потеснение:**
+  - **1-й эшелон (33 наиболее ликвидные акции Мосбиржи):** низкие потери в стакане (`0,065%` на сторону = `0,13%` за полный круг со всеми комиссиями), базовый порог входа `~+0,40%`, живой `Conviction Sizing` разгоняет сильные одиночные сигналы вплоть до `92%` бюджета в лонг и `70%` в шорт на `1×` (в режиме «Хозяин»; до `75% / 56%` на «VIP», `52% / 40%` на «Профи», `58%` на «Инвесторе»), а с ростом плеча счёта лимит одной бумаги растёт сублинейно (`1 + 0,80 × (плечо − 1)`), сохраняя свободный маржинальный резерв под параллельные идеи.
+  - **2–3-й эшелон (остальные ~92 акции):** более широкий спред в стакане (`0,125%` на сторону = `0,25%` за полный круг), порог входа повышен в `1,20×` (`~+0,48%`), прямой предел позиции до `17%` в лонг и до `7%` в шорт на `1×` (с плавным ростом по плечу `0,72 / 0,40`) и жёстким потолком не более `15%` от реального 10-минутного оборота свечи.
+  - **Итеративный перелив (`water-filling`) и динамическое потеснение:** мелкие по ёмкости сделки 2-го эшелона не отнимают квоту у лидеров 1-го эшелона, а при нехватке лимита под новый сильный сигнал 1-го эшелона робот освобождает место ротацией остывшей позиции или частичным подрезанием 2-го эшелона (на `auto` — в реальном времени, на `confirm` — в плановых 30-минутных пакетах).
 - **Авто-балансировка по тренду индекса:** когда индекс Мосбиржи растёт, покупки идут по базовому порогу (`+0,40%` / `+0,48%`), а вход в контртрендовый шорт ужесточается в `1,25×` (`−0,50%` / `−0,60%`). На падающем рынке система автоматически облегчает шорты (`×0,90`) и ужесточает покупки (`×1,25`).
 - **Глубина сопровождения `130 минут` (`holdBars = 13`) и фиксация прибыли:** первые 45 минут после открытия действует мягкий порог удержания (`0,35×`), затем к 130-й минуте он плавно поднимается к `0,95×` с подстройкой под сегодняшнюю волатильность бумаги. При достижении порога Take-Profit включается скользящая защита прибыли (в 1-м эшелоне удерживает `≥70%` пика, во 2-м эшелоне — `≥75%` пика с допустимым откатом не более `0,35%`).
 
@@ -91,5 +92,5 @@
   - Торговля **в рост и в падение (с шортами)** с повышенной концентрацией слота;
   - Количество брокерских счетов и начальная сумма торговли определяются **по индивидуальному согласованию**.
 - **Режим «Хозяин» (`owner` — для владельца / администратора платформы):**
-  - **Без ограничений** по размеру позиции (внутричасовой перехват `H/5` каждые 30 минут, `Conviction Sizing` до 75% капитала), числу счетов и сумме капитала;
+  - **Максимальная отдача капитала** (внутричасовой перехват `H/5` каждые 30 минут, живой `Conviction Sizing` до `92%` капитала в лонг / `70%` в шорт в 1-м эшелоне с сублинейным плечом и динамическим потеснением), без ограничений по числу счетов и сумме капитала;
   - Эксклюзивный доступ к разделу **«Эксперименты»**.

package/docs//320/234/320/225/320/245/320/220/320/235/320/230/320/232/320/220_/320/230_/320/237/320/220/320/240/320/220/320/234/320/225/320/242/320/240/320/253.md

@@ -114,10 +114,12 @@ $$\text{Edge}_i = \hat{y}_i \cdot \sigma_i \cdot \sqrt{H}$$
 * В режиме `Покупки и продажи (longshort)` с включённым самообучением система автоматически **повышает входной фильтр для покупок (`×1.25`)** и **облегчает вход для коротких продаж (`×0.90`)** на падающем рынке (и наоборот — на растущем рынке).
 * Именно эта механика позволяет стратегии стабильно зарабатывать и в растущие месяцы, и на затяжном падении индекса Мосбиржи.
 
-### 5.5. Распределение капитала по эшелонам, плечу и чистой отдаче (`Dynamic Top-K` + `Conviction Sizing` + `netPickSort`)
-В режиме автопилота (`modelTopK = 0`) система держит до 4 лонгов и до 4 шортов, распределяя капитал между отобранными лидерами пропорционально **чистой ожидаемой отдаче после вычета круговых издержек эшелона** (`|Edge| − 0,13%` для 1-го эшелона и `|Edge| − 0,25%` для 2-го):
-* В **1-м эшелоне** размер слота масштабируется на полное плечо счёта (`maxLeverage`), а предел на одну бумагу составляет до **`50%` бюджета в лонг и до `38%` в шорт** (умноженные на плечо).
-* Во **2-м эшелоне** действует асимметричное масштабирование от плеча счёта (`tierSizeMult`): для лонга — `max(0,50, 0,38 × плечо)`, для шорта — `max(0,35, 0,22 × плечо)`, при пределе `22%` в лонг / `18%` в шорт и жёстком потолке ликвидности **не более `15%` от медианного 10-минутного оборота свечи (`barTurnoverRub`)**.
+### 5.5. Адаптивная загрузка без холостого резерва: живой `Conviction Sizing`, сублинейное плечо, `water-filling` и двухступенчатое потеснение
+Поскольку `81,5%` активного времени на рынке открыта всего **одна** позиция, система не замораживает половину лимита в «мёртвом резерве» под гипотетические будущие сделки, а решает три задачи раздельно:
+* **1-й эшелон (живой `Conviction Sizing` + сублинейное плечо):** пограничный сигнал получает умеренный базовый объём, а сильный одиночный импульс пропорционально `conv` (до `1,92×` в режиме «Хозяин») разгоняется до **`92%` бюджета в лонг и `70%` в шорт** на счёте `1×` (`75% / 56%` на «VIP», `52% / 40%` на «Профи», `58%` в лонг на «Инвесторе»). С ростом плеча счёта потолок *одной* бумаги растёт **сублинейно** (`1 + 0,80 × (плечо − 1)`), удерживая риск одиночной сделки в рамках контроля просадки и превращая остаток бесплатного внутридневного плеча под залог `LQDT` в эластичный резерв под 2-ю и 3-ю параллельные идеи.
+* **2-й эшелон (прямой риск-лимит + стакан биржи):** без двойного перемножения штрафов действует прямой потолок — до **`17%` бюджета в лонг** (`1 + 0,72 × (плечо − 1)`) и до **`7%` в шорт** (`1 + 0,40 × (плечо − 1)`), жёстко отсечённый по реальной глубине биржевого стакана (**не более `15%` от медианного 10-минутного оборота свечи `barTurnoverRub`**).
+* **Итеративный перелив (`waterFillAllocations`) и чистая отдача (`netPickSort`):** веса сделок рассчитываются за вычетом круговых издержек эшелона (`|Edge| − 0,13%` в 1-м эшелоне и `|Edge| − 0,25%` во 2-м). При одновременном входе сделки с узким лимитом (2-й эшелон / тонкий стакан) забирают ровно свой потолок, а весь оставшийся ресурс переливается крупным лидерам 1-го эшелона без пустых остатков.
+* **Двухступенчатое динамическое потеснение (`crowdOut`):** если свободного лимита реально не хватает под новый сильный сигнал 1-го эшелона, робот (с защитной выдержкой `≥ 20 минут` от «пилы») либо ротирует остывшую позицию целиком, либо частично подрезает позицию 2-го эшелона с полным сохранением `entryTs` и накопленного `peakPrice` для скользящего `Profit Lock`.
 
 ---
 
@@ -155,7 +157,7 @@ $$\text{Edge}_i = \hat{y}_i \cdot \sigma_i \cdot \sqrt{H}$$
 4. **Только лимитные заявки с точным шагом цены (`limitOffsetPct`):** Заявки выставляются от живой цены с защитным лимитным отступом (по умолчанию `0.1%`), округлённым строго по шагу цены (`MINSTEP` / `minPriceIncrement`) конкретной бумаги.
 5. **Защита краёв сессии (`skipEdgeMinutes`):** В окна `06:50–07:25`, `09:50–10:10` и `18:35–18:55` МСК новые входы не открываются и фиксация прибыли не срабатывает на шуме стакана; аварийные стопы работают всегда.
 6. **Аварийный стоп позиции — 7% от средней цены входа** (у брокера стоп-заявкой и во внутреннем контуре). Модель торгует возврат к среднему, поэтому стоп стоит широко: проверка на истории показала, что прежние 4,5–5% закрывали позиции на пике отклонения и снижали итог на обеих половинах периода.
-6.1. **Плечо (`maxLeverage`, настройка счёта):** множитель размера позиций и предел суммарной позиции (`×` капитал). В ликвидных бумагах 1-го эшелона размер масштабируется на полное плечо счёта, а во 2–3-м эшелоне действует асимметричное масштабирование (`max(0,50, 0,38 × плечо)` для лонга и `max(0,35, 0,22 × плечо)` для шорта) под защитой потолка `15%` от 10-минутного оборота свечи (`barTurnoverRub`). Работает только при включённой маржинальной торговле; тариф «Инвестор» — без плеча, «Профи» — до 3, «VIP» и «Хозяин» — до 7. Предел заявки дополнительно проверяет брокер (`GetMaxLots`, маржинальный лимит).
+6.1. **Плечо (`maxLeverage`, настройка счёта):** предел суммарной позиции (`×` капитал) и сублинейный множитель одиночной сделки (`tierSizeMult`). В 1-м эшелоне предел одной бумаги растёт по закону `1 + 0,80 × (плечо − 1)`, оставляя часть бесплатного внутридневного плеча свободным резервом под параллельные идеи; во 2–3-м эшелоне прямой лимит (`17%` лонг / `7%` шорт на `1×`, наклон по плечу `0,72` / `0,40`) защищён потолком `15%` от 10-минутного оборота свечи (`barTurnoverRub`). Работает только при включённой маржинальной торговле; тариф «Инвестор» — без плеча, «Профи» — до 3, «VIP» и «Хозяин» — до 7. Предел заявки дополнительно проверяет брокер (`GetMaxLots`, маржинальный лимит).
 6.2. **Стоп по общей просадке (`maxDrawdownPct`, настройка счёта, 0 — выкл.):** если оценка счёта опустилась от своего максимума на заданный процент, новые входы запрещаются до ручного снятия («Снять стоп по просадке»); открытые позиции сопровождаются. После вывода денег стоп снимается вручную.
 6.3. **Капитал в LQDT как залог** (при включённых «Свободные рубли в LQDT» и маржинальной торговле): паи LQDT не продаются под входы — внутридневные позиции открываются под обеспечение и закрываются до ночи (платы за перенос нет), а свободные рубли размещаются в LQDT, когда у стратегии нет открытых позиций.
 6.4. **Вход против планки:** если брокер отклонил вход из-за ценового коридора Мосбиржи (код 30099 — бумага у планки), вход в эту бумагу в ту же сторону блокируется до конца торгового дня.
@@ -171,13 +173,14 @@ $$\text{Edge}_i = \hat{y}_i \cdot \sigma_i \cdot \sqrt{H}$$
 
 Изменение правил проверяется в лаборатории `scripts/strategy-lab.mjs` (варианты — в `scripts/strategy-lab-variants.mjs`) и принимается, только если оно лучше текущих правил **и на первой, и на второй половине периода**. Каждая отправленная заявка записывается в журнал решений `trade_decisions` (причина, ожидание и порог, контекст дня, плечо, версия программы; `GET /api/brokers/:id/decisions`).
 
-Проверка правил 13.11.2026 (пошаговые прогнозы 06.2024–11.2026, 59 051 свеча, 900 сделок, капитал 800 тыс. ₽, LQDT за период — 18,5% годовых):
+Проверка правил 13.11.2026 (пошаговые прогнозы 06.2024–11.2026, 59 051 свеча, 896 сделок, капитал 800 тыс. ₽, LQDT за период — 18,5% годовых):
 
 | Правила | CAGR (весь период) | 1-я / 2-я половина | PF | Макс. просадка | Худшая сделка, % капитала |
 |---|---|---|---|---|---|
 | До 06.11.2026 (без LQDT, 2-й эшелон полным размером) | 12,9% | 19,3% / 6,8% | 1,40 | 4,4% | −2,0% |
-| Текущие (`holdBars=13`, ревизия эшелонов), плечо 1× | **39,5%** | **49,2% / 30,7%** | **1,85** | **2,0%** | −2,2% |
-| Текущие (`holdBars=13`, ревизия эшелонов), плечо 2× | **59,8%** | **73,8% / 47,4%** | **2,03** | **3,6%** | −4,3% |
-| Текущие (`holdBars=13`, ревизия эшелонов), плечо 3× | **83,7%** | **104,6% / 65,6%** | **2,07** | **5,9%** | −6,5% |
+| Предыдущие (`v0.6.11`, полка `50%/38%` T1), плечо 2× | 59,8% | 73,8% / 47,4% | 2,03 | 3,6% | −1,9% |
+| Текущие (живой `Conviction` + сублинейное плечо + перелив + потеснение), плечо 1× | **48,7%** | **59,9% / 38,7%** | **1,90** | **3,4%** | −1,3% |
+| Текущие (живой `Conviction` + сублинейное плечо + перелив + потеснение), плечо 2× | **77,6%** | **95,0% / 62,4%** | **2,05** | **5,6%** | −2,4% |
+| Текущие (живой `Conviction` + сублинейное плечо + перелив + потеснение), плечо 3× | **110,3%** | **133,7% / 90,1%** | **2,18** | **7,1%** | −3,4% |
 
 Отклонены (хуже хотя бы на одной половине или с катастрофическим хвостом): защита вечным фьючерсом IMOEXF (издержки больше выигрыша), пассивные лимитные входы, снижение порога входа, 6–8 позиций на сторону, выход по времени, отключение фиксации прибыли, стоп по волатильности и «стоп отмены идеи», размер позиции по риску. Результат на истории не гарантирует будущий: плечо пропорционально увеличивает и доходность, и просадки.

package/package.json

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

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, symbolCapRub, 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';
@@ -188,7 +191,6 @@ function logBrokerEvent(acc, kind, text) {
     const uid = currentUserId();
     db.prepare('INSERT INTO broker_events (ts, user_id, account_id, kind, text) VALUES (?, ?, ?, ?, ?)')
       .run(Date.now(), uid, String(acc?.id || ''), String(kind), String(text || '').slice(0, 500));
-    if (/error|stop|halt/.test(kind)) console.warn(`[брокер ${acc?.name || acc?.id}] ${kind}: ${text}`);
     // храним последние 5000 событий на счёт
     if (Math.random() < 0.02) {
       db.prepare(`DELETE FROM broker_events WHERE user_id = ? AND account_id = ? AND id NOT IN
@@ -272,7 +274,6 @@ function migrateKvAccounts(uid) {
       db.exec('COMMIT');
     } catch (e) { db.exec('ROLLBACK'); throw e; }
     // прежняя запись не удаляется: при откате на версию до 0.4.1 счета останутся на месте (в состоянии на момент переноса)
-    console.log(`✓ Брокерские счета пользователя ${uid} перенесены в отдельные записи (${old.length})`);
   }
   userKvSet('brokerAccountsMigrated', true, uid);
 }
@@ -2093,32 +2094,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 +2309,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 +2343,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.50, 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 +2416,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 posSide = side === 'short' ? 'short' : 'long';
-        const barTurnRub = !isT1 ? recentBarTurnoverRub(r.symbol) : 0;
-        const liqCap = symbolCapRub(r.symbol, posSide, budget, barTurnRub);
-        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,43 +2433,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;
       }
     }
   }
-  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);
-  };
-  if (autoAdapt && combinedNew.length > 1) {
-    combinedNew.sort((a, b) => netPickWeight(b.r) - netPickWeight(a.r));
+
+  // Двухступенчатое динамическое потеснение под новый сильный сигнал 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;
+        }
+      }
+    }
   }
-  let remWeightSum = combinedNew.reduce((s, x) => s + netPickWeight(x.r), 0);
-
-  // Жёсткий предохранитель концентрации на одну бумагу в реальном стакане брокера (symbolCapRub в policy.js):
-  // • для ликвидных бумаг 1-го эшелона: до 50% счёта на один лонг и до 38% счёта на один шорт;
-  // • для бумаг 2–3 эшелона: до 22% счёта на один лонг и до 18% на один шорт (но не более 15% от 10-минутного оборота свечи),
-  //   чтобы крупная заявка не выкупала тонкий стакан против самой себя и всегда оставляла капитал на 3–4 бумаги!
-  for (const { r, side } of combinedNew) {
-    const wCur = netPickWeight(r);
-    const propShare = autoAdapt && remWeightSum > 0 ? availRub * (wCur / remWeightSum) : availRub / Math.max(1, remNew);
-    remWeightSum = Math.max(0, remWeightSum - wCur);
-    remNew--;
+
+  // Итеративное распределение свободного ресурса методом перелива (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);
-    const posSide = side === 'short' ? 'short' : 'long';
-    // множитель размера по эшелону и направлению: 1-й эшелон — плечо счёта, 2–3-й — асимметричное масштабирование от плеча (policy.js)
-    const tierMult = autoAdapt ? tierSizeMult(r.symbol, leverage, posSide) : 1;
-    // Лимит от реального 10-минутного оборота стакана (Liquidity Cap): во 2-м эшелоне не входим объёмом больше 15% от 10-минутного оборота биржи,
-    // чтобы заявка не становилась «стенкой» для стаканных роботов и исполнялась целиком без проскальзывания
-    const barTurnoverRub = !isTier1 ? recentBarTurnoverRub(r.symbol) : 0;
-    const sideCapRub = symbolCapRub(r.symbol, posSide, budget * tierMult, barTurnoverRub);
-    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);
@@ -2524,8 +2554,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} ч`
@@ -2783,7 +2813,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) {
@@ -3175,10 +3205,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) {
@@ -3513,8 +3545,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(() => {});
           }
         }