neuroalpha 0.3.17 → 0.5.2

package/server/model/research.js

@@ -7,8 +7,9 @@ import { loadDataset, barsFromHours, BAR_INTERVAL } from './dataset.js';
 import { buildFold, MODELS, modelNames, HEADS, LIQ_MIN, FEATURE_WARMUP, mapSnapshot, alignTo, matchClusters } from './models.js';
 import { ensureProfiles } from './profiles.js';
 import { spearman } from './linalg.js';
-import { listRuns, getRun, createRun, finishRun, saveTrade, saveRunExtra } from '../db.js';
+import { listRuns, getRun, createRun, finishRun, saveTrade, saveRunExtra, kvGet } from '../db.js';
 import { strategyDefaults } from '../config.js';
+import { ENTRY_EDGE_MULT, symbolEdgeMult } from './edge.js';
 
 const DAY = 86400000;
 const MSK = 3 * 3600000;
@@ -152,8 +153,14 @@ async function run(runId, p, state) {
   // чтобы смена «Окна обучения» (modelTrainDays) или «Периода исследования» (modelHistoryDays)
   // НИКОГДА не сдвигала fromTs и не вызывала повторную загрузку котировок!
   const todayStartMsk = Math.floor((tillTs + MSK) / DAY) * DAY - MSK;
-  const researchFrom = todayStartMsk - p.modelHistoryDays * DAY;
-  const fromTs = todayStartMsk - 1650 * DAY;
+  const rawResearchFrom = todayStartMsk - p.modelHistoryDays * DAY;
+  // Стабильная привязка сетки 20-дневных окон переобучения к эпохе (1706165400000 = 25.01.2024):
+  // начало первого фолда выравнивается по 20-дневной сетке, чтобы смена календарного дня запуска НЕ перекраивала всю прошлую 3-летнюю историю фолдов,
+  // а новые торговые дни честно дописывались в правый край последнего фолда!
+  const EPOCH_ANCHOR_TS = 1706165400000;
+  const gridBlockMs = 20 * DAY;
+  const researchFrom = EPOCH_ANCHOR_TS + Math.round((rawResearchFrom - EPOCH_ANCHOR_TS) / gridBlockMs) * gridBlockMs;
+  const fromTs = EPOCH_ANCHOR_TS - 660 * DAY;
 
   emit({ stage: 'data', pct: 0, text: 'Загружаем словарь рынка (состав индекса широкого рынка)…' });
   const ds = await loadDataset({
@@ -249,7 +256,7 @@ async function run(runId, p, state) {
       foldIc,
       pts: ptsRound,
       cl,
-      ...(fi === 0 ? { symbols: tokens.map((tk) => tk.symbol) } : {}),
+      symbols: tokens.map((tk) => tk.symbol),
       ...(attM ? {
         heads: HEADS.map((h, i) => ({ label: h.label, coef: round(attM.coef[i], 4) })),
         self: [round(attM.coef[HEADS.length], 4), round(attM.coef[HEADS.length + 1], 4), round(attM.coef[HEADS.length + 2], 4)],
@@ -293,6 +300,7 @@ async function run(runId, p, state) {
   const mktFilter = p.modelMarketFilter === 'ma';
   const invVol = p.modelAllocMode === 'invvol';
   const realCost = (p.commissionPct + p.slippagePct) / 100;
+  const symMult = Float64Array.from(tokens, (tk) => symbolEdgeMult(tk.symbol));
   const liquid = (i, t) => tokens[i].liq[t] >= LIQ_MIN && tokens[i].open[t + 1] > 0;
   // только покупки: на позицию капитал / K; с продажами: капитал / 2K (покупки и продажи вместе не больше капитала)
   const slots = dir === 'long' ? K : 2 * K;
@@ -324,14 +332,43 @@ async function run(runId, p, state) {
 
     // решение на закрытии свечи t, сделки по цене открытия свечи t+1; сопровождение раз в H/2 свечей (при autoAdapt) или H свечей
     // Плата за заём при продаже — % годовых от суммы позиции за календарное время от входа до выхода
-  function simulate(name, cost, borrowPct = p.modelShortFeePct, startIdx = 0) {
+  // Параметры исполнения для стресс-теста (по умолчанию — как в основном отчёте):
+  //   lag        — через сколько свечей после решения входим/выходим (1 = open[t+1]; 2 = на свечу позже)
+  //   needTrade  — входить только в свечу, где реально были сделки; выход — по первой свече со сделками
+  //   partCap    — позиция не больше этой доли оборота свечи входа (в рублях)
+  //   lots       — только целые лоты
+  //   shortable  — множество бумаг, которые брокер разрешает продавать без покрытия (null — без проверки)
+  function simulate(name, cost, borrowPct = p.modelShortFeePct, startIdx = 0, ex = {}) {
     startIdx = Math.max(0, Math.floor(startIdx));
+    const lag = Math.max(1, Math.floor(ex.lag || 1));
+    const needTrade = Boolean(ex.needTrade);
+    const partCap = Number(ex.partCap) || 0;
+    const useLots = Boolean(ex.lots);
+    const shortable = ex.shortable || null;
+    const midBar = Boolean(ex.midBar);
+    // множитель порога входа и выхода (1 — как в стратегии): проверка «торговать реже, но с запасом над издержками»
+    const needMult = Number(ex.needMult) > 0 ? Number(ex.needMult) : ENTRY_EDGE_MULT;
+    const cashRateAnnual = Number(ex.cashRateAnnual) > 0 ? Number(ex.cashRateAnnual) : 0;
+    const costOf = (i) => (ex.tierCost ? (symMult[i] === 1 ? 0.00065 : 0.00125) : cost);
     let equity = p.capital;
+    let idleShareSum = 0, idleSteps = 0, prevStepTs = tsOf(testTs[startIdx] ?? testTs[0]);
     const curve = [{ ts: tsOf(testTs[startIdx] ?? testTs[0]), equity }];
     const trades = [];
     const held = new Map(); // i -> { side, entryT, entryPrice, alloc, entryCost, expectedPct }
-    let lastOut = (testTs[startIdx] ?? testTs[0]) + 1;
+    let lastOut = (testTs[startIdx] ?? testTs[0]) + lag;
     const px = (i, t) => tokens[i].open[t];
+    // цена исполнения: open свечи или (midBar) средняя цена свечи — заявка исполняется где-то внутри неё, а не на первой сделке
+    const fillPx = (i, t) => {
+      const o = tokens[i].open[t], c = tokens[i].close[t];
+      return midBar && o > 0 && c > 0 ? (o + c) / 2 : o;
+    };
+    // выход по первой свече со сделками (не дальше maxH свечей), иначе — по расчётной цене этой свечи
+    const exitPx = (i, t) => {
+      if (!needTrade) return fillPx(i, t);
+      const lim = Math.min(T - 1, t + maxH);
+      for (let k = t; k <= lim; k++) if (tokens[i].has[k] && tokens[i].open[k] > 0) return fillPx(i, k);
+      return fillPx(i, t);
+    };
     const borrowFee = (h, t) => h.alloc * (borrowPct / 100) * ((tsOf(t) - tsOf(h.entryT)) / 3600000 / 24 / 365);
     const countSide = (side) => [...held.values()].filter((h) => h.side === side).length;
     // Самообучение правил по прошлым закрытым сделкам (временный карантин «акций-убийц» с затуханием и авто-калибровка порога выхода)
@@ -341,16 +378,17 @@ async function run(runId, p, state) {
     const stepBars = autoAdapt ? Math.max(3, Math.floor(H / 5)) : H;
     const maxSlotWeight = dir === 'long' ? Math.min(0.58, Math.max(1 / K, 1.8 / K)) : Math.min(0.75, 3.0 / (2 * K));
 
-    const closePos = (i, h, t, end, why) => {
-      const exitPrice = px(i, t);
+    const closePos = (i, h, t, end, why, forcedExitPrice = null) => {
+      const exitPrice = forcedExitPrice > 0 ? forcedExitPrice : exitPx(i, t);
       let gross, fee, borrow = 0;
+      const c = costOf(i);
       if (h.side === 'short') {
         gross = h.alloc * (1 - exitPrice / h.entryPrice);
-        fee = (h.alloc - gross) * cost;
+        fee = (h.alloc - gross) * c;
         borrow = borrowFee(h, t);
       } else {
         gross = h.alloc * (exitPrice / h.entryPrice - 1);
-        fee = (h.alloc + gross) * cost;
+        fee = (h.alloc + gross) * c;
       }
       equity += gross - fee - borrow;
       trades.push(tradeRec(name, i, h, t, exitPrice, gross - fee - borrow - h.entryCost, h.entryCost + fee, borrow, end, why));
@@ -364,7 +402,7 @@ async function run(runId, p, state) {
     };
     for (let k = startIdx; k < testTs.length; k += stepBars) {
       const t = testTs[k];
-      const tIn = t + 1, tOut = Math.min(t + 1 + stepBars, T - 1);
+      const tIn = Math.min(t + lag, T - 1), tOut = Math.min(t + lag + stepBars, T - 1);
       if (autoAdapt) {
         for (let i = 0; i < N; i++) { stockPnl[i] *= 0.99; stockCnt[i] *= 0.99; }
       }
@@ -375,20 +413,38 @@ async function run(runId, p, state) {
       let order, entries;
       if (dir !== 'long') {
         const edge = (i) => pr[i] * sg[i] * Math.sqrt(H);
-        const need = effMinEdge * 2 * realCost;
+        const need = effMinEdge * 2 * realCost * needMult;
         const exitNeed = need * curExitRatio;
         const earlyExitNeed = need * 0.35;
         // держим позицию, пока ожидаемое движение выше порога выхода (первые два полушага — мягкий порог, чтобы не резать сделку от шума)
         for (const [i, h] of [...held]) {
           const e = edge(i);
           const barsHeld = tIn - h.entryT;
-          const req = autoAdapt && barsHeld <= 2 * stepBars ? earlyExitNeed : exitNeed;
+          const req = (autoAdapt && barsHeld <= 2 * stepBars ? earlyExitNeed : exitNeed) * symMult[i];
           if (!(h.side === 'long' ? e > req : e < -req) || !liquid(i, t)) closePos(i, h, tIn, false, 'Прогноз ослаб');
         }
         const needL = autoAdapt && bear ? need * 1.25 : need;
         const needS = autoAdapt ? (bear ? need * 0.90 : need * 1.25) : need;
-        const candL = mktDown ? [] : [...pr.keys()].filter((i) => !held.has(i) && stockAllowed(i) && liquid(i, t) && edge(i) > needL).sort((a, b) => pr[b] - pr[a]);
-        const candS = [...pr.keys()].filter((i) => !held.has(i) && stockAllowed(i) && liquid(i, t) && edge(i) < -needS).sort((a, b) => pr[a] - pr[b]);
+        const candL = mktDown ? [] : [...pr.keys()].filter((i) => !held.has(i) && stockAllowed(i) && liquid(i, t) && edge(i) > needL * symMult[i]).sort((a, b) => pr[b] - pr[a]);
+        const candS = [...pr.keys()].filter((i) => !held.has(i) && stockAllowed(i) && liquid(i, t) && edge(i) < -needS * symMult[i]).sort((a, b) => pr[a] - pr[b]);
+        // Вытеснение слабой/остывшей позиции новым мощным лидером (Opportunity Rotation):
+        // если капитал заперт в позиции с ослабевшим ожиданием (< 0.55 * exitNeed), а на текущей свече появился лидер в 2.4 раза сильнее порога,
+        // освобождаем слот под лидера, чтобы ни одна фаза не застревала в слабых бумагах
+        const usedNow = [...held.values()].reduce((s, h) => s + h.alloc, 0);
+        if (autoAdapt && usedNow > equity * 0.65 && (candL.length > 0 || candS.length > 0)) {
+          const bestNewEdge = Math.max(candL.length ? edge(candL[0]) : 0, candS.length ? Math.abs(edge(candS[0])) : 0);
+          if (bestNewEdge >= need * 2.2) {
+            let weakestIdx = -1, weakestE = Infinity;
+            for (const [i, h] of held) {
+              const curSignedE = h.side === 'long' ? edge(i) : -edge(i);
+              if (curSignedE < exitNeed * 0.60 && curSignedE < weakestE && bestNewEdge > Math.max(need, curSignedE) * 2.4) {
+                weakestE = curSignedE;
+                weakestIdx = i;
+              }
+            }
+            if (weakestIdx >= 0) closePos(weakestIdx, held.get(weakestIdx), tIn, false, 'Ротация в более сильного лидера');
+          }
+        }
         const nL = K - countSide('long');
         const nS = K - countSide('short');
         const pickedL = filterDynamicTopK(candL, edge, needL, Math.max(0, nL));
@@ -400,18 +456,18 @@ async function run(runId, p, state) {
       } else if (effMinEdge > 0) {
         // ожидаемое движение (в долях) = прогноз × обычный размах × √H; входим, только если оно окупает сделку
         const edge = (i) => pr[i] * sg[i] * Math.sqrt(H);
-        const need = effMinEdge * 2 * realCost;
+        const need = effMinEdge * 2 * realCost * needMult;
         const exitNeed = need * curExitRatio;
         const earlyExitNeed = need * 0.35;
         for (const [i, h] of [...held]) {
           const e = edge(i);
           const barsHeld = tIn - h.entryT;
-          const req = autoAdapt && barsHeld <= 2 * stepBars ? earlyExitNeed : exitNeed;
+          const req = (autoAdapt && barsHeld <= 2 * stepBars ? earlyExitNeed : exitNeed) * symMult[i];
           if (!(e > req) || !liquid(i, t)) closePos(i, h, tIn, false);
         }
         const free = K - held.size;
         const needL = autoAdapt && bear ? need * 1.25 : need;
-        const rawCand = mktDown ? [] : [...pr.keys()].filter((i) => !held.has(i) && stockAllowed(i) && liquid(i, t) && edge(i) > needL).sort((a, b) => pr[b] - pr[a]);
+        const rawCand = mktDown ? [] : [...pr.keys()].filter((i) => !held.has(i) && stockAllowed(i) && liquid(i, t) && edge(i) > needL * symMult[i]).sort((a, b) => pr[b] - pr[a]);
         const cand = filterDynamicTopK(rawCand, edge, needL, Math.max(0, free));
         order = [...held.keys(), ...cand];
       } else {
@@ -430,7 +486,7 @@ async function run(runId, p, state) {
       }
       const usedStart = [...held.values()].reduce((s, h) => s + h.alloc, 0);
       let avail = Math.max(0, equity * 0.99 - usedStart);
-      const needEdge = effMinEdge * 2 * realCost;
+      const needEdge = effMinEdge * 2 * realCost * needMult;
       // Динамическая концентрация капитала под реально работающие позиции:
       // если при K=5 на рынке есть всего 1–2 сильных сигнала, не замораживаем 60% денег в кэше под пустые слоты,
       // а взвешиваем слот от фактического числа занятых + новых позиций и силы каждого сигнала (Conviction Sizing)
@@ -450,6 +506,8 @@ async function run(runId, p, state) {
       for (let idx = 0; idx < newEntries.length; idx++) {
         const [i, side, edgeAt] = newEntries[idx];
         const effEdge = edgeWeights[idx];
+        if (side === 'short' && shortable && !shortable.has(tokens[i].symbol)) continue;
+        if (needTrade && !(tokens[i].has[tIn] && tokens[i].open[tIn] > 0)) continue;
         const conv = autoAdapt && needEdge > 0 && effEdge > 0 ? Math.min(1.65, Math.max(0.85, 0.80 + 0.30 * (effEdge / needEdge))) : 1;
         const propShare = autoAdapt && remWeightSum > 0 ? avail * (effEdge / remWeightSum) : avail / Math.max(1, newEntries.length - idx);
         remWeightSum = Math.max(0, remWeightSum - effEdge);
@@ -459,12 +517,29 @@ async function run(runId, p, state) {
           const w = Math.max(0.4, Math.min(1.8, (1 / sg[i]) / avgInv));
           alloc = Math.min(baseAlloc * w, avail / Math.max(1, newEntries.length - idx));
         }
+        // не больше заданной доли реального оборота свечи входа
+        if (partCap > 0) alloc = Math.min(alloc, partCap * (tokens[i].value[tIn] || 0));
+        // только целые лоты
+        if (useLots) {
+          const lotRub = (lotSizeOf(tokens[i].symbol) || 1) * px(i, tIn);
+          alloc = lotRub > 0 ? Math.floor(alloc / lotRub) * lotRub : 0;
+        }
         if (!(alloc > 1000)) continue;
         avail = Math.max(0, avail - alloc);
-        const fee = alloc * cost;
+        const fee = alloc * costOf(i);
         equity -= fee;
-        held.set(i, { side, entryT: tIn, entryPrice: px(i, tIn), alloc, entryCost: fee, expectedPct: edgeAt === null ? null : round(edgeAt * 100, 3) });
+        held.set(i, { side, entryT: tIn, entryPrice: fillPx(i, tIn), alloc, entryCost: fee, expectedPct: edgeAt === null ? null : round(edgeAt * 100, 3) });
+      }
+      const usedAfter = [...held.values()].reduce((s, h) => s + h.alloc, 0);
+      const idleCash = Math.max(0, equity - usedAfter);
+      idleShareSum += equity > 0 ? idleCash / equity : 0;
+      idleSteps++;
+      const curStepTs = tsOf(tOut);
+      if (cashRateAnnual > 0 && curStepTs > prevStepTs && idleCash > 0) {
+        const dtYears = Math.min(4 / 365, (curStepTs - prevStepTs) / (365.25 * 86400000));
+        equity += idleCash * cashRateAnnual * dtYears;
       }
+      prevStepTs = curStepTs;
       let mtm = 0;
       for (const [i, h] of held) {
         mtm += h.side === 'short' ? h.alloc * (1 - px(i, tOut) / h.entryPrice) - borrowFee(h, tOut) : h.alloc * (px(i, tOut) / h.entryPrice - 1);
@@ -478,7 +553,7 @@ async function run(runId, p, state) {
       exitRatio: curExitRatio,
       quarantined: tokens.map((tk, i) => (!stockAllowed(i) ? tk.symbol : null)).filter(Boolean),
     } : null;
-    return { trades, curve, adaptation };
+    return { trades, curve, adaptation, idleCashPct: round((idleShareSum / Math.max(1, idleSteps)) * 100, 1) };
   }
   function tradeRec(name, i, h, t, exitPrice, pnl, commission, borrow, end = false, why = '') {
     const heldMin = (t - h.entryT) * BAR_INTERVAL; // минуты
@@ -523,8 +598,10 @@ async function run(runId, p, state) {
     await tick();
     const gross = simulate(n, 0, 0);
     const grossReport = computeReport(gross.trades, gross.curve, p.capital, p.oosPct);
+    const liveSim = simulate(n, 0.001, p.modelShortFeePct, 0, { midBar: true, needTrade: true, partCap: 0.05, lots: true, shortable: shortableSet(), tierCost: true });
+    const liveReport = computeReport(liveSim.trades, liveSim.curve, p.capital, p.oosPct);
     splitTs = report.splitTs;
-    results[n] = { sim, report, grossReport, gross };
+    results[n] = { sim, report, grossReport, gross, liveSim, liveReport };
   }
   const segRet = (curve, a, b) => {
     const seg = curve.filter((x) => x.ts >= a && x.ts <= b);
@@ -584,6 +661,8 @@ async function run(runId, p, state) {
         longPct: sidePct('long'), shortPct: sidePct('short'),
         ic: ic.seg[k].ic, weeksPositivePct: ic.seg[k].weeksPositivePct, weeks: ic.seg[k].weeks,
         returnPct: m?.returnPct ?? null, grossReturnPct: (results[n].grossReport[k] || results[n].grossReport.full)?.returnPct ?? null,
+        realisticReturnPct: (results[n].liveReport?.[k] || results[n].liveReport?.full)?.returnPct ?? null,
+        realisticProfitFactor: (results[n].liveReport?.[k] || results[n].liveReport?.full)?.profitFactor ?? null,
         marketPct: round(mret, 2), vsMarketPct: m ? round(m.returnPct - mret, 2) : null,
         trades: m?.trades ?? 0, profitFactor: m?.profitFactor ?? null, maxDrawdownPct: m?.maxDrawdownPct ?? null, winRate: m?.winRate ?? null,
       };
@@ -596,6 +675,8 @@ async function run(runId, p, state) {
   const report = results[chosen].report;
   report.period = { from: tsOf(testTs[0]), till: tsOf(testTs[testTs.length - 1]) };
   report.bars = testTs.length;
+  // итог стресс-теста в метриках прогона (сводка для списка экспериментов); подробности — в extra.stress
+  report.stressPending = true;
   report.model = { chosen, horizon: H, tokens: N, folds: fi, comparison: Object.fromEntries(names.map((n) => [n, comparison[n]])) };
 
   // «головы внимания» последнего окна обучения — что модель считает важным
@@ -606,9 +687,11 @@ async function run(runId, p, state) {
   const macroHeads = (att.macroHeads || []).map((h) => ({ label: h.label, coef: round(h.coef, 4) }));
   const neighbors = tokens.map((_, j) => [...lastFold.cos[j].keys()].filter((i) => i !== j).sort((a, b) => lastFold.cos[j][b] - lastFold.cos[j][a]).slice(0, 6).map((i) => [i, round(lastFold.cos[j][i], 3)]));
 
-  // Быстрая проверка устойчивости по сдвигам точки пересмотра и старта (на готовых прогнозах, без переобучения)
-  const bpdInt = Math.max(1, Math.round(bpd));
-  const offsets = [...new Set([0, Math.max(1, Math.floor(H / 3)), Math.max(2, Math.floor((2 * H) / 3)), bpdInt * 2, bpdInt * 4].filter((o) => o < Math.min(testTs.length / 4, bpdInt * 10)))];
+  // Быстрая проверка устойчивости по сдвигам точки пересмотра и старта (на готовых прогнозах, без переобучения):
+  // dayShift2 и dayShift4 кратны stepBars, чтобы сдвиги дней проверяли устойчивость к дате начала, а фазы +10м/+20м — к внутричасовой минуте!
+  const stepBarsForStab = autoAdapt ? Math.max(3, Math.floor(H / 5)) : H;
+  const bpdAligned = Math.max(stepBarsForStab, Math.round(bpd / stepBarsForStab) * stepBarsForStab);
+  const offsets = [...new Set([0, 1, 2, bpdAligned * 2, bpdAligned * 4].filter((o) => o < Math.min(testTs.length / 4, bpdAligned * 10)))];
   const stabRuns = [];
   for (let idx = 0; idx < offsets.length; idx++) {
     const off = offsets[idx];
@@ -624,6 +707,10 @@ async function run(runId, p, state) {
   }
   const stability = summarizeStability(stabRuns, 'phase');
 
+  emit({ stage: 'calc', pct: 96, text: 'Финальный пересчёт · стресс-тест исполнения (издержки, задержка входа, ликвидность, лоты, шорты)…' });
+  await tick();
+  const stress = runStressTest({ simulate, chosen, testTs, tsOf, mcurve, p, H });
+
   emit({ stage: 'calc', pct: 98, text: `Финальный пересчёт · запись ${results[chosen].sim.trades.length} сделок и кривых капитала в базу…` });
   await tick();
   const chosenTrades = results[chosen].sim.trades;
@@ -640,6 +727,7 @@ async function run(runId, p, state) {
     comparison, splitTs,
     adaptation: results[chosen].sim.adaptation || null,
     stability,
+    stress,
     periods: buildPeriods({
       model: results[chosen].sim.curve, gross: results[chosen].gross.curve, market: mcurve,
       models: Object.fromEntries(names.map((n) => [n, results[n].sim.curve])),
@@ -650,10 +738,110 @@ async function run(runId, p, state) {
     map: { snapshots, eigenvalues: lastFold.eigenvalues.map((v) => round(v, 3)) },
     neighbors,
   });
+  delete report.stressPending;
+  const realistic = stress.scenarios.find((s) => s.key === 'realistic');
+  report.stress = realistic ? { returnPct: realistic.full.returnPct, cagrPct: realistic.full.cagrPct, profitFactor: realistic.full.profitFactor, maxDrawdownPct: realistic.full.maxDrawdownPct, last12Pct: realistic.last12.returnPct } : null;
   finishRun(runId, { metrics: report, equity: downsample(results[chosen].sim.curve) });
   return report;
 }
 
+// ---------- стресс-тест исполнения ----------
+// Та же стратегия и те же правила решений, но с реалистичным исполнением. Показывает, какая часть доходности
+// бэктеста держится на допущениях (дешёвые сделки, вход по цене самого сигнала, неограниченная ликвидность, шорт всего подряд).
+const lotSizeCache = { at: 0, map: {} };
+function lotSizeOf(sym) {
+  if (Date.now() - lotSizeCache.at > 3600000) {
+    lotSizeCache.map = kvGet('moexSpecs')?.specs || {};
+    lotSizeCache.at = Date.now();
+  }
+  return Number(lotSizeCache.map[sym]?.lotSize) || 1;
+}
+
+function shortableSet() {
+  const m = kvGet('tbankShortableMap')?.map;
+  if (!m || typeof m !== 'object') return null;
+  const s = new Set(Object.entries(m).filter(([, v]) => v === true || v?.shortEnabled || v?.short === true).map(([k]) => k));
+  return s.size ? s : null;
+}
+
+function runStressTest({ simulate, chosen, testTs, tsOf, mcurve, p, H }) {
+  const shortable = shortableSet();
+  const lastTs = tsOf(testTs[testTs.length - 1]);
+  const yearsOf = (curve) => Math.max(1 / 365, ((curve.at(-1)?.ts || 0) - (curve[0]?.ts || 0)) / (365.25 * 86400000));
+  const cagr = (ret, yrs) => (ret > -100 && yrs >= 0.25 ? round((Math.pow(1 + ret / 100, 1 / yrs) - 1) * 100, 1) : null);
+  const segment = (sim, fromTs) => {
+    const curve = sim.curve.filter((x) => x.ts >= fromTs);
+    if (curve.length < 2) return { returnPct: null, trades: 0 };
+    const m = computeReport(sim.trades.filter((t) => t.entryTs >= fromTs), curve, curve[0].equity, 0).full;
+    return { returnPct: m.returnPct, profitFactor: m.profitFactor, maxDrawdownPct: m.maxDrawdownPct, trades: m.trades };
+  };
+  const mSeg = (fromTs) => {
+    const c = mcurve.filter((x) => x.ts >= fromTs);
+    return c.length > 1 ? round((c.at(-1).equity / c[0].equity - 1) * 100, 2) : null;
+  };
+  const base = (p.commissionPct + p.slippagePct) / 100;
+  const REAL = { lag: 2, needTrade: true, partCap: 0.05, lots: true, shortable };
+  const LIVE = { midBar: true, needTrade: true, partCap: 0.05, lots: true, shortable };
+  const scenarios = [
+    { key: 'base', label: 'Как в основном отчёте', note: `издержки ${round(base * 100, 3)}% на сторону, вход по open следующей свечи`, cost: base, ex: {} },
+    { key: 'cost15', label: 'Издержки 0,15% на сторону', note: 'комиссия + спред + проскальзывание для второго-третьего эшелона', cost: 0.0015, ex: {} },
+    { key: 'mid1', label: 'Вход внутри следующей свечи', note: 'средняя цена (open+close)/2 свечи t+1: заявка по живой цене исполняется в течение свечи, а не на её первой сделке', cost: base, ex: { midBar: true } },
+    { key: 'lag2', label: 'Вход на свечу позже', note: 'open[t+2]: данные приходят с задержкой 10+ минут (ISS без живых цен брокера)', cost: base, ex: { lag: 2 } },
+    { key: 'trades', label: 'Только свечи со сделками', note: 'без входа по «цене», которой не было (свеча без сделок = цена закрытия предыдущей)', cost: base, ex: { needTrade: true } },
+    { key: 'liquidity', label: '≤ 5% оборота свечи и целые лоты', note: 'позиция не больше 5% реального оборота свечи входа', cost: base, ex: { partCap: 0.05, lots: true } },
+    { key: 'shorts', label: 'Шорт только разрешённых бумаг', note: shortable ? `по текущему списку Т-Банка (${shortable.size} бумаг)` : 'список Т-Банка не загружен — проверка не выполнена', cost: base, ex: { shortable } },
+    { key: 'liveLike', label: 'Как живой контур (внутри свечи), издержки как в отчёте', note: 'живые цены брокера: вход внутри следующей свечи + сделки, оборот, лоты, шорты', cost: base, ex: LIVE },
+    { key: 'liveLike10', label: 'Как живой контур, издержки 0,10%', note: 'то же при издержках 0,10% на сторону (комиссия 0,05% + спред/проскальзывание 0,05%)', cost: 0.001, ex: LIVE },
+    { key: 'liveTierLqdt', label: 'Живой контур + издержки по эшелонам + свободный кэш в LQDT (16%/год)', note: 'издержки 0,065% 1-й эшелон и 0,125% 2–3-й эшелон + начисление ставки денежного рынка на незанятые рубли (~95% времени)', cost: 0.001, ex: { ...LIVE, tierCost: true, cashRateAnnual: 0.16 } },
+    { key: 'execOnly', label: 'Всё вместе, издержки как в отчёте', note: 'задержка, сделки, оборот, лоты и шорты — без роста издержек', cost: base, ex: REAL },
+    { key: 'realistic', label: 'Всё вместе, издержки 0,15%', note: 'реалистичная оценка', cost: 0.0015, ex: REAL },
+    { key: 'harsh', label: 'Всё вместе, издержки 0,25%', note: 'пессимистичная оценка', cost: 0.0025, ex: REAL },
+  ];
+  const out = [];
+  for (const s of scenarios) {
+    const sim = simulate(chosen, s.cost, p.modelShortFeePct, 0, s.ex);
+    const full = computeReport(sim.trades, sim.curve, p.capital, 0).full;
+    const yrs = yearsOf(sim.curve);
+    const longPnl = sim.trades.filter((t) => t.side === 'long').reduce((a, t) => a + t.pnl, 0);
+    const shortPnl = sim.trades.filter((t) => t.side === 'short').reduce((a, t) => a + t.pnl, 0);
+    out.push({
+      key: s.key, label: s.label, note: s.note,
+      full: { returnPct: full.returnPct, cagrPct: cagr(full.returnPct, yrs), profitFactor: full.profitFactor, maxDrawdownPct: full.maxDrawdownPct, trades: full.trades, winRate: full.winRate, avgTradePct: full.avgTradePct, longPnl: round(longPnl, 0), shortPnl: round(shortPnl, 0) },
+      last12: segment(sim, lastTs - 365 * 86400000),
+      last6: segment(sim, lastTs - 182 * 86400000),
+    });
+  }
+  // Порог безубыточности: при каких издержках на сторону итог за период равен нулю (итог монотонно падает с ростом издержек)
+  const breakEven = (ex) => {
+    let lo = 0, hi = 0.01;
+    const retAt = (c) => { const s = simulate(chosen, c, p.modelShortFeePct, 0, ex); return computeReport(s.trades, s.curve, p.capital, 0).full.returnPct; };
+    if (retAt(lo) <= 0) return 0;
+    for (let k = 0; k < 9; k++) {
+      const mid = (lo + hi) / 2;
+      if (retAt(mid) > 0) lo = mid; else hi = mid;
+    }
+    return round(((lo + hi) / 2) * 100, 3);
+  };
+  // Подбор порога входа под реальные издержки: живое исполнение, издержки 0,09% на сторону (комиссия 0,04% + проскальзывание ~0,05%)
+  const thresholdSweep = [1, 1.5, 1.65, 2, 2.5, 3].map((m) => {
+    const sim = simulate(chosen, 0.0009, p.modelShortFeePct, 0, { ...LIVE, needMult: m });
+    const f = computeReport(sim.trades, sim.curve, p.capital, 0).full;
+    return { needMult: m, current: m === ENTRY_EDGE_MULT, entryEdgePct: round(2.5 * 2 * base * m * 100, 3), returnPct: f.returnPct, cagrPct: cagr(f.returnPct, yearsOf(sim.curve)), profitFactor: f.profitFactor, maxDrawdownPct: f.maxDrawdownPct, trades: f.trades, avgTradePct: f.avgTradePct, last12Pct: segment(sim, lastTs - 365 * 86400000).returnPct, last6Pct: segment(sim, lastTs - 182 * 86400000).returnPct };
+  });
+  return {
+    scenarios: out,
+    thresholdSweep,
+    breakEvenCostPct: { asReport: breakEven({}), liveLike: breakEven(LIVE), realisticExecution: breakEven(REAL) },
+    market: { full: mSeg(-Infinity), last12: mSeg(lastTs - 365 * 86400000), last6: mSeg(lastTs - 182 * 86400000) },
+    shortableKnown: Boolean(shortable),
+    caveats: [
+      'Состав рынка — сегодняшний индекс широкого рынка, бумаги отобраны по покрытию данных за весь период (ошибка выжившего не устранена).',
+      'Константы стратегии подбирались на этой же истории, поэтому «последние 6 и 12 месяцев» не являются честно отложенной выборкой. Честная проверка — торговля после фиксации версии.',
+      'Список бумаг для шорта — текущий, а не на каждую дату.',
+    ],
+  };
+}
+
 function summarizeStability(runs, mode = 'shifts') {
   const rets = runs.map((r) => r.returnPct).sort((a, b) => a - b);
   const med = rets.length % 2 ? rets[(rets.length - 1) >> 1] : (rets[(rets.length >> 1) - 1] + rets[rets.length >> 1]) / 2;
@@ -797,18 +985,18 @@ async function runStabilityLoop(targetId, runRow, st) {
         const bear = isMarketDown(ds, t);
         const mktDown = mktFilter && bear;
         const edge = (i) => pr[i] * sg[i] * Math.sqrt(H);
-        const need = effMinEdge * 2 * realCost, exitNeed = need * curExitRatio, earlyExitNeed = need * 0.35;
+        const need = effMinEdge * 2 * realCost * ENTRY_EDGE_MULT, exitNeed = need * curExitRatio, earlyExitNeed = need * 0.35;
         let order, entries;
         if (dir !== 'long') {
           for (const [i, h] of [...held]) {
             const e = edge(i), barsHeld = tIn - h.entryT;
-            const req = autoAdapt && barsHeld <= 2 * stepBars ? earlyExitNeed : exitNeed;
+            const req = (autoAdapt && barsHeld <= 2 * stepBars ? earlyExitNeed : exitNeed) * symbolEdgeMult(tokens[i].symbol);
             if (!(h.side === 'long' ? e > req : e < -req) || !liquid(i, t)) closePos(i, h, tIn);
           }
           const needL = autoAdapt && bear ? need * 1.25 : need;
           const needS = autoAdapt ? (bear ? need * 0.90 : need * 1.25) : need;
-          const candL = mktDown ? [] : [...pr.keys()].filter((i) => !held.has(i) && stockAllowed(i) && liquid(i, t) && edge(i) > needL).sort((a, b) => pr[b] - pr[a]);
-          const candS = [...pr.keys()].filter((i) => !held.has(i) && stockAllowed(i) && liquid(i, t) && edge(i) < -needS).sort((a, b) => pr[a] - pr[b]);
+          const candL = mktDown ? [] : [...pr.keys()].filter((i) => !held.has(i) && stockAllowed(i) && liquid(i, t) && edge(i) > needL * symbolEdgeMult(tokens[i].symbol)).sort((a, b) => pr[b] - pr[a]);
+          const candS = [...pr.keys()].filter((i) => !held.has(i) && stockAllowed(i) && liquid(i, t) && edge(i) < -needS * symbolEdgeMult(tokens[i].symbol)).sort((a, b) => pr[a] - pr[b]);
           const nL = K - countSide('long'), nS = K - countSide('short');
           entries = [...candL.slice(0, Math.max(0, nL)).map((i) => [i, 'long', edge(i)]), ...candS.slice(0, Math.max(0, nS)).map((i) => [i, 'short', edge(i)])];
         } else if (effMinEdge > 0) {

package/server/notify/index.js

@@ -1,10 +1,10 @@
 // Copyright (c) 2026 Roman A. Perepelkin. All rights reserved. Proprietary software.
 import crypto from 'node:crypto';
 import https from 'node:https';
-import fs from 'node:fs';
-import path from 'node:path';
-import tls from 'node:tls';
-import { ROOT } from '../config.js';
+import { TRUSTED_CA } from '../tls-ca.js';
+import { IS_INSTANCE } from '../role.js';
+import { getIdentity } from '../instance/identity.js';
+import { relayNotifyToCentral } from '../instance/agent.js';
 import { db, kvGet, kvSet } from '../db.js';
 import { encryptSecret, decryptSecret, getUserById, runWithUser, generateApiKey, hashPassword, ensureApiKey } from '../auth/index.js';
 import { round } from '../util.js';
@@ -13,11 +13,7 @@ let actionHandlers = { execute: null, reject: null };
 export function registerBrokerHandlers(h) { actionHandlers = h; }
 
 // Надёжный HTTP-клиент для platform-api2.max.ru (поддерживает сертификат НУЦ Минцифры РФ)
-let maxCa = undefined;
-try {
-  const certPath = process.env.GIGACHAT_CA_FILE || path.resolve(ROOT, '../work/#system/certs/russian_trusted_root_ca.pem');
-  if (fs.existsSync(certPath)) maxCa = [...tls.rootCertificates, fs.readFileSync(certPath, 'utf8')];
-} catch { /* ignore */ }
+const maxCa = TRUSTED_CA;
 
 function maxRequest(urlPath, { method = 'GET', token = '', body = null, timeoutMs = 12000 } = {}) {
   return new Promise((resolve, reject) => {
@@ -29,7 +25,7 @@ function maxRequest(urlPath, { method = 'GET', token = '', body = null, timeoutM
       path: u.pathname + u.search,
       method,
       ca: maxCa,
-      rejectUnauthorized: Boolean(maxCa),
+      rejectUnauthorized: true,
       headers: {
         Authorization: token,
         Accept: 'application/json',
@@ -171,6 +167,14 @@ export async function sendMax(chatId, text, buttons = null) {
 }
 
 export async function notifyUser(userId, text, buttons = null) {
+  // На машине клиента ботов нет: текст и кнопки уходят в центр, а центр пишет клиенту в его Telegram / MAX.
+  // Нажатие кнопки центр возвращает машине командой внутри подписанной лицензии.
+  if (IS_INSTANCE) {
+    const termUrl = getIdentity().url;
+    const relayButtons = (buttons || []).filter((b) => b.action && b.accountId).map((b) => ({ label: b.label, action: b.action, accountId: b.accountId, batchId: b.batchId || '' }));
+    const hint = buttons?.length ? `\n\nПодтвердите кнопкой ниже или в терминале${termUrl ? `: ${termUrl}` : ' на вашем компьютере'}.` : '';
+    return relayNotifyToCentral(`${text}${hint}`, relayButtons);
+  }
   const u = getUserById(userId);
   if (!u) return { tg: false, max: false };
   const [tg, max] = await Promise.all([
@@ -185,8 +189,8 @@ export async function notifyBrokerBatch(userId, acc, batch) {
   const lines = batch.orders.map((o) => `• ${o.action === 'buy' ? 'Купить' : 'Продать'} ${o.symbol}: ${o.lots} л. (${o.shares} шт.) по ${o.limitPrice} ₽ ≈ ${round(o.amountRub, 0)} ₽`);
   const text = `НейроАльфа · Счёт «${acc.name}»\nСформирован пакет лимитных заявок (свеча ${batch.bar || '—'}):\n${lines.join('\n')}`;
   const buttons = acc.mode === 'confirm' ? [
-    { label: `✓ Исполнить (${batch.orders.length})`, data: `exec:${userId}:${acc.id}` },
-    { label: '✕ Отклонить', data: `rej:${userId}:${acc.id}` },
+    { label: `✓ Исполнить (${batch.orders.length})`, data: `exec:${userId}:${acc.id}`, action: 'exec', accountId: acc.id, batchId: batch.id || '' },
+    { label: '✕ Отклонить', data: `rej:${userId}:${acc.id}`, action: 'rej', accountId: acc.id, batchId: batch.id || '' },
   ] : null;
   await notifyUser(userId, text, buttons);
 }
@@ -202,10 +206,29 @@ function tryLinkByCode(text, channel, chatId) {
   return u;
 }
 
-async function handleCallbackAction(data, replyFn) {
+// Центр: обработчик кнопок, пришедших с машин клиентов (данные вида «ix:<одноразовый id>»)
+let instanceActionHandler = null;
+export function registerInstanceActionHandler(fn) { instanceActionHandler = fn; }
+
+async function handleCallbackAction(data, replyFn, { channel, chatId } = {}) {
+  if (String(data || '').startsWith('ix:')) {
+    if (!instanceActionHandler) return;
+    try {
+      await replyFn(await instanceActionHandler(String(data).slice(3), { channel, chatId }));
+    } catch (e) {
+      await replyFn(`Ошибка: ${e.message}`);
+    }
+    return;
+  }
   const [act, uidStr, accId] = String(data || '').split(':');
   const u = getUserById(Number(uidStr));
   if (!u || !accId) return;
+  // Кнопка должна прийти из того же чата, который привязан к владельцу счёта (данные кнопки можно подделать)
+  const boundChat = channel === 'max' ? u.max_chat_id : u.tg_chat_id;
+  if (!boundChat || !chatId || String(boundChat) !== String(chatId)) {
+    await replyFn('⛔ Это действие доступно только из чата, привязанного к владельцу счёта.');
+    return;
+  }
   try {
     if (act === 'exec' && actionHandlers.execute) {
       await runWithUser(u, () => actionHandlers.execute(accId));
@@ -250,7 +273,10 @@ async function pollTelegram() {
         }
       } else if (upd.callback_query?.data) {
         const chatId = upd.callback_query.message?.chat?.id;
-        await handleCallbackAction(upd.callback_query.data, (msg) => sendTelegram(chatId, msg));
+        const fromId = upd.callback_query.from?.id;
+        // в личном чате с ботом id чата совпадает с id нажавшего пользователя
+        const verifiedChat = chatId && fromId && String(chatId) === String(fromId) ? chatId : null;
+        await handleCallbackAction(upd.callback_query.data, (msg) => sendTelegram(chatId, msg), { channel: 'tg', chatId: verifiedChat });
       }
     }
   } catch { /* ignore */ }
@@ -274,11 +300,19 @@ async function processMaxUpdate(upd) {
   }
   if (upd.callback?.payload) {
     const cbChatId = upd.chat_id || upd.message?.recipient?.chat_id || upd.callback?.user?.user_id;
-    await handleCallbackAction(upd.callback.payload, (msg) => sendMax(cbChatId, msg));
+    await handleCallbackAction(upd.callback.payload, (msg) => sendMax(cbChatId, msg), { channel: 'max', chatId: cbChatId });
   }
 }
 
-export async function handleMaxWebhook(body = {}) {
+// Вебхук MAX принимается только с секретом (заголовок X-Max-Bot-Api-Secret = MAX_WEBHOOK_SECRET).
+// Без настроенного секрета вебхук выключен — обновления MAX забираются опросом (pollMax).
+export async function handleMaxWebhook(body = {}, headers = {}) {
+  const secret = String(process.env.MAX_WEBHOOK_SECRET || '').trim();
+  const got = String(headers['x-max-bot-api-secret'] || '').trim();
+  const a = Buffer.from(got);
+  const b = Buffer.from(secret);
+  const okSecret = secret && a.length === b.length && crypto.timingSafeEqual(a, b);
+  if (!okSecret) throw Object.assign(new Error('Вебхук MAX отключён или секрет неверен'), { status: 403 });
   const list = Array.isArray(body.updates) ? body.updates : (body.update_type ? [body] : []);
   for (const upd of list) await processMaxUpdate(upd);
   return { ok: true };
@@ -296,6 +330,7 @@ async function pollMax() {
 }
 
 export function startNotifyPolling() {
+  if (IS_INSTANCE) return;
   const timer = setInterval(() => {
     pollTelegram();
     pollMax();

package/server/role.js

@@ -0,0 +1,44 @@
+// Copyright (c) 2026 Roman A. Perepelkin. All rights reserved. Proprietary software.
+// Режим работы сервера:
+//   central  — центральный сервер платформы: лендинг, кабинеты, оплата, админка, ИИ-прокси, реестр машин клиентов и выпуск лицензий
+//   instance — машина клиента с лицензией центра. Вид машины (INSTANCE_KIND):
+//                cloud   — арендованная машина в Kubernetes (поддомен naXXXXXX.odant.org), вход через центр
+//                desktop — установка на компьютер клиента (VIP по договору), активация кодом из кабинета
+//   dev      — локальный запуск разработчика/владельца (прежнее поведение)
+import './config.js';
+import { BUILD } from './build-info.js';
+
+// Защищённая сборка для компьютера клиента — всегда instance/desktop, без возможности переопределения
+const raw = BUILD ? 'instance' : String(process.env.NEUROALPHA_ROLE || (process.env.CLOUD_MODE === '1' ? 'central' : 'dev')).trim().toLowerCase();
+export const ROLE = ['central', 'instance', 'dev'].includes(raw) ? raw : 'dev';
+export const IS_CENTRAL = ROLE === 'central';
+export const IS_INSTANCE = ROLE === 'instance';
+export const IS_DEV = ROLE === 'dev';
+export const INSTANCE_KIND = BUILD ? 'desktop' : (IS_INSTANCE && String(process.env.INSTANCE_KIND || 'cloud').trim().toLowerCase() === 'desktop' ? 'desktop' : 'cloud');
+export const IS_DESKTOP = IS_INSTANCE && INSTANCE_KIND === 'desktop';
+
+if (IS_CENTRAL) process.env.CLOUD_MODE = '1';
+if (BUILD) {
+  delete process.env.CLOUD_MODE;
+  // провайдер ИИ «НейроАльфа Облако» и проверка лицензии ходят только в вшитый центр
+  process.env.CLOUD_URL = BUILD.centralUrl;
+}
+
+export const INSTANCE_DOMAIN = String(process.env.INSTANCE_DOMAIN || 'odant.org').trim().replace(/^\.+/, '');
+export const CENTRAL_URL = (BUILD ? BUILD.centralUrl : String(process.env.CENTRAL_URL || process.env.CLOUD_URL || 'https://neuroalpha.odant.org')).trim().replace(/\/+$/, '');
+
+// Адрес прослушивания: установка на компьютер по умолчанию доступна только с этого компьютера
+export const LISTEN_HOST = String(process.env.HOST || (IS_DESKTOP ? '127.0.0.1' : '')).trim() || undefined;
+
+// IP клиента: за ingress/прокси (central, cloud-машина или TRUST_PROXY=1) берётся последний адрес из X-Forwarded-For,
+// который добавил наш прокси; первые значения цепочки клиент может подделать
+export function clientIp(req) {
+  const behindProxy = IS_CENTRAL || (IS_INSTANCE && !IS_DESKTOP) || process.env.TRUST_PROXY === '1';
+  const xff = String(req?.headers?.['x-forwarded-for'] || '').split(',').map((s) => s.trim()).filter(Boolean);
+  if (behindProxy && xff.length) return xff[xff.length - 1];
+  return String(req?.socket?.remoteAddress || '');
+}
+
+export function isHttpsRequest(req) {
+  return Boolean(req?.secure || String(req?.headers?.['x-forwarded-proto'] || '').split(',')[0].trim() === 'https');
+}