neuroalpha 0.6.11 → 0.6.13

package/server/index.js

@@ -1,5 +1,6 @@
 // Copyright (c) 2026 Roman A. Perepelkin. All rights reserved. Proprietary software.
 import http from 'node:http';
+import fs from 'node:fs';
 import os from 'node:os';
 import { spawn } from 'node:child_process';
 import path from 'node:path';
@@ -141,11 +142,26 @@ app.use('/docs', express.static(path.join(ROOT, 'docs')));
 app.use(express.static(path.join(ROOT, 'public')));
 
 function lanUrls() {
-  return Object.values(os.networkInterfaces()).flat()
+  return Object.entries(os.networkInterfaces())
+    .filter(([name]) => !/vethernet|wsl|docker|hyper-v|virtualbox|vmware/i.test(name))
+    .flatMap(([, list]) => list || [])
     .filter((a) => a && a.family === 'IPv4' && !a.internal)
     .map((a) => `http://${a.address}:${PORT}`);
 }
 
+function fmtClickableUrl(url, out = process.stdout) {
+  if (!out?.isTTY) return url;
+  const osc8 = Boolean(
+    process.env.WT_SESSION
+    || process.env.TERM_PROGRAM
+    || process.env.COLORTERM
+    || process.env.FORCE_HYPERLINK === '1'
+    || (process.platform !== 'win32' && process.env.TERM && process.env.TERM !== 'dumb'),
+  );
+  const styled = `\x1b[4;96m${url}\x1b[0m`;
+  return osc8 ? `\x1b]8;;${url}\x1b\\${styled}\x1b]8;;\x1b\\` : styled;
+}
+
 const shouldOpenBrowser = process.env.OPEN_BROWSER === '1'
   || (process.env.OPEN_BROWSER !== '0'
     && process.env.NO_BROWSER !== '1'
@@ -157,9 +173,10 @@ const shouldOpenBrowser = process.env.OPEN_BROWSER === '1'
 
 wss.on('error', () => {});
 server.on('error', (e) => {
+  const clientUrl = `http://localhost:${PORT}`;
   if (e.code === 'EADDRINUSE') {
-    console.error(`Порт ${PORT} занят: сервер уже запущен? Клиент: http://localhost:${PORT}`);
-    if (shouldOpenBrowser) openBrowser(`http://localhost:${PORT}`);
+    console.error(`Порт ${PORT} занят: сервер уже запущен? Клиент: ${fmtClickableUrl(clientUrl, process.stderr)}`);
+    if (shouldOpenBrowser) openBrowser(clientUrl);
   } else {
     console.error(e);
   }
@@ -168,12 +185,20 @@ server.on('error', (e) => {
 
 server.listen(PORT, LISTEN_HOST, () => {
   const ident = IS_INSTANCE ? getIdentity() : null;
-  console.log(`Консорциум агентов запущен · режим ${ROLE}${IS_INSTANCE ? ` (${INSTANCE_KIND}) · машина ${ident.id || 'не активирована'} · центр ${ident.centralUrl}` : ''}`);
+  let ver = '';
+  try { ver = ` v${JSON.parse(fs.readFileSync(path.join(ROOT, 'package.json'), 'utf8')).version}`; } catch { /* ignore */ }
+  console.log(`◈ НейроАльфа${ver} запущена${IS_INSTANCE ? ` (${INSTANCE_KIND}) · машина ${ident.id || 'не активирована'} · центр ${ident.centralUrl}` : (IS_CENTRAL ? ' · центр' : '')}`);
   const llm = activeModelInfo();
-  console.log(`ИИ-стратег: ${llm.enabled ? `${llm.provider} · ${llm.model}` : 'выключен (нет модели или ключа: Настройки → Модели ИИ)'}`);
-  if (!LISTEN_HOST || LISTEN_HOST === '0.0.0.0') for (const url of lanUrls()) console.log(`  В локальной сети: ${url}`);
-  console.log(`Клиент: http://localhost:${PORT}`);
-  if (shouldOpenBrowser) openBrowser(`http://localhost:${PORT}`);
+  console.log(`  ИИ-стратег: ${llm.enabled ? `${llm.provider} · ${llm.model}` : 'выключен (Настройки → Модели ИИ)'}`);
+  if (!LISTEN_HOST || LISTEN_HOST === '0.0.0.0') for (const url of lanUrls()) console.log(`  В сети:     ${fmtClickableUrl(url)}`);
+  const clientUrl = `http://localhost:${PORT}`;
+  const enterHint = process.stdin?.isTTY && !IS_CENTRAL ? '  (Enter — открыть в браузере)' : '';
+  console.log(`  Клиент:     ${fmtClickableUrl(clientUrl)}${enterHint}`);
+  if (shouldOpenBrowser) openBrowser(clientUrl);
+  if (process.stdin?.isTTY && !IS_CENTRAL) {
+    process.stdin.on('data', () => openBrowser(clientUrl));
+    process.stdin.unref?.();
+  }
 });
 
 function openBrowser(url) {

package/server/model/dataset.js

@@ -295,10 +295,9 @@ export async function loadDataset({ interval = BAR_INTERVAL, fromTs, tillTs, use
           killer.unref?.();
         }),
       ]);
-    } catch (e) {
+    } catch {
       if (signal?.aborted) throw new Error('Отменено');
       raw[s] = EMPTY();
-      console.warn(`[dataset] ${s}: ${e.message} — акция пропущена`);
     } finally {
       clearTimeout(killer);
       onProgress({ symbol: s, done: ++done, total: all.length });
@@ -309,10 +308,9 @@ export async function loadDataset({ interval = BAR_INTERVAL, fromTs, tillTs, use
     try {
       onProgress({ symbol: 'BR', done: done, total: all.length });
       raw.BR = await loadBrent(fromTs, tillTs, signal, { localOnly });
-    } catch (e) {
+    } catch {
       if (signal?.aborted) throw new Error('Отменено');
       raw.BR = EMPTY();
-      console.warn(`[dataset] BR: ${e.message} — нефть пропущена`);
     }
   }
   if (!raw.IMOEX?.n) throw new Error('Нет данных индекса МосБиржи');

package/server/model/forecast.js

@@ -966,9 +966,7 @@ export async function forecastNow(input, { force = false, onProgress } = {}) {
     if (saved?.result && saved.key === key && now - (saved.result.at || 0) < 4 * 3600000) {
       if (!inflight.has(key)) {
         setImmediate(() => {
-          refreshDatasetStateInBackground(p, key, { force: false }).catch((err) => {
-            console.warn('[forecast] background warm-up error:', err?.message || err);
-          });
+          refreshDatasetStateInBackground(p, key, { force: false }).catch(() => {});
         });
       }
       const liveSnap = await fetchLiveMoexSnapshot().catch(() => null);

package/server/model/policy.js

@@ -19,28 +19,44 @@ export const STRATEGY_POLICY = Object.freeze({
   profitLock: true,
   // размер позиции: 'slot' — доля бюджета × сила сигнала
   sizing: Object.freeze({ mode: 'slot' }),
-  // Множитель размера позиции по эшелонам:
-  //   • 1-й эшелон (33 ликвидные акции, PF 2,86 и 0 стопов на 59 051 свече): масштабируется на полное плечо счёта (lev),
-  //     предельный вес бумаги — до 50% бюджета в лонг и до 38% в шорт (базовый слот 0,50);
-  //   • 2-й эшелон: асимметричное масштабирование от плеча счёта (лонг max(0,50, 0,38 × lev), шорт max(0,35, 0,22 × lev))
-  //     под защитой потолка реальной ликвидности стакана (15% от медианного 10-минутного оборота свечи barTurnoverRub)
-  //     и плотного сопровождения Take-Profit (удержание ≥75% пика и откат ≤0,35%).
-  // Проверка 13.11.2026 (06.2024–11.2026, 59 051 свеча): улучшает итог на обеих половинах истории при любом плече
-  //   • плечо 1×: CAGR 49,2%/30,7% по половинам (весь 39,5%, PF 1,85, DD 2,0%) против 43,8%/27,3% (весь 35,1%, PF 1,63);
-  //   • плечо 2×: CAGR 73,8%/47,4% по половинам (весь 59,8%, 6 мес. 105,0%, PF 2,03, DD 3,6%) против 54,5%/40,6% (весь 47,2%, PF 1,87, DD 3,4%);
-  //   • плечо 3×: CAGR 104,6%/65,6% по половинам (весь 83,7%, PF 2,07, DD 5,9%) против 65,9%/55,2% (весь 60,3%, PF 2,03, DD 6,0%).
-  sizeMultT2LongBase: 0.50,
-  sizeMultT2LongLev: 0.38,
-  sizeMultT2ShortBase: 0.35,
-  sizeMultT2ShortLev: 0.22,
-  capT1Long: 0.50,
-  capT1Short: 0.38,
-  capT2Long: 0.22,
-  capT2Short: 0.18,
+  // Адаптивное распределение размера позиции, сублинейное плечо и перелив капитала (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,
@@ -141,44 +157,166 @@ export function exitHoldRatio(heldMin, horizonMin, { sigmaBarPct = 0, realizedBa
   return startRatio + (endRatio - startRatio) * ramp;
 }
 
-// ---------- плечо и множители размера по эшелонам ----------
+// ---------- профиль слотов по тарифу, плечо и предельный размер позиции ----------
 export const MAX_LEVERAGE = 7;
+
+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));
-  if (TIER1_LIQUID_SYMBOLS.has(symbol)) return policy.sizeMultT1 ?? lev;
-  if (policy.sizeMultT2 !== undefined) return policy.sizeMultT2;
-  const raw = 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(raw * 1000) / 1000;
+  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, policy = STRATEGY_POLICY) {
+export function symbolCapRub(symbol, side, budget, barTurnoverRub = 0, policy = STRATEGY_POLICY, profile = null) {
   const isT1 = TIER1_LIQUID_SYMBOLS.has(symbol);
   const isShort = side === 'short';
-  const capPct = isShort
-    ? (isT1 ? (policy?.capT1Short ?? 0.38) : (policy?.capT2Short ?? 0.18))
-    : (isT1 ? (policy?.capT1Long ?? 0.50) : (policy?.capT2Long ?? 0.22));
+  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, policy);
-  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

@@ -41,7 +41,8 @@ export { isMarketDown };
 // 17: капитал в LQDT как залог, половинный размер 2-го эшелона, строки с плечом 3 и 5
 // 18: глубина сопровождения позиции и вечернего окна входов holdBars=13 (130 мин) во всех контурах симуляции
 // 19: ревизия правил 1-го и 2-го эшелонов (MTLR/BSPB/RTKM/SVCB в T1, асимметричный масштаб T2 от плеча, лимит 50%/38% T1 и плотный трал T2)
-const DATA_VERSION = 19;
+// 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) {
@@ -822,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;
@@ -837,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, tierSizeMult, 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.50 : 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]);
@@ -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,28 +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']),
       ];
-      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))));
       picks.sort((a, b) => pickWeight(b[0]) - pickWeight(a[0]));
-      let avail = Math.max(0, budget * maxGross - grossUsed(t));
-      let remW = picks.reduce((s, [i]) => s + pickWeight(i), 0);
+      avail = Math.max(0, budget * maxGross - grossUsed(t));
+      const prepared = [];
       for (const [i, side] of picks) {
         const e = edge(i);
-        const w = pickWeight(i);
-        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 = tierSizeMult(tokens[i].symbol, lev, side, policy);
-        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];