neuroalpha 0.6.10 → 0.6.12

package/server/model/policy.js

@@ -19,11 +19,44 @@ export const STRATEGY_POLICY = Object.freeze({
   profitLock: true,
   // размер позиции: 'slot' — доля бюджета × сила сигнала
   sizing: Object.freeze({ mode: 'slot' }),
-  // Множитель размера позиции по эшелонам. Для 1-го эшелона множитель равен плечу счёта (настройка maxLeverage),
-  // 2–3-й эшелон торгуется половинным размером. Проверка 06.11.2026: сделки 1-го эшелона — PF 1,9/3,6 по половинам периода
-  // (издержки 0,065% на сторону), 2–3-го эшелона — чистыми 0,1% на сделку (издержки 0,125%). Плечо 3 на 1-й эшелон и ½ на 2-й:
-  // CAGR 56%/49% по половинам против 44%/24% (с доходом LQDT), PF 1,87; рост итога с плечом почти линейный на обеих половинах.
-  sizeMultT2: 0.5,
+  // Адаптивное распределение размера позиции, сублинейное плечо и перелив капитала (water-filling + потеснение):
+  //   • 1-й эшелон (33 ликвидные акции, 0 стопов на 59 051 свече): живой Conviction Sizing (базовый слот 0,56 × conv до 1,92×)
+  //     разгоняет одиночные сильные импульсы до потолка 92% бюджета в лонг и 70% в шорт на 1× (убирая холостой простой кэша,
+  //     т.к. 81,5% активного времени открыта 1 позиция). С ростом плеча счёта потолок одной бумаги растёт сублинейно
+  //     (1 + 0,80 × (lev − 1): до 166% на 2× и 239% на 3×), оставляя остаток бесплатного плеча под залог LQDT свободным резервом;
+  //   • 2-й эшелон: единый прямой лимит без двойного перемножения — до 17% бюджета в лонг (масштаб плеча 0,72) и до 7% в шорт (0,40),
+  //     под жёстким отсечением по реальной ёмкости стакана (15% от медианного 10-минутного оборота свечи barTurnoverRub);
+  //   • waterFill: при пакетном входе мелкие по лимиту сделки 2-го эшелона не «замораживают» квоту крупных лидеров 1-го эшелона;
+  //   • crowdOut: двухступенчатое потеснение (ротация остывшей позиции или частичное подрезание без потери peakPrice/entryTs)
+  //     при нехватке лимита под сильный сигнал 1-го эшелона (повышение качества T2 → T1 либо перекладка из остывшей T1).
+  // Проверка 13.11.2026 (06.2024–11.2026, 59 051 свеча): улучшает итог и PF на обеих половинах истории при любом плече и тарифе
+  //   • плечо 1×: CAGR 59,9%/38,7% по половинам (весь 48,7%, PF 1,90, DD 3,4%) против 49,2%/30,7% (весь 39,5%, PF 1,85);
+  //   • плечо 2×: CAGR 95,0%/62,4% по половинам (весь 77,6%, 6 мес. 165,1%, PF 2,05, DD 5,6%) против 73,8%/47,4% (весь 59,8%, PF 2,03);
+  //   • плечо 3×: CAGR 133,7%/90,1% по половинам (весь 110,3%, 6 мес. 292,3%, PF 2,18, DD 7,1%) против 104,6%/65,6% (весь 83,7%, PF 2,07).
+  slotOwner: 0.56,
+  convMaxOwner: 1.92,
+  convKOwner: 0.38,
+  capT1Long: 0.92,
+  capT1Short: 0.70,
+  capT2Long: 0.17,
+  capT2Short: 0.070,
+  slotT2LongMult: 0.25,
+  slotT2ShortMult: 0.10,
+  levSlopeT1: 0.80,
+  levSlopeT2Long: 0.72,
+  levSlopeT2Short: 0.40,
+  turnoverCapMult: 0.15,
+  tpRetainT2: 0.75,
+  tpTrailT2: 0.35,
+  netPickSort: true,
+  waterFill: true,
+  crowdOut: true,
+  crowdMinMin: 20,
+  crowdMinPct: 0.06,
+  crowdRotBufPct: 0.08,
+  crowdTrimBufPct: 0.12,
+  crowdCoolRatioT1: 0.45,
+  crowdCoolRatioT2: 0.80,
   // капитал хранится в фонде денежного рынка LQDT как залог: внутридневные позиции открываются под обеспечение
   // (без платы за перенос — позиции закрываются до ночи), LQDT не продаётся под входы
   cashYield: true,
@@ -63,12 +96,15 @@ export function sessionEdgeWarning(ts = Date.now()) {
 // ---------- фиксация прибыли ----------
 // Уровни в процентах выигрыша от средней цены. peakGainPct — лучший выигрыш с момента входа.
 // Возвращает { floorPct, minExitPct, kind } — выход, когда текущий выигрыш опустился до floorPct, но не ниже minExitPct; или null.
-export function profitLockLevels(sym, peakGainPct, heldMin, roundTripFeePct = 0.10) {
+export function profitLockLevels(sym, peakGainPct, heldMin, roundTripFeePct = 0.10, policy = STRATEGY_POLICY) {
+  const isT1 = TIER1_LIQUID_SYMBOLS.has(sym);
   const tierMult = symbolEdgeMult(sym);
   const minNetFloorPct = Math.max(roundTripFeePct + 0.30, Math.round(0.38 * tierMult * 100) / 100);
   const tpTriggerPct = (heldMin < 15 ? 1.55 : 1.20) * tierMult;
   if (peakGainPct >= tpTriggerPct) {
-    return { floorPct: Math.max(peakGainPct * 0.70, peakGainPct - 0.45, minNetFloorPct), minExitPct: minNetFloorPct, kind: 'tp' };
+    const retain = !isT1 && policy?.tpRetainT2 ? policy.tpRetainT2 : 0.70;
+    const trail = !isT1 && policy?.tpTrailT2 ? policy.tpTrailT2 : 0.45;
+    return { floorPct: Math.max(peakGainPct * retain, peakGainPct - trail, minNetFloorPct), minExitPct: minNetFloorPct, kind: 'tp' };
   }
   if (heldMin >= 15 && peakGainPct >= 0.85 * tierMult) {
     return { floorPct: Math.max(minNetFloorPct, peakGainPct * 0.45), minExitPct: roundTripFeePct + 0.22, kind: 'be' };
@@ -121,31 +157,166 @@ export function exitHoldRatio(heldMin, horizonMin, { sigmaBarPct = 0, realizedBa
   return startRatio + (endRatio - startRatio) * ramp;
 }
 
-// ---------- плечо и множители размера по эшелонам ----------
+// ---------- профиль слотов по тарифу, плечо и предельный размер позиции ----------
 export const MAX_LEVERAGE = 7;
-export function tierSizeMult(symbol, leverage = 1, policy = STRATEGY_POLICY) {
+
+export function planSizingProfile(plan = 'owner', dir = 'longshort', policy = STRATEGY_POLICY) {
+  const id = typeof plan === 'object' && plan ? (plan.isOwner ? 'owner' : (plan.id || 'investor')) : String(plan || 'owner');
+  if (id === 'owner') {
+    return {
+      id: 'owner',
+      slotW: policy?.slotPct ?? policy?.slotOwner ?? 0.56,
+      convMax: policy?.convMaxOwner ?? 1.92,
+      convK: policy?.convKOwner ?? 0.38,
+      capT1Long: policy?.capT1Long ?? 0.92,
+      capT1Short: policy?.capT1Short ?? 0.70,
+      capT2Long: policy?.capT2Long ?? 0.17,
+      capT2Short: policy?.capT2Short ?? 0.070,
+    };
+  }
+  if (id === 'vip') {
+    return {
+      id: 'vip',
+      slotW: policy?.slotPct ?? 0.46,
+      convMax: 1.50,
+      convK: 0.28,
+      capT1Long: 0.75,
+      capT1Short: 0.56,
+      capT2Long: 0.14,
+      capT2Short: 0.065,
+    };
+  }
+  if (id === 'pro') {
+    return {
+      id: 'pro',
+      slotW: policy?.slotPct ?? (dir === 'long' ? 0.36 : 0.34),
+      convMax: 1.0,
+      convK: 0,
+      capT1Long: 0.52,
+      capT1Short: 0.40,
+      capT2Long: 0.12,
+      capT2Short: 0.060,
+    };
+  }
+  return {
+    id: 'investor',
+    slotW: policy?.slotPct ?? 0.42,
+    convMax: 1.0,
+    convK: 0,
+    capT1Long: 0.58,
+    capT1Short: 0,
+    capT2Long: 0.14,
+    capT2Short: 0,
+  };
+}
+
+export function convictionMult(edgeRatio = 1, profile = null) {
+  const convMax = profile?.convMax ?? 1;
+  const convK = profile?.convK ?? 0;
+  if (!(convMax > 1) || !(edgeRatio > 0)) return 1;
+  return Math.min(convMax, Math.max(0.85, 0.80 + convK * edgeRatio));
+}
+
+// Сублинейный множитель масштабирования одиночной позиции от плеча счёта (на плече 1× равен 1,00):
+// разгружает риск одиночной бумаги на высоких плечах и оставляет свободный маржинальный резерв под параллельные идеи.
+export function tierSizeMult(symbol, leverage = 1, sideOrPolicy = 'long', policyArg = STRATEGY_POLICY) {
+  const isObj = sideOrPolicy && typeof sideOrPolicy === 'object';
+  const side = isObj ? 'long' : (sideOrPolicy === 'short' ? 'short' : 'long');
+  const policy = isObj ? sideOrPolicy : (policyArg || STRATEGY_POLICY);
   const lev = Math.max(1, Math.min(MAX_LEVERAGE, Number(leverage) || 1));
-  return TIER1_LIQUID_SYMBOLS.has(symbol) ? lev : (policy.sizeMultT2 ?? 1);
+  const isT1 = TIER1_LIQUID_SYMBOLS.has(symbol);
+  // Обратная совместимость со старыми вариантами лаборатории (sizeMultT2 / sizeMultT2LongBase)
+  if (policy?.sizeMultT2 !== undefined) return isT1 ? (policy.sizeMultT1 ?? lev) : policy.sizeMultT2;
+  if (policy?.sizeMultT2LongBase !== undefined) {
+    if (isT1) return policy.sizeMultT1 ?? lev;
+    const rawOld = side === 'short'
+      ? Math.max(policy.sizeMultT2ShortBase ?? 0.35, (policy.sizeMultT2ShortLev ?? 0.22) * lev)
+      : Math.max(policy.sizeMultT2LongBase ?? 0.50, (policy.sizeMultT2LongLev ?? 0.38) * lev);
+    return Math.round(rawOld * 1000) / 1000;
+  }
+  if (isT1 && policy?.sizeMultT1 !== undefined) return policy.sizeMultT1;
+  const slope = isT1
+    ? (policy?.levSlopeT1 ?? 0.80)
+    : (side === 'short' ? (policy?.levSlopeT2Short ?? 0.40) : (policy?.levSlopeT2Long ?? 0.72));
+  return Math.round((1 + slope * (lev - 1)) * 1000) / 1000;
 }
 
 // ---------- предельный размер позиции на одну бумагу ----------
-export function symbolCapRub(symbol, side, budget, barTurnoverRub = 0) {
+export function symbolCapRub(symbol, side, budget, barTurnoverRub = 0, policy = STRATEGY_POLICY, profile = null) {
   const isT1 = TIER1_LIQUID_SYMBOLS.has(symbol);
-  const rawCap = budget * (side === 'short' ? (isT1 ? 0.35 : 0.18) : (isT1 ? 0.45 : 0.22));
-  return (!isT1 && barTurnoverRub > 0) ? Math.max(45000, Math.min(rawCap, barTurnoverRub * 0.12)) : rawCap;
+  const isShort = side === 'short';
+  const legacyMode = policy?.sizeMultT2 !== undefined || policy?.sizeMultT2LongBase !== undefined;
+  let capPct;
+  if (legacyMode) {
+    capPct = isShort
+      ? (isT1 ? (policy?.capT1Short ?? 0.38) : (policy?.capT2Short ?? 0.18))
+      : (isT1 ? (policy?.capT1Long ?? 0.50) : (policy?.capT2Long ?? 0.22));
+  } else if (profile) {
+    capPct = isShort
+      ? (isT1 ? profile.capT1Short : profile.capT2Short)
+      : (isT1 ? profile.capT1Long : profile.capT2Long);
+  } else {
+    capPct = isShort
+      ? (isT1 ? (policy?.capT1Short ?? 0.70) : (policy?.capT2Short ?? 0.070))
+      : (isT1 ? (policy?.capT1Long ?? 0.92) : (policy?.capT2Long ?? 0.17));
+  }
+  const rawCap = budget * capPct;
+  const turnMult = policy?.turnoverCapMult ?? 0.15;
+  return (!isT1 && barTurnoverRub > 0) ? Math.max(45000, Math.min(rawCap, barTurnoverRub * turnMult)) : rawCap;
 }
 
-// Размер новой позиции в рублях до учёта свободного кэша и пропорциональной доли:
-//   'slot' — рабочий слот × сила сигнала (conv), не больше предела бумаги;
+// Размер новой позиции в рублях до учёта свободного лимита и итеративного перелива (water-filling):
+//   'slot' — рабочий слот × множитель эшелона × сила сигнала (conv), не больше предела бумаги;
 //   'risk' — при срабатывании стопа счёт теряет не больше riskPct% бюджета.
-export function targetPositionRub({ symbol, side, budget, slotRub, conv = 1, stopPct, barTurnoverRub = 0 }, policy = STRATEGY_POLICY) {
-  const cap = symbolCapRub(symbol, side, budget, barTurnoverRub);
-  const sz = policy.sizing || {};
+export function targetPositionRub({ symbol, side, budget, slotRub, conv = 1, stopPct, barTurnoverRub = 0, profile = null }, policy = STRATEGY_POLICY) {
+  const cap = symbolCapRub(symbol, side, budget, barTurnoverRub, policy, profile);
+  const sz = policy?.sizing || {};
   if (sz.mode === 'risk' && stopPct > 0) {
     const byRisk = (budget * (sz.riskPct / 100)) / (stopPct / 100);
     return Math.min(cap, byRisk * (sz.useConv ? conv : 1), sz.maxSlotPct ? budget * sz.maxSlotPct : Infinity);
   }
-  return Math.min(cap, slotRub * conv);
+  const isT1 = TIER1_LIQUID_SYMBOLS.has(symbol);
+  const legacyMode = policy?.sizeMultT2 !== undefined || policy?.sizeMultT2LongBase !== undefined;
+  const slotTierMult = (isT1 || legacyMode)
+    ? 1.0
+    : (side === 'short' ? (policy?.slotT2ShortMult ?? 0.10) : (policy?.slotT2LongMult ?? 0.25));
+  return Math.min(cap, slotRub * slotTierMult * conv);
+}
+
+// Итеративное распределение доступного лимита методом перелива (water-filling):
+// бумаги с низким индивидуальным потолком (2-й эшелон / лимит оборота стакана) забирают ровно свой потолок,
+// а весь невыбранный остаток капитала перераспределяется между флагманскими лидерами пропорционально чистой выгоде (weight).
+export function waterFillAllocations(items, availRub) {
+  const n = Array.isArray(items) ? items.length : 0;
+  const out = new Float64Array(n);
+  if (!(availRub > 0) || !n) return out;
+  const totalDesired = items.reduce((s, x) => s + Math.max(0, Number(x.targetRub) || 0), 0);
+  if (totalDesired <= availRub) {
+    for (let k = 0; k < n; k++) out[k] = Math.max(0, Number(items[k].targetRub) || 0);
+    return out;
+  }
+  let remAvail = availRub;
+  const open = new Set(items.map((_, idx) => idx));
+  while (open.size > 0 && remAvail > 0) {
+    let wSum = 0;
+    for (const idx of open) wSum += Math.max(1e-6, Number(items[idx].weight) || 0);
+    let clampedAny = false;
+    for (const idx of [...open]) {
+      const share = remAvail * (Math.max(1e-6, Number(items[idx].weight) || 0) / wSum);
+      const cap = Math.max(0, Number(items[idx].targetRub) || 0);
+      if (cap <= share + 1e-6) {
+        out[idx] = cap;
+        remAvail = Math.max(0, remAvail - cap);
+        open.delete(idx);
+        clampedAny = true;
+      }
+    }
+    if (!clampedAny) {
+      for (const idx of open) out[idx] = remAvail * (Math.max(1e-6, Number(items[idx].weight) || 0) / wSum);
+      break;
+    }
+  }
+  return out;
 }
 
 // ---------- контекст торгового дня бумаги по свечам до момента решения ----------

package/server/model/research.js

@@ -40,7 +40,9 @@ export { isMarketDown };
 // 16: главная оценка — симулятор с правилами живого контура (simulator.js), аварийный стоп 7%
 // 17: капитал в LQDT как залог, половинный размер 2-го эшелона, строки с плечом 3 и 5
 // 18: глубина сопровождения позиции и вечернего окна входов holdBars=13 (130 мин) во всех контурах симуляции
-const DATA_VERSION = 18;
+// 19: ревизия правил 1-го и 2-го эшелонов (MTLR/BSPB/RTKM/SVCB в T1, асимметричный масштаб T2 от плеча, лимит 50%/38% T1 и плотный трал T2)
+// 20: разблокировка Conviction Sizing в T1 (до 92%/70% с сублинейным плечом 0,80), прямой риск-лимит T2, перелив water-filling и двухступенчатое потеснение
+const DATA_VERSION = 20;
 
 const AUTO_LOCKED = { modelHorizon: 2.5, modelMinEdge: 2.5, modelExitRatio: 0.95 };
 function reuseParamsKey(params) {
@@ -821,7 +823,7 @@ async function run(runId, p, state) {
     const lqdtRows = await ensureLqdtHistory().catch(() => []);
     const lqdt = lqdtRows.length ? alignSeries(timeline, lqdtRows) : null;
     const liveRows = [];
-    for (const lev of [1, 3, 5]) {
+    for (const lev of [1, 2, 3, 5]) {
       const lp = simulateStrategy({ ds, wf: wfLive, p, capital: p.capital, shortable: shortableSet(), divCal, lqdt, leverage: lev });
       const yrs = Math.max(1 / 365, ((lp.curve.at(-1)?.ts || 0) - (lp.curve[0]?.ts || 0)) / (365.25 * 86400000));
       const lastLpTs = lp.curve.at(-1)?.ts || 0;
@@ -836,7 +838,7 @@ async function run(runId, p, state) {
       liveRows.push({
         key: lev === 1 ? 'liveRules' : `liveRulesL${lev}`,
         label: lev === 1 ? 'Правила живого контура, без плеча (главная оценка)' : `Правила живого контура, плечо ${lev}`,
-        note: `исполнение и сопровождение как у реального счёта: входы на любой свече, аварийный стоп и фиксация прибыли внутри свечи, окна сессий, планки, перегрев, паузы, размер позиции и пределы на бумагу, издержки по эшелонам${lqdt ? ', капитал в LQDT как залог' : ''}${lev > 1 ? `; позиции 1-го эшелона ×${lev}` : ''}`,
+        note: `исполнение и сопровождение как у реального счёта: входы на любой свече, аварийный стоп и фиксация прибыли внутри свечи, окна сессий, планки, перегрев, паузы, итеративный перелив (water-filling), двухступенчатое потеснение и издержки по эшелонам${lqdt ? ', капитал в LQDT как залог' : ''}${lev > 1 ? `; сублинейный масштаб одиночной позиции при лимите портфеля ×${lev}` : ''}`,
         full: { returnPct: full.returnPct, cagrPct, profitFactor: full.profitFactor, maxDrawdownPct: full.maxDrawdownPct, trades: full.trades, winRate: full.winRate, avgTradePct: full.avgTradePct, longPnl: round(lp.trades.filter((t) => t.side === 'long').reduce((a, t) => a + t.pnl, 0), 0), shortPnl: round(lp.trades.filter((t) => t.side === 'short').reduce((a, t) => a + t.pnl, 0), 0), afterTaxCagrPct: cagrPct === null ? null : round(cagrPct > 0 ? cagrPct * 0.87 : cagrPct, 1) },
         costs: null,
         last12: segOf(lastLpTs - 365 * 86400000),

package/server/model/simulator.js

@@ -17,7 +17,11 @@ import {
   isStockQuarantined, canEnterIntraday, shouldExitBeforeNight, isMarketDown,
 } from './edge.js';
 import { nextDividendAt, dividendRules } from './dividends.js';
-import { STRATEGY_POLICY, MAX_LEVERAGE, sessionEdgeWarning, profitLockLevels, protectiveStopPct, exitHoldRatio, targetPositionRub, counterTrendBlocked, thesisStopPx, dayContext } from './policy.js';
+import {
+  STRATEGY_POLICY, MAX_LEVERAGE, sessionEdgeWarning, profitLockLevels, protectiveStopPct, exitHoldRatio,
+  planSizingProfile, convictionMult, tierSizeMult, targetPositionRub, waterFillAllocations,
+  counterTrendBlocked, thesisStopPx, dayContext,
+} from './policy.js';
 
 // Выравнивание внешнего ряда (свечи IMOEXF, дневные цены LQDT) по шкале датасета с переносом последней цены
 export function alignSeries(timeline, rows) {
@@ -40,7 +44,7 @@ export function simulateStrategy({ ds, wf, p, policy = STRATEGY_POLICY, capital
   const bpd = Math.max(1, Math.round(ds.barsPerDay || 94));
   const stepBars = plan === 'owner' || plan === 'vip' ? Math.max(3, Math.floor(holdBars / 5)) : holdBars;
   const K = policy.K ?? 4;
-  const dir = p.modelDirection === 'long' ? 'long' : 'longshort';
+  const dir = plan === 'investor' || p.modelDirection === 'long' ? 'long' : 'longshort';
   const realCost = (p.commissionPct + p.slippagePct) / 100;
   const need = 2.5 * 2 * realCost * (policy.entryEdgeMult ?? ENTRY_EDGE_MULT);
   const roundTripFeePct = 2 * (p.commissionPct + p.slippagePct);
@@ -50,9 +54,15 @@ export function simulateStrategy({ ds, wf, p, policy = STRATEGY_POLICY, capital
   const cooldownBars = Math.round((policy.cooldownMin ?? 30) / BAR_INTERVAL);
   const stopCooldownBars = Math.round((policy.stopCooldownMin ?? 60) / BAR_INTERVAL);
   const horizonMin = Math.max(90, holdBars * BAR_INTERVAL);
-  const slotW = policy.slotPct ?? (plan === 'owner' ? 0.45 : plan === 'vip' ? 0.40 : plan === 'pro' ? Math.min(0.28, 1.15 / 8) : Math.min(0.24, 1.05 / 5));
-  const convMax = plan === 'owner' ? 1.65 : plan === 'vip' ? 1.30 : 1;
-  const convK = plan === 'owner' ? 0.30 : 0.25;
+  const legacySizing = policy.sizeMultT2 !== undefined || policy.sizeMultT2LongBase !== undefined;
+  const profile = legacySizing
+    ? {
+        slotW: policy.slotPct ?? (plan === 'owner' ? 0.50 : plan === 'vip' ? 0.40 : plan === 'pro' ? Math.min(0.28, 1.15 / 8) : Math.min(0.24, 1.05 / 5)),
+        convMax: plan === 'owner' ? 1.65 : plan === 'vip' ? 1.30 : 1,
+        convK: plan === 'owner' ? 0.30 : 0.25,
+      }
+    : planSizingProfile(plan, dir, policy);
+  const slotW = profile.slotW;
   const lev = Math.max(1, Math.min(MAX_LEVERAGE, Number(leverage) || 1));
   const maxGross = policy.maxGross ?? 0.99 * lev;
   const capScale = policy.capScale ?? 1;
@@ -69,7 +79,7 @@ export function simulateStrategy({ ds, wf, p, policy = STRATEGY_POLICY, capital
   const curve = [];
   const cooldownUntil = new Int32Array(N).fill(-1);
   const stockPnl = new Float64Array(N), stockCnt = new Float64Array(N);
-  const stats = { stops: 0, thesis: 0, locks: 0, signalExits: 0, timeExits: 0, night: 0, rotations: 0, regime: 0, div: 0, blockedCT: 0, entries: 0, missedPassive: 0, hedgePnl: 0, hedgeCost: 0, cashYield: 0, exposureSum: 0, exposureN: 0 };
+  const stats = { stops: 0, thesis: 0, locks: 0, signalExits: 0, timeExits: 0, night: 0, rotations: 0, trims: 0, regime: 0, div: 0, blockedCT: 0, entries: 0, missedPassive: 0, hedgePnl: 0, hedgeCost: 0, cashYield: 0, exposureSum: 0, exposureN: 0 };
   let hedgeRub = 0;
 
   const divRule = (i, t) => {
@@ -110,6 +120,35 @@ export function simulateStrategy({ ds, wf, p, policy = STRATEGY_POLICY, capital
     stockPnl[i] = stockPnl[i] * 0.90 + (g - 2 * c);
     stockCnt[i] += 1;
   };
+  const trimPos = (i, pos, exitT, exitPx, trimAllocRub, why) => {
+    const frac = Math.min(1, Math.max(0, trimAllocRub / pos.alloc));
+    if (frac >= 0.999) {
+      closePos(i, pos, exitT, exitPx, why, 'rotation');
+      stats.rotations++;
+      return true;
+    }
+    const c = costOf(i);
+    const g = gainOf(pos, exitPx);
+    const sliceAlloc = pos.alloc * frac;
+    const sliceEntryFee = pos.entryFee * frac;
+    const gross = sliceAlloc * g;
+    const fee = (sliceAlloc + (pos.side === 'long' ? gross : -gross)) * c;
+    equity += gross - fee;
+    if (collectTrades) {
+      trades.push({
+        symbol: tokens[i].symbol, side: pos.side, entryTs: timeline[pos.entryT], exitTs: timeline[Math.min(exitT, T - 1)],
+        entryPrice: pos.entryPx, exitPrice: exitPx, alloc: sliceAlloc,
+        pnl: gross - fee - sliceEntryFee, pnlPct: ((gross - fee - sliceEntryFee) / sliceAlloc) * 100,
+        commission: fee + sliceEntryFee, barsHeld: (exitT - pos.entryT) * BAR_INTERVAL,
+        expectedPct: pos.expectedPct, stopPct: pos.stopPct, reasonExit: why, exitKind: 'trim',
+        dayMovePct: pos.dayMovePct, counterTrend: pos.counterTrend, tier: isT1(i) ? 1 : 2,
+      });
+    }
+    pos.alloc -= sliceAlloc;
+    pos.entryFee -= sliceEntryFee;
+    stats.trims++;
+    return false;
+  };
   const mtmUnreal = (t) => {
     let s = 0;
     for (const q of held.values()) s += q.alloc * gainOf(q, tokens[q.i].close[t]);
@@ -189,7 +228,7 @@ export function simulateStrategy({ ds, wf, p, policy = STRATEGY_POLICY, capital
       }
       if (done) continue;
       if (policy.profitLock) {
-        const lv = profitLockLevels(tk.symbol, pos.peakGain * 100, heldMinStart, roundTripFeePct);
+        const lv = profitLockLevels(tk.symbol, pos.peakGain * 100, heldMinStart, roundTripFeePct, policy);
         if (lv) {
           const gO = gainOf(pos, o) * 100;
           if (gO <= lv.floorPct && gO >= lv.minExitPct) { closePos(i, pos, t, o, 'Фиксация прибыли', 'lock'); stats.locks++; done = true; }
@@ -199,7 +238,7 @@ export function simulateStrategy({ ds, wf, p, policy = STRATEGY_POLICY, capital
       if (done) continue;
       pos.peakGain = Math.max(pos.peakGain, gainOf(pos, favorable));
       if (policy.profitLock) {
-        const lv = profitLockLevels(tk.symbol, pos.peakGain * 100, heldMinStart + BAR_INTERVAL, roundTripFeePct);
+        const lv = profitLockLevels(tk.symbol, pos.peakGain * 100, heldMinStart + BAR_INTERVAL, roundTripFeePct, policy);
         const gC = gainOf(pos, c) * 100;
         if (lv && gC <= lv.floorPct && gC >= lv.minExitPct) { closePos(i, pos, t, c, 'Фиксация прибыли', 'lock'); stats.locks++; }
       }
@@ -304,8 +343,84 @@ export function simulateStrategy({ ds, wf, p, policy = STRATEGY_POLICY, capital
       let nL = 0, nS = 0;
       for (const q of held.values()) { if (q.side === 'long') nL++; else nS++; }
       const budget = equity + mtmUnreal(t);
-      // ротация остывшей позиции в сильного лидера (на плановом шаге)
-      if (isStep && (candL.length || candS.length) && grossUsed(t) > budget * maxGross * 0.65) {
+      const pickWeight = (i) => (policy.netPickSort !== false ? Math.max(0.0001, Math.abs(edge(i)) - 2 * costOf(i)) : Math.max(0.0001, Math.abs(edge(i))));
+      const calcDesiredRub = (i, side, e, stopPct) => {
+        const tm = tierSizeMult(tokens[i].symbol, lev, side, policy);
+        if (!(tm > 0)) return 0;
+        const conv = convictionMult(Math.abs(e) / need, profile);
+        return targetPositionRub({
+          symbol: tokens[i].symbol, side,
+          budget: budget * capScale * tm,
+          slotRub: budget * slotW * tm,
+          conv, stopPct,
+          barTurnoverRub: isT1(i) ? 0 : barTurnover(i, t),
+          profile: legacySizing ? null : profile,
+        }, policy);
+      };
+
+      // Двухступенчатое динамическое потеснение (ротация остывшей позиции или частичное подрезание T2 под флагман T1)
+      let avail = Math.max(0, budget * maxGross - grossUsed(t));
+      if (!legacySizing && policy.crowdOut !== false && held.size > 0 && (candL.length || candS.length)) {
+        const rawPicks = [
+          ...candL.slice(0, Math.max(0, K - nL)).map((i) => [i, 'long']),
+          ...candS.slice(0, Math.max(0, K - nS)).map((i) => [i, 'short']),
+        ];
+        rawPicks.sort((a, b) => pickWeight(b[0]) - pickWeight(a[0]));
+        const minAgeBars = Math.round((policy.crowdMinMin ?? 20) / BAR_INTERVAL);
+        const minChunkRub = Math.max(45000, budget * (policy.crowdMinPct ?? 0.06));
+        const rotBuf = (policy.crowdRotBufPct ?? 0.08) / 100;
+        const trimBuf = (policy.crowdTrimBufPct ?? 0.12) / 100;
+        const desiredItems = [];
+        for (const [i, side] of rawPicks) {
+          const e = edge(i);
+          const sigmaBarPct = sg[i] * 100;
+          const ctx = dayContext(ds, i, t, sigmaBarPct);
+          if (counterTrendBlocked(side, ctx, policy)) continue;
+          const stopPct = protectiveStopPct(side, { sigmaBarPct, realizedBarPct: ctx.realizedBarPct, horizonBars: holdBars }, policy);
+          desiredItems.push({ i, side, e, netEdge: pickWeight(i), targetRub: calcDesiredRub(i, side, e, stopPct) });
+        }
+        const totalDesired = desiredItems.reduce((s, x) => s + x.targetRub, 0);
+        let shortfall = totalDesired - avail;
+        const bestT1 = desiredItems.find((x) => isT1(x.i));
+        if (shortfall >= minChunkRub && bestT1) {
+          const elig = [];
+          for (const [hi, q] of held) {
+            if (t + 1 - q.entryT < minAgeBars) continue;
+            if (!(tokens[hi].open[t + 1] > 0)) continue;
+            const curSigned = q.side === 'long' ? edge(hi) : -edge(hi);
+            const thrEntry = q.side === 'long' ? Math.max(needL * mult[hi] * tierScale(hi), minEdgeL) : Math.max(needS * mult[hi] * tierScale(hi), minEdgeS);
+            elig.push({ hi, q, curSigned, thrEntry, tierRank: isT1(hi) ? 1 : 0 });
+          }
+          elig.sort((a, b) => (a.tierRank - b.tierRank) || (a.curSigned - b.curSigned));
+          for (const el of elig) {
+            if (shortfall < minChunkRub * 0.5) break;
+            const { hi, q, curSigned, thrEntry } = el;
+            const pxExit = fill === 'mid' ? (tokens[hi].open[t + 1] + tokens[hi].close[t + 1]) / 2 : tokens[hi].open[t + 1];
+            const heldIsT1 = isT1(hi);
+            const cooled = curSigned < thrEntry * (heldIsT1 ? (policy.crowdCoolRatioT1 ?? 0.45) : (policy.crowdCoolRatioT2 ?? 0.80));
+            const netAdv = bestT1.netEdge - Math.max(0, curSigned);
+            if (cooled && netAdv >= rotBuf) {
+              if (!heldIsT1 || curSigned < thrEntry * 0.35 || q.alloc - shortfall < minChunkRub) {
+                closePos(hi, q, t + 1, pxExit, 'Ротация в сильный сигнал', 'rotation');
+                stats.rotations++;
+                if (q.side === 'long') nL--; else nS--;
+              } else {
+                const trimAmt = Math.min(shortfall, q.alloc - minChunkRub);
+                if (trimAmt >= minChunkRub) trimPos(hi, q, t + 1, pxExit, trimAmt, 'Частичное потеснение под сильный сигнал');
+              }
+              avail = Math.max(0, budget * maxGross - grossUsed(t));
+              shortfall = totalDesired - avail;
+            } else if (!cooled && !heldIsT1 && netAdv >= trimBuf && q.alloc >= minChunkRub * 1.5) {
+              const trimAmt = Math.min(shortfall, q.alloc - minChunkRub);
+              if (trimAmt >= minChunkRub) {
+                trimPos(hi, q, t + 1, pxExit, trimAmt, 'Частичное потеснение под сильный сигнал');
+                avail = Math.max(0, budget * maxGross - grossUsed(t));
+                shortfall = totalDesired - avail;
+              }
+            }
+          }
+        }
+      } else if (legacySizing && isStep && (candL.length || candS.length) && grossUsed(t) > budget * maxGross * 0.65) {
         const best = Math.max(candL.length ? edge(candL[0]) : 0, candS.length ? -edge(candS[0]) : 0);
         if (best >= need * 2.2) {
           let wi = -1, we = Infinity;
@@ -321,27 +436,42 @@ export function simulateStrategy({ ds, wf, p, policy = STRATEGY_POLICY, capital
           }
         }
       }
+
       const picks = [
         ...candL.slice(0, Math.max(0, K - nL)).map((i) => [i, 'long']),
         ...candS.slice(0, Math.max(0, K - nS)).map((i) => [i, 'short']),
       ];
-      picks.sort((a, b) => Math.abs(edge(b[0])) - Math.abs(edge(a[0])));
-      let avail = Math.max(0, budget * maxGross - grossUsed(t));
-      let remW = picks.reduce((s, [i]) => s + Math.max(0.0001, Math.abs(edge(i))), 0);
+      picks.sort((a, b) => pickWeight(b[0]) - pickWeight(a[0]));
+      avail = Math.max(0, budget * maxGross - grossUsed(t));
+      const prepared = [];
       for (const [i, side] of picks) {
         const e = edge(i);
-        const w = Math.max(0.0001, Math.abs(e));
-        const propShare = remW > 0 ? avail * (w / remW) : avail;
-        remW -= w;
         const sigmaBarPct = sg[i] * 100;
         const ctx = dayContext(ds, i, t, sigmaBarPct);
         if (counterTrendBlocked(side, ctx, policy)) { stats.blockedCT++; continue; }
         const stopPct = protectiveStopPct(side, { sigmaBarPct, realizedBarPct: ctx.realizedBarPct, horizonBars: holdBars }, policy);
-        const conv = Math.min(convMax, Math.max(0.85, 0.80 + convK * (Math.abs(e) / need)));
-        const tm = isT1(i) ? (policy.sizeMultT1 ?? lev) : (policy.sizeMultT2 ?? 1);
-        if (!(tm > 0)) continue;
-        const target = targetPositionRub({ symbol: tokens[i].symbol, side, budget: budget * capScale * tm, slotRub: budget * slotW * tm, conv: convMax > 1 ? conv : 1, stopPct, barTurnoverRub: isT1(i) ? 0 : barTurnover(i, t) }, policy);
-        const alloc = Math.min(target, propShare, avail);
+        const targetRub = calcDesiredRub(i, side, e, stopPct);
+        if (!(targetRub > 0)) continue;
+        prepared.push({ i, side, e, weight: pickWeight(i), targetRub, stopPct, ctx });
+      }
+      const allocs = (!legacySizing && policy.waterFill !== false)
+        ? waterFillAllocations(prepared, avail)
+        : (() => {
+            const out = new Float64Array(prepared.length);
+            let a = avail;
+            let remW = prepared.reduce((s, x) => s + x.weight, 0);
+            for (let idx = 0; idx < prepared.length; idx++) {
+              const propShare = remW > 0 ? a * (prepared[idx].weight / remW) : a;
+              remW -= prepared[idx].weight;
+              const al = Math.min(prepared[idx].targetRub, propShare, a);
+              out[idx] = al;
+              a -= al;
+            }
+            return out;
+          })();
+      for (let idx = 0; idx < prepared.length; idx++) {
+        const { i, side, e, stopPct, ctx } = prepared[idx];
+        const alloc = Math.min(allocs[idx], avail);
         if (!(alloc > 5000)) continue;
         const tk = tokens[i];
         let entryPx = fill === 'mid' ? (tk.open[t + 1] + tk.close[t + 1]) / 2 : tk.open[t + 1];

package/server/strategist/index.js

@@ -249,16 +249,31 @@ ${liveTradingSummary}
   - Если данные инструментов расходятся с календарём или временем — **верь данным инструментов**: это фактические позиции и исполненные сделки.
 
 ## Как устроено автоматическое ядро платформы «НейроАльфа» (Рынок как язык)
-- **Словарь:** ~100 самых ликвидных акций индекса широкого рынка Мосбиржи (MOEXBMI) + индекс IMOEX. Свечи 10-минутные, дивидендные отсечки скорректированы со сверкой по реальному гэпу цены, объёмы нормированы по 24-часовому суточному профилю (valRatio по часам МСК).
+- **Словарь:** ~125 акций широкого рынка Мосбиржи (MOEXBMI) + индекс IMOEX. Свечи 10-минутные, дивидендные отсечки скорректированы со сверкой по реальному гэпу цены, объёмы нормированы по 24-часовому суточному профилю (valRatio по часам МСК).
 - **Карта рынка и авто-эмбеддинг (modelEmbedDim = 0 Авто):** окно обучения фиксировано на 90 торговых днях. На каждом шаге размерность карты рынка автоматически определяется по спектральному порогу Марченко–Пастура (отсечение рыночного шума от истинных факторов).
-- **12 голов внимания и мульти-горизонт (1,5–3,5 часа):** модель смотрит на 3 масштаба времени (1ч, 3ч, день), цену и денежный поток, узких и широких соседей по карте, предсказывая чистое остаточное движение каждой акции относительно индекса Мосбиржи.
-- **Пороги входа и удержания (индивидуальные по эшелонам ликвидности):**
-  - Базовый порог выгоды на вход = 2,5 × (удвоенная сумма комиссии и проскальзывания) × 1,60 (запас над реальными издержками по стресс-тесту и фактическим сделкам). Для высоколиквидных голубых фишек 1-го эшелона (SBER, LKOH, GAZP, T, YDEX, GMKN, FLOT и др.) при издержках 0,05% за сделку это +0,40% (с индивидуальной подстройкой под оборот и волатильность бумаги).
-  - Для акций 2–3-го эшелона с более широким спредом в стакане (MRKU, LSRG, SFIN, SOFL, FIXR, NKNCP, SVAV, PIKK, SMLT и др.) порог автоматически повышается в 1,20× — до ~+0,48% (с индивидуальной поправкой на рублёвую ликвидность стакана).
-  - Авто-балансировка по тренду индекса: на растущем рынке (индекс выше 20-дневной средней) покупки открываются от базового порога (+0,40% 1-й эшелон и +0,48% 2–3-й эшелон), а контртрендовые шорты ужесточаются в 1,25× (до −0,50% для 1-го эшелона и −0,60% для 2–3-го эшелона). На падающем рынке — наоборот. Всегда называй пользователю именно индивидуальный порог конкретной бумаги (\`порог_покупки_проц\` / \`порог_шорта_проц\`).
-  - Удержание позиции: первые 65 минут после входа действует мягкий порог удержания (0,35× от порога входа), затем — плотный порог фиксации прибыли.
-  - Реальные издержки на счёте Т-Банка (по фактическим сделкам): комиссия ~0,04% + отклонение цены исполнения от цены сигнала ~0,03–0,08% на сторону.
-- **Dynamic Top-K (modelTopK = 0 Авто) и Conviction Sizing:** фиксированного числа акций нет — робот держит от 0 до 4 лонгов и до 4 шортов в зависимости от силы сигналов и концентрирует слот в лучших лидерах.
+- **12 голов внимания и мульти-горизонт обучения (2,5 часа = 15 свечей, диапазон 1,5–3,5 часа):** модель смотрит на 3 масштаба времени (1ч, 3ч, день), цену и денежный поток, узких и широких соседей по карте, предсказывая чистое остаточное движение каждой акции относительно индекса Мосбиржи (Edge_i = y_i × sigma_i × √15).
+- **Эшелоны ликвидности и реальные издержки («на сторону» и «за полный круг»):**
+  - «Издержки на сторону» — это потери на одной операции (отдельно на входе и отдельно на выходе); за полный круг сделки («купил → продал») они удваиваются. Комиссия брокера (Т-Банк) одинаковая для всех бумаг (0,04% на сторону = 0,08% за круг), а потери в биржевом стакане (спред + проскальзывание) зависят от эшелона:
+  - **1-й эшелон (33 ликвидные акции с глубоким стаканом:** SBER, SBERP, LKOH, GAZP, T, YDEX, ROSN, NVTK, GMKN, PLZL, VTBR, TATN, TATNP, SNGS, SNGSP, ALRS, CHMF, NLMK, MAGN, MOEX, OZON, PHOR, AFLT, MTSS, IRAO, TRNFP, RUAL, FLOT, X5, MTLR, BSPB, RTKM, SVCB): потери в стакане ~0,025% + комиссия 0,04% = **0,065% на сторону (0,13% за круг)**.
+  - **2–3-й эшелон (остальные ~92 акции,** включая высоковолатильные бумаги с более широким спредом и хвостовым риском: SMLT, PIKK, POSI, AFKS, VKCO, SPBE, UGLD, HEAD, CBOM, LSRG, SFIN, FESH и др.): потери в стакане ~0,085% + комиссия 0,04% = **0,125% на сторону (0,25% за круг)**.
+- **Пороги входа по эшелонам и тренду индекса:**
+  - Базовый порог выгоды на вход = 2,5 × 2 × (комиссия + проскальзывание) × 1,60. Для 1-го эшелона при настройке издержек 0,05% базовый порог составляет **+0,40%** (с тонкой поправкой symbolEdgeMult на оборот и волатильность бумаги в коридоре 0,88..1,45).
+  - Для 2–3-го эшелона порог входа повышен в **1,20× (TIER2_EDGE_MULT)** — до **~+0,48%**, чтобы ожидаемый импульс с запасом перекрывал более широкий спред стакана. В первые 20 минут утренней сессии (07:00–07:20 МСК) шорты 2-го эшелона блокируются из-за пустого утреннего стакана.
+  - Авто-балансировка по тренду индекса (isMarketDown): на растущем рынке покупки открываются от базового порога (+0,40% 1-й эшелон и +0,48% 2-й эшелон), а контртрендовые шорты ужесточаются в 1,25× (до −0,50% и −0,60%). На падающем рынке — наоборот: покупки ужесточаются в 1,25×, а шорты облегчаются в 0,90×. Всегда называй пользователю точный индивидуальный порог конкретной бумаги (\`порог_покупки_проц\` / \`порог_шорта_проц\`).
+- **Размер позиций, сублинейное плечо, перелив капитала и динамическое потеснение (policy.js):**
+  - **Живой Conviction Sizing без холостого резерва:** робот держит до 4 лонгов и до 4 шортов, но поскольку 81,5% активного времени на рынке есть ровно 1 сигнал, стратегия не замораживает половину лимита «на всякий случай». В режиме владельца базовый слот 1-го эшелона составляет 56% бюджета и масштабируется на силу сигнала conv (от 0,85× до 1,92×), разгоняя сильные одиночные импульсы до **92% бюджета в лонг и до 70% в шорт** на счёте 1× (на VIP — до 75% / 56%, на Профи — до 52% / 40%, на Инвесторе — до 58% в лонг).
+  - **Сублинейное масштабирование одиночной позиции по плечу (tierSizeMult):**
+    1. В **1-м эшелоне** потолок одной бумаги растёт с плечом счёта сублинейно по формуле 1 + 0,80 × (плечо − 1) (на 1× → 1,00×, на 2× → 1,80×, на 3× → 2,60× при общем лимите портфеля 2×..3× капитала). Это удерживает риск одной бумаги под контролем, а разницу между лимитом бумаги и общим плечом счёта превращает в бесплатный маржинальный резерв под 2-ю и 3-ю параллельные сделки под залог LQDT.
+    2. Во **2-м эшелоне** действует прямой риск-потолок без двойного штрафа: до **17% бюджета в лонг** (масштаб плеча 1 + 0,72 × (плечо − 1)) и до **7% в шорт** (1 + 0,40 × (плечо − 1)), под жёстким отсечением по реальной ликвидности биржи — **не более 15% от медианного 10-минутного оборота свечи (barTurnoverRub)** (минимум 45 000 ₽).
+  - **Итеративный перелив капитала (waterFillAllocations) и чистая отдача (netPickSort):** очерёдность и веса между отобранными сделками определяются по чистой ожидаемой отдаче за вычетом круговых издержек (|expectedPct| − 0,13% для 1-го эшелона и |expectedPct| − 0,25% для 2-го). При одновременном входе бумаги с узким лимитом (2-й эшелон / тонкий стакан) забирают ровно свой потолок, а весь невыбранный остаток переливается флагманским лидерам 1-го эшелона.
+  - **Двухступенчатое динамическое потеснение (crowdOut):** если свободного лимита не хватает под новый сильный сигнал 1-го эшелона (не моложе 20 минут жизни уже открытых сделок), робот освобождает место по факту: (1) полностью ротирует остывшую позицию либо (2) частично подрезает позицию 2-го эшелона под флагман 1-го эшелона с сохранением времени входа entryTs и накопленного пика peakPrice для трала Profit Lock (на счетах auto работает и на быстрых 20-секундных входах, на confirm — на плановых 30-минутных шагах).
+  - **Капитал в фонде денежного рынка LQDT как залог:** свободный капитал работает в LQDT, а внутридневные позиции открываются под обеспечение и закрываются до ночи (без платы брокеру за перенос через ночь).
+- **Глубина сопровождения позиций (130 минут), фиксация прибыли и защитные контуры:**
+  - **Глубина сопровождения (holdBars = 13 свечей = 130 минут = 2 ч 10 м):** плановая ревизия портфеля идёт каждые 20–30 минут (holdBars / 5), а вечернее окно новых внутридневных входов закрывается за 130 минут до конца торгов (после **21:30 МСК** новые входы не открываются, перед 23:40–23:50 МСК позиции закрываются перед ночью).
+  - **Плавная рампа удержания (exitHoldRatio):** первые **45 минут** после входа действует мягкий порог удержания (0,35× от порога входа), чтобы сделку не выбило шумом; затем с 45-й по **130-ю минуту** порог плавно поднимается к 0,95×, динамически подстраиваясь под сегодняшнюю волатильность бумаги (realizedBarPct / sigmaBarPct в коридоре [0,75..1,25]: в спокойный день держит дольше, в турбулентный фиксирует быстрее).
+  - **Скользящая фиксация прибыли (profitLockLevels):** включает безубыток от +0,85% × tierMult (после 15 мин) и скользящий Take-Profit от +1,20% × tierMult (+1,55% × tierMult в первые 15 мин). В 1-м эшелоне трал удерживает ≥70% пиковой прибыли (допуская откат до 0,45%), а во 2-м эшелоне работает **уплотнённый трал — удерживает ≥75% пика и допускает откат не более 0,35%**, забирая импульс до разворота спреда.
+  - **Аварийный стоп — 7% от средней цены входа** (выставляется реальной стоп-заявкой у брокера и контролируется внутри свечи).
+  - **Карантин убыточных бумаг (isStockQuarantined):** FIFO-учёт кругов сделок с периодом полураспада ~15 торговых дней (0,9985 на 30-минутном шаге); если бумага накопила серию убытков (≥2 сделок с суммарным итогом < −1,2% или < −2,5%), слабые сигналы по ней пропускаются, но **сильный сигнал (≥ 110% от индивидуального порога входа) пробивает карантин**.
 
 ## Брокерские счета и режимы работы
 Полная поддержка — Т-Банк (T-Invest API, включая секцию TQBR и SPBRU для SPBE). Финам, БКС, Алор, Цифра брокер и ITI Capital — бета, только «Подтверждение заявок». СберИнвестиции, ВТБ и Альфа-Инвестиции сейчас не подключаются (нет открытого API для заявок).