neuroalpha 0.5.34 → 0.6.0

package/server/model/simulator.js

@@ -0,0 +1,366 @@
+// Copyright (c) 2026 Roman A. Perepelkin. All rights reserved. Proprietary software.
+// Симулятор стратегии с правилами живого контура (brokers/index.js) по 10-минутным свечам:
+//   • решения на закрытии свечи t, исполнение входов и плановых выходов по цене открытия t+1;
+//   • входы — на любой свече (быстрый добор живого контура), плановые выходы, ротация — раз в stepBars свечей;
+//   • защитный стоп, стоп отмены идеи и фиксация прибыли — внутри каждой свечи по её максимуму/минимуму
+//     (при неоднозначности внутри свечи считается, что сначала случилось неблагоприятное движение);
+//   • фильтры живого прогноза: окна начала/конца сессий, планки, перегрев, экстремальная свеча, утренние шорты 2-го эшелона,
+//     паузы повторного входа, карантин, дивидендный предохранитель, список бумаг для шорта;
+//   • размер позиции и пределы на бумагу — как у живого счёта (policy.js); издержки по эшелонам ликвидности;
+//   • по выбору: доход фонда денежного рынка LQDT на весь капитал (залог для внутридневной маржинальной торговли),
+//     защита вечным фьючерсом на индекс IMOEXF от движения рынка, плечо, пассивные лимитные входы, выход по времени.
+// Не моделируются: минутный фильтр затухания импульса, спред-фильтр стакана, новостной фильтр (нет истории).
+import { BAR_INTERVAL, BAR_MS } from './dataset.js';
+import { LIQ_MIN } from './models.js';
+import {
+  ENTRY_EDGE_MULT, TIER1_LIQUID_SYMBOLS, REGIME_SHOCK_1D, REGIME_CRASH_30M, QUARANTINE_DECAY,
+  isStockQuarantined, canEnterIntraday, shouldExitBeforeNight, isMarketDown,
+} from './edge.js';
+import { nextDividendAt, dividendRules } from './dividends.js';
+import { STRATEGY_POLICY, sessionEdgeWarning, profitLockLevels, protectiveStopPct, targetPositionRub, counterTrendBlocked, thesisStopPx, dayContext } from './policy.js';
+
+// Выравнивание внешнего ряда (свечи IMOEXF, дневные цены LQDT) по шкале датасета с переносом последней цены
+export function alignSeries(timeline, rows) {
+  const out = new Float64Array(timeline.length);
+  const sorted = [...rows].filter((r) => r.close > 0).sort((a, b) => a.ts - b.ts);
+  let j = 0, last = 0;
+  for (let i = 0; i < timeline.length; i++) {
+    while (j < sorted.length && sorted[j].ts <= timeline[i]) { last = sorted[j].close; j++; }
+    out[i] = last;
+  }
+  return out;
+}
+
+export function simulateStrategy({ ds, wf, p, policy = STRATEGY_POLICY, capital = 800000, plan = 'owner', fill = 'open', shortable = null, divCal = null, stopSlipPct = 0.10, collectTrades = true, fromTs = -Infinity, tillTs = Infinity, fut = null, lqdt = null, leverage = 1 }) {
+  const { tokens, timeline, T } = ds;
+  const N = tokens.length;
+  const H = wf.H;
+  const sqrtH = Math.sqrt(H);
+  const bpd = Math.max(1, Math.round(ds.barsPerDay || 94));
+  const stepBars = plan === 'owner' || plan === 'vip' ? Math.max(3, Math.floor(H / 5)) : H;
+  const K = policy.K ?? 4;
+  const dir = 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);
+  const isT1 = (i) => TIER1_LIQUID_SYMBOLS.has(tokens[i].symbol);
+  const costOf = (i) => (isT1(i) ? 0.00065 : 0.00125);
+  const commission = p.commissionPct / 100;
+  const cooldownBars = Math.round((policy.cooldownMin ?? 30) / BAR_INTERVAL);
+  const stopCooldownBars = Math.round((policy.stopCooldownMin ?? 60) / BAR_INTERVAL);
+  const horizonMin = Math.max(90, (H * 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 lev = Math.max(1, Number(leverage) || 1);
+  const maxGross = policy.maxGross ?? 0.99 * lev;
+  const capScale = policy.capScale ?? 1;
+  const tierScale = (i) => (isT1(i) ? (policy.edgeScaleT1 ?? 1) : (policy.edgeScaleT2 ?? 1));
+  const minEdgeL = (policy.minEdgePct ?? 0.30) / 100;
+  const minEdgeS = (policy.minEdgePct ?? 0.31) / 100;
+  const hedge = policy.hedge && fut ? policy.hedge : null;
+  const hedgeMult = hedge?.pointRub ?? 10;
+  const passive = policy.passiveEntry || null;
+
+  let equity = capital;
+  const held = new Map(); // i -> pos
+  const trades = [];
+  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 };
+  let hedgeRub = 0;
+
+  const divRule = (i, t) => {
+    if (!divCal) return null;
+    const nd = nextDividendAt(divCal, i, t);
+    return nd ? dividendRules(nd.daysToEx, nd.y) : null;
+  };
+  const gainOf = (pos, px) => (pos.side === 'long' ? px / pos.entryPx - 1 : 1 - px / pos.entryPx);
+  const pxOfGain = (pos, g) => (pos.side === 'long' ? pos.entryPx * (1 + g) : pos.entryPx * (1 - g));
+  const barTurnover = (i, t) => {
+    const vals = [];
+    for (let k = t; k >= 0 && vals.length < 48 && k > t - 400; k--) if (tokens[i].value[k] > 0) vals.push(tokens[i].value[k]);
+    if (!vals.length) return 0;
+    vals.sort((a, b) => a - b);
+    const mid = Math.floor(vals.length / 2);
+    const med = vals.length % 2 ? vals[mid] : (vals[mid - 1] + vals[mid]) / 2;
+    return med * 0.6 + (vals.reduce((s, v) => s + v, 0) / vals.length) * 0.4;
+  };
+
+  const closePos = (i, pos, exitT, exitPx, why, kind) => {
+    const c = costOf(i);
+    const g = gainOf(pos, exitPx);
+    const gross = pos.alloc * g;
+    const fee = (pos.alloc + (pos.side === 'long' ? gross : -gross)) * c + (kind === 'stop' || kind === 'thesis' ? pos.alloc * (stopSlipPct / 100) : 0);
+    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: pos.alloc,
+        pnl: gross - fee - pos.entryFee, pnlPct: ((gross - fee - pos.entryFee) / pos.alloc) * 100,
+        commission: fee + pos.entryFee, barsHeld: (exitT - pos.entryT) * BAR_INTERVAL,
+        expectedPct: pos.expectedPct, stopPct: pos.stopPct, reasonExit: why, exitKind: kind,
+        dayMovePct: pos.dayMovePct, counterTrend: pos.counterTrend, tier: isT1(i) ? 1 : 2,
+      });
+    }
+    held.delete(i);
+    cooldownUntil[i] = exitT + (kind === 'stop' || kind === 'thesis' ? stopCooldownBars : cooldownBars);
+    stockPnl[i] = stockPnl[i] * 0.90 + (g - 2 * realCost);
+    stockCnt[i] += 1;
+  };
+  const mtmUnreal = (t) => {
+    let s = 0;
+    for (const q of held.values()) s += q.alloc * gainOf(q, tokens[q.i].close[t]);
+    return s;
+  };
+  const grossUsed = (t) => {
+    let s = 0;
+    for (const q of held.values()) s += q.alloc * (1 + gainOf(q, tokens[q.i].close[t]) * (q.side === 'long' ? 1 : -1));
+    return s;
+  };
+
+  let firstK = wf.testTs.findIndex((t) => timeline[t] >= fromTs);
+  if (firstK < 0) firstK = wf.testTs.length;
+  let lastT = -1;
+  let prevT = -1;
+  for (let k = firstK; k < wf.testTs.length; k++) {
+    const t = wf.testTs[k];
+    if (timeline[t] > tillTs || t + 1 >= T) break;
+    lastT = t;
+    const fo = wf.foldOf[k];
+    const pr = wf.pred[k], sg = wf.foldSigma[fo], mult = wf.foldMult[fo], beta = wf.foldBeta[fo];
+    const decTs = timeline[t] + BAR_MS;
+    const isStep = (k - firstK) % stepBars === 0;
+    if (isStep) {
+      for (let i = 0; i < N; i++) { stockPnl[i] *= QUARANTINE_DECAY; stockCnt[i] *= QUARANTINE_DECAY; }
+    }
+    // доход фонда денежного рынка на весь капитал (LQDT в залоге; внутридневная маржа без платы за перенос)
+    if (policy.cashYield && lqdt && prevT >= 0 && lqdt[t] > 0 && lqdt[prevT] > 0 && lqdt[t] !== lqdt[prevT]) {
+      const y = equity * (lqdt[t] / lqdt[prevT] - 1);
+      equity += y;
+      stats.cashYield += y;
+    }
+    // результат защиты фьючерсом за свечу
+    if (hedge && hedgeRub !== 0 && prevT >= 0 && fut[t] > 0 && fut[prevT] > 0) {
+      const hp = hedgeRub * (fut[t] / fut[prevT] - 1);
+      equity += hp;
+      stats.hedgePnl += hp;
+    }
+    prevT = t;
+
+    // 1) внутри свечи t: фиксация прибыли, стоп отмены идеи и защитный стоп
+    for (const [i, pos] of [...held]) {
+      if (pos.entryT > t) continue;
+      const tk = tokens[i];
+      if (!tk.has[t]) continue;
+      const o = tk.open[t], h = tk.high[t], l = tk.low[t], c = tk.close[t];
+      const adverse = pos.side === 'long' ? l : h;
+      const favorable = pos.side === 'long' ? h : l;
+      const heldMinStart = (t - pos.entryT) * BAR_INTERVAL;
+      let done = false;
+      if (policy.profitLock) {
+        const lv = profitLockLevels(tk.symbol, pos.peakGain * 100, heldMinStart, roundTripFeePct);
+        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; }
+          else if (gO > lv.floorPct && gainOf(pos, adverse) * 100 <= lv.floorPct) { closePos(i, pos, t, pxOfGain(pos, lv.floorPct / 100), 'Фиксация прибыли', 'lock'); stats.locks++; done = true; }
+        }
+      }
+      if (done) continue;
+      const stopPx = pxOfGain(pos, -pos.stopPct / 100);
+      const levels = [[stopPx, 'stop']];
+      if (pos.thesisPx > 0) levels.push([pos.thesisPx, 'thesis']);
+      levels.sort((a, b) => (pos.side === 'long' ? b[0] - a[0] : a[0] - b[0]));
+      for (const [lvPx, kind] of levels) {
+        const hit = pos.side === 'long' ? adverse <= lvPx : adverse >= lvPx;
+        if (!hit) continue;
+        const px = pos.side === 'long' ? Math.min(o, lvPx) : Math.max(o, lvPx);
+        closePos(i, pos, t, px, kind === 'stop' ? 'Защитный стоп' : 'Стоп отмены идеи', kind);
+        if (kind === 'stop') stats.stops++; else stats.thesis++;
+        done = true;
+        break;
+      }
+      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 gC = gainOf(pos, c) * 100;
+        if (lv && gC <= lv.floorPct && gC >= lv.minExitPct) { closePos(i, pos, t, c, 'Фиксация прибыли', 'lock'); stats.locks++; }
+      }
+    }
+
+    // 2) решение на закрытии свечи t
+    const bear = isMarketDown(ds, t);
+    const needL = bear ? need * 1.25 : need;
+    const needS = bear ? need * 0.90 : need * 1.25;
+    const edge = (i) => pr[i] * sg[i] * sqrtH;
+    const t1d = Math.max(0, t - bpd), t3d = Math.max(0, t - 3 * bpd), t30 = Math.max(0, t - 3);
+    const mNow = ds.mclose[t];
+    const mx = (a) => (ds.mclose[a] > 0 && mNow > 0 ? mNow / ds.mclose[a] - 1 : 0);
+    const m1d = mx(t1d), m3d = mx(t3d), m30 = mx(t30);
+    const flags = (i) => {
+      const tk = tokens[i];
+      const px = tk.close[t];
+      const ex = (a, m) => (tk.close[a] > 0 && px > 0 ? px / tk.close[a] - 1 : 0) - m;
+      const ex1d = ex(t1d, m1d), ex3d = ex(t3d, m3d), ex30 = ex(t30, m30);
+      const flat = tk.high[t] > 0 && tk.high[t] === tk.low[t] && tk.value[t] > 1e6;
+      const lastMove = (tk.ret[t] - beta[i] * ds.mret[t]) * 100;
+      const rawMove = tk.close[t - 1] > 0 ? (px / tk.close[t - 1] - 1) * 100 : 0;
+      const crash = ex1d < -REGIME_SHOCK_1D || ex30 < -REGIME_CRASH_30M || (flat && ex1d < -0.05);
+      const squeeze = ex1d > REGIME_SHOCK_1D || (flat && ex1d > 0.05);
+      return {
+        crash, squeeze,
+        dipBlock: crash || lastMove < -4.5 || rawMove < -4.5,
+        spikeBlock: squeeze || lastMove > 4.5 || rawMove > 4.5,
+        overheat: ex1d >= 0.06 || ex3d >= 0.12,
+      };
+    };
+    const liquid = (i) => tokens[i].liq[t] >= LIQ_MIN && tokens[i].open[t + 1] > 0;
+    const nightNow = shouldExitBeforeNight(decTs, 0, 3, BAR_INTERVAL);
+    const exitsAt = [];
+    for (const [i, pos] of held) {
+      const nightExit = shouldExitBeforeNight(decTs, timeline[pos.entryT], 3, BAR_INTERVAL);
+      const dr = divRule(i, t);
+      const divExit = Boolean(dr && (pos.side === 'long' ? dr.exitLong : dr.exitShort));
+      if (nightExit || divExit) { exitsAt.push([i, nightExit ? 'Закрытие перед ночью' : 'Дивидендная отсечка', nightExit ? 'night' : 'div']); continue; }
+      const barsHeldNext = t + 1 - pos.entryT;
+      if (policy.maxHoldBars > 0 && barsHeldNext >= policy.maxHoldBars) { exitsAt.push([i, 'Выход по времени', 'time']); continue; }
+      if (!isStep) continue;
+      const fl = flags(i);
+      if (pos.side === 'long' ? fl.crash : fl.squeeze) { exitsAt.push([i, 'Защита от сквиза/обвала', 'regime']); continue; }
+      if (policy.signalExit === false) continue;
+      const heldMin = barsHeldNext * BAR_INTERVAL;
+      const ramp = heldMin <= 45 ? 0 : Math.min(1, (heldMin - 45) / (horizonMin - 45));
+      const thr = (0.35 + (0.95 - 0.35) * ramp) * need * mult[i] * tierScale(i);
+      const soft = 0.35 * need * mult[i] * tierScale(i);
+      const e = edge(i);
+      const signed = pos.side === 'long' ? e : -e;
+      const curGainPct = gainOf(pos, tokens[i].close[t]) * 100;
+      const holdDip = heldMin < horizonMin && liquid(i) && signed > soft && curGainPct >= -1.0 && curGainPct < roundTripFeePct + 0.12;
+      if (!(liquid(i) && (signed > thr || holdDip))) exitsAt.push([i, 'Прогноз ослаб', 'signal']);
+    }
+    for (const [i, why, kind] of exitsAt) {
+      const pos = held.get(i);
+      if (!pos) continue;
+      const px = fill === 'mid' ? (tokens[i].open[t + 1] + tokens[i].close[t + 1]) / 2 : tokens[i].open[t + 1];
+      closePos(i, pos, t + 1, px > 0 ? px : tokens[i].close[t], why, kind);
+      if (kind === 'night') stats.night++; else if (kind === 'signal') stats.signalExits++; else if (kind === 'time') stats.timeExits++; else if (kind === 'regime') stats.regime++; else stats.div++;
+    }
+
+    // 3) входы
+    const timeOk = canEnterIntraday(decTs, H, BAR_INTERVAL) && !sessionEdgeWarning(decTs) && !nightNow && (policy.entryEveryBar !== false || isStep);
+    if (timeOk) {
+      const baseOk = (i) => !held.has(i) && cooldownUntil[i] <= t && liquid(i) && (!tokens[i].inIndex || tokens[i].inIndex[t] === 1) && !isStockQuarantined(stockCnt[i], stockPnl[i]) && (policy.tier2 !== false || isT1(i));
+      const candL = [];
+      const candS = [];
+      for (let i = 0; i < N; i++) {
+        const e = edge(i);
+        if (e > Math.max(needL * mult[i] * tierScale(i), minEdgeL)) {
+          if (!baseOk(i)) continue;
+          const fl = flags(i);
+          if (fl.dipBlock || fl.overheat || divRule(i, t)?.blockLong) continue;
+          candL.push(i);
+        } else if (dir !== 'long' && e < -Math.max(needS * mult[i] * tierScale(i), minEdgeS)) {
+          if (!baseOk(i)) continue;
+          if (shortable && !shortable.has(tokens[i].symbol)) continue;
+          if (!canEnterIntraday(decTs, H, BAR_INTERVAL, 'short', tokens[i].symbol)) continue;
+          const fl = flags(i);
+          if (fl.spikeBlock || divRule(i, t)?.blockShort) continue;
+          candS.push(i);
+        }
+      }
+      candL.sort((a, b) => pr[b] - pr[a]);
+      candS.sort((a, b) => pr[a] - pr[b]);
+      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 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;
+          for (const [i, q] of held) {
+            const s = q.side === 'long' ? edge(i) : -edge(i);
+            if (s < need * 0.95 * 0.90 && s < we && best > Math.max(need, s) * 2.4) { we = s; wi = i; }
+          }
+          if (wi >= 0) {
+            const q = held.get(wi);
+            closePos(wi, q, t + 1, tokens[wi].open[t + 1], 'Ротация', 'rotation');
+            stats.rotations++;
+            if (q.side === 'long') nL--; else nS--;
+          }
+        }
+      }
+      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);
+      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: H }, 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);
+        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];
+        let entryFee = alloc * costOf(i);
+        if (passive) {
+          // пассивная лимитная заявка на своей стороне спреда: исполняется, только если цена свечи t+1 прошла сквозь неё
+          const off = (isT1(i) ? passive.t1Pct : passive.t2Pct) / 100;
+          const lim = side === 'long' ? tk.open[t + 1] * (1 - off) : tk.open[t + 1] * (1 + off);
+          const filled = tk.has[t + 1] && (side === 'long' ? tk.low[t + 1] < lim : tk.high[t + 1] > lim);
+          if (!filled) { stats.missedPassive++; continue; }
+          entryPx = lim;
+          entryFee = alloc * commission;
+        }
+        if (!(entryPx > 0)) continue;
+        equity -= entryFee;
+        avail -= alloc;
+        held.set(i, {
+          i, side, entryT: t + 1, entryPx, alloc, entryFee, peakGain: 0, stopPct, beta: beta[i],
+          thesisPx: thesisStopPx(side, ctx, policy),
+          expectedPct: Math.round(e * 10000) / 100, dayMovePct: Math.round(ctx.dayMovePct * 100) / 100,
+          counterTrend: side === 'short' ? ctx.dayMovePct > 0 : ctx.dayMovePct < 0,
+        });
+        stats.entries++;
+      }
+    }
+
+    // 4) защита фьючерсом: позиция против чистой беты портфеля (в целых контрактах)
+    if (hedge && fut[t] > 0) {
+      let netBeta = 0;
+      for (const q of held.values()) netBeta += (q.side === 'long' ? 1 : -1) * q.beta * q.alloc * (1 + gainOf(q, tokens[q.i].close[t]) * (q.side === 'long' ? 1 : -1));
+      const contractRub = fut[t] * hedgeMult;
+      const target = Math.round(-netBeta / contractRub) * contractRub;
+      if (target !== hedgeRub) {
+        const cost = Math.abs(target - hedgeRub) * (hedge.costPct / 100);
+        equity -= cost;
+        stats.hedgeCost += cost;
+        hedgeRub = target;
+      }
+    }
+    const used = grossUsed(t);
+    stats.exposureSum += used;
+    stats.exposureN++;
+    if (isStep) curve.push({ ts: timeline[t], equity: equity + mtmUnreal(t) });
+  }
+  if (lastT >= 0) {
+    for (const [i, pos] of [...held]) closePos(i, pos, lastT, tokens[i].close[lastT], 'Конец периода', 'end');
+    curve.push({ ts: timeline[lastT], equity });
+  }
+  stats.avgExposurePct = stats.exposureN ? (stats.exposureSum / stats.exposureN / capital) * 100 : 0;
+  return { trades, curve, stats, equity };
+}

package/server/model/walkforward.js

@@ -0,0 +1,59 @@
+// Copyright (c) 2026 Roman A. Perepelkin. All rights reserved. Proprietary software.
+// Пошаговое (walk-forward) обучение одной модели на истории: окно обучения → прогноз 20 дней → сдвиг.
+// Те же фолды, что в research.js, но только для выбранной модели и без телеметрии интерфейса —
+// результат (прогнозы по каждой свече) используется симулятором стратегии (simulator.js) и лабораторией правил.
+import { buildFold, MODELS, FEATURE_WARMUP } from './models.js';
+import { computeTokenEdgeMults } from './edge.js';
+import { barsFromHours } from './dataset.js';
+
+const DAY = 86400000;
+const MSK = 3 * 3600000;
+const EPOCH_ANCHOR_TS = 1718272800000;
+const tick = () => new Promise((r) => setImmediate(r));
+
+export async function computeWalkForward(ds, p, { model = 'attention', tillTs = Date.now(), onProgress = () => {}, signal } = {}) {
+  const autoAdapt = p.modelAutoAdapt !== false;
+  const H = barsFromHours(autoAdapt ? 2.5 : p.modelHorizon);
+  const maxH = autoAdapt ? Math.round(H * 1.4) : H;
+  const { tokens, T, timeline } = ds;
+  const N = tokens.length;
+  const bpd = ds.barsPerDay;
+  const trainLen = Math.round(p.modelTrainDays * bpd);
+  const testLen = Math.round(20 * bpd);
+  const todayStartMsk = Math.floor((tillTs + MSK) / DAY) * DAY - MSK;
+  const rawFrom = todayStartMsk - p.modelHistoryDays * DAY;
+  const gridBlockMs = 20 * DAY;
+  const researchFrom = Math.max(EPOCH_ANCHOR_TS, EPOCH_ANCHOR_TS + Math.round((rawFrom - EPOCH_ANCHOR_TS) / gridBlockMs) * gridBlockMs);
+  let testStart = Math.max(timeline.findIndex((t) => t >= researchFrom), FEATURE_WARMUP + maxH + 100);
+  if (testStart < 0 || testStart >= T - H - 10) throw new Error('Недостаточно истории для пошаговой проверки');
+  const folds = Math.ceil((T - maxH - 2 - testStart) / testLen);
+  const testTs = [];
+  const pred = [];
+  const foldOf = [];
+  const foldSigma = [];
+  const foldBeta = [];
+  const foldMult = [];
+  let fi = 0;
+  while (testStart < T - maxH - 2) {
+    if (signal?.aborted) throw new Error('Отменено');
+    const testEnd = Math.min(testStart + testLen, T - maxH - 2);
+    const trainStart = Math.max(FEATURE_WARMUP + maxH + 2, testStart - trainLen);
+    onProgress({ fold: fi + 1, folds, from: timeline[testStart], till: timeline[testEnd - 1] });
+    await tick();
+    const f = buildFold(ds, { trainStart, testStart, testEnd, H, embedDim: p.modelEmbedDim, textWeight: 0, profiles: null, multiHorizon: autoAdapt });
+    foldSigma.push(Float64Array.from(f.sigma));
+    foldBeta.push(Float64Array.from(f.beta));
+    foldMult.push(computeTokenEdgeMults(tokens, f.sigma, trainStart, testStart));
+    const fitted = await MODELS[model].fit(f);
+    for (let t = testStart; t < testEnd; t++) {
+      const u = t - f.lo;
+      if (!f.yok[u]) continue;
+      testTs.push(t);
+      pred.push(Float32Array.from(MODELS[model].predict(fitted, f, u)));
+      foldOf.push(fi);
+    }
+    testStart = testEnd;
+    fi++;
+  }
+  return { H, N, testTs, pred, foldOf, foldSigma, foldBeta, foldMult };
+}

package/server/strategist/tools.js

@@ -48,6 +48,8 @@ export const TOOLS = {
         режим_старого_портфеля: a.legacyMode || 'isolate',
         лимит_на_стратегию_руб: a.maxCapitalRub,
         дневной_стоп_проц: a.maxDailyDrawdownPct,
+        плечо: a.maxLeverage || 1,
+        стоп_по_общей_просадке_проц: a.maxDrawdownPct || 0,
         отступ_лимитки_проц: a.limitOffsetPct,
         пауза_причина: a.haltedReason || null,
         время_снимка_портфеля_мск: a.lastSync?.at ? fmtBarMsk(a.lastSync.at) : null,