neuroalpha 0.5.21 → 0.5.24

package/server/model/research.js

@@ -9,7 +9,7 @@ import { ensureProfiles } from './profiles.js';
 import { spearman } from './linalg.js';
 import { listRuns, getRun, createRun, finishRun, saveTrade, saveRunExtra, kvGet } from '../db.js';
 import { strategyDefaults } from '../config.js';
-import { ENTRY_EDGE_MULT, TIER1_LIQUID_SYMBOLS, symbolEdgeMult, computeTokenEdgeMults, QUARANTINE_DECAY, isStockQuarantined, canEnterIntraday, shouldExitBeforeNight } from './edge.js';
+import { ENTRY_EDGE_MULT, TIER1_LIQUID_SYMBOLS, symbolEdgeMult, computeTokenEdgeMults, QUARANTINE_DECAY, isStockQuarantined, canEnterIntraday, shouldExitBeforeNight, isRegimeShocked } from './edge.js';
 import { buildDividendCalendar, nextDividendAt, dividendRules, DIV_TAX } from './dividends.js';
 
 const DAY = 86400000;
@@ -40,7 +40,9 @@ export function isMarketDown(ds, t) {
 // 9: исторический состав индекса (без ошибки выжившего), дивиденды префов, правила v0.5.x
 // 10: запрет переноса внутридневных сделок через ночь, период полураспада карантина 15 дн., строгий 1-й эшелон
 // 11: индивидуальный расчёт порога каждой акции по её фактическому рублёвому обороту и остаточной волатильности
-const DATA_VERSION = 11;
+// 12: калибровка индивидуальных порогов 2–3 эшелона по ликвидности, защита от шорт-сквизов (≥20% за день) и обвалов (≥9,5% за 30м), отбор доступных шортов до Top-K
+// 13: полная докачка левого края истории свечей (раньше при уже накопленных свечах 2022 год не догружался)
+const DATA_VERSION = 13;
 
 const AUTO_LOCKED = { modelHorizon: 2.5, modelMinEdge: 2.5, modelExitRatio: 0.95 };
 function reuseParamsKey(params) {
@@ -461,8 +463,8 @@ async function run(runId, p, state) {
       }
       const timeOk = !autoAdapt || canEnterIntraday(barTs, H, BAR_INTERVAL);
       const canOpenAt = (i) => timeOk && !held.has(i) && !closedThisBar.has(i) && stockAllowed(i) && canEnter(i, t);
-      const okLong = (i) => !divRule(i, t)?.blockLong;
-      const okShort = (i) => !divRule(i, t)?.blockShort;
+      const okLong = (i) => !divRule(i, t)?.blockLong && (!needTrade || (tokens[i].has[tIn] && tokens[i].open[tIn] > 0)) && (!autoAdapt || !isRegimeShocked(ds, i, t, 'long'));
+      const okShort = (i) => !divRule(i, t)?.blockShort && (!shortable || shortable.has(tokens[i].symbol)) && (!needTrade || (tokens[i].has[tIn] && tokens[i].open[tIn] > 0)) && (!autoAdapt || !isRegimeShocked(ds, i, t, 'short'));
       let order, entries;
       if (dir !== 'long') {
         const edge = (i) => pr[i] * sg[i] * Math.sqrt(H);
@@ -474,12 +476,15 @@ async function run(runId, p, state) {
           const e = edge(i);
           const barsHeld = tIn - h.entryT;
           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 shocked = autoAdapt && isRegimeShocked(ds, i, t, h.side);
+          if (shocked || !(h.side === 'long' ? e > req : e < -req) || !liquid(i, t)) {
+            closePos(i, h, tIn, false, shocked ? 'Защита от экстремального сквиза/обвала' : 'Прогноз ослаб');
+          }
         }
         const needL = autoAdapt && bear ? need * 1.25 : need;
         const needS = autoAdapt ? (bear ? need * 0.90 : need * 1.25) : need;
-        const candL = (mktDown || !timeOk) ? [] : [...pr.keys()].filter((i) => canOpenAt(i) && okLong(i) && edge(i) > needL * symMult[i]).sort((a, b) => pr[b] - pr[a]);
-        const candS = !timeOk ? [] : [...pr.keys()].filter((i) => canOpenAt(i) && okShort(i) && edge(i) < -needS * symMult[i]).sort((a, b) => pr[a] - pr[b]);
+        const candL = (mktDown || !timeOk) ? [] : [...pr.keys()].filter((i) => edge(i) > needL * symMult[i] && canOpenAt(i) && okLong(i)).sort((a, b) => pr[b] - pr[a]);
+        const candS = !timeOk ? [] : [...pr.keys()].filter((i) => edge(i) < -needS * symMult[i] && canOpenAt(i) && okShort(i)).sort((a, b) => pr[a] - pr[b]);
         // Вытеснение слабой/остывшей позиции новым мощным лидером (Opportunity Rotation):
         // если капитал заперт в позиции с ослабевшим ожиданием (< 0.55 * exitNeed), а на текущей свече появился лидер в 2.4 раза сильнее порога,
         // освобождаем слот под лидера, чтобы ни одна фаза не застревала в слабых бумагах
@@ -516,11 +521,27 @@ async function run(runId, p, state) {
           const e = edge(i);
           const barsHeld = tIn - h.entryT;
           const req = (autoAdapt && barsHeld <= 2 * stepBars ? earlyExitNeed : exitNeed) * symMult[i];
-          if (!(e > req) || !liquid(i, t)) closePos(i, h, tIn, false);
+          const shocked = autoAdapt && isRegimeShocked(ds, i, t, 'long');
+          if (shocked || !(e > req) || !liquid(i, t)) closePos(i, h, tIn, false, shocked ? 'Защита от экстремального обвала' : '');
         }
-        const free = K - held.size;
         const needL = autoAdapt && bear ? need * 1.25 : need;
-        const rawCand = (mktDown || !timeOk) ? [] : [...pr.keys()].filter((i) => canOpenAt(i) && okLong(i) && edge(i) > needL * symMult[i]).sort((a, b) => pr[b] - pr[a]);
+        const rawCand = (mktDown || !timeOk) ? [] : [...pr.keys()].filter((i) => edge(i) > needL * symMult[i] && canOpenAt(i) && okLong(i)).sort((a, b) => pr[b] - pr[a]);
+        const usedNow = [...held.values()].reduce((s, h) => s + h.alloc, 0);
+        if (autoAdapt && usedNow > equity * 0.65 && rawCand.length > 0) {
+          const bestNewEdge = edge(rawCand[0]);
+          if (bestNewEdge >= need * 2.2) {
+            let weakestIdx = -1, weakestE = Infinity;
+            for (const [i] of held) {
+              const curSignedE = 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 free = K - held.size;
         const cand = filterDynamicTopK(rawCand, edge, needL, Math.max(0, free));
         order = [...held.keys(), ...cand];
       } else {
@@ -912,7 +933,7 @@ function runStressTest({ simulate, chosen, testTs, tsOf, mcurve, p, H }) {
     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 thresholdSweep = [1, 1.5, 1.6, 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 };
@@ -924,7 +945,7 @@ function runStressTest({ simulate, chosen, testTs, tsOf, mcurve, p, H }) {
     market: { full: mSeg(-Infinity), last12: mSeg(lastTs - 365 * 86400000), last6: mSeg(lastTs - 182 * 86400000) },
     shortableKnown: Boolean(shortable),
     caveats: [
-      'Состав рынка — сегодняшний индекс широкого рынка, бумаги отобраны по покрытию данных за весь период (ошибка выжившего не устранена).',
+      'Состав рынка — исторический состав индекса MOEXBMI на каждую дату плюс текущий состав; отсекаются только бумаги с покрытием данных менее 15% периода.',
       'Константы стратегии подбирались на этой же истории, поэтому «последние 6 и 12 месяцев» не являются честно отложенной выборкой. Честная проверка — торговля после фиксации версии.',
       'Список бумаг для шорта — текущий, а не на каждую дату.',
     ],
@@ -974,7 +995,9 @@ async function runStabilityLoop(targetId, runRow, st) {
     await pause();
     const p = normalizeParams(runRow.params || {});
     const shifts = [-8, -4, 0, 4, 8];
-    const H = barsFromHours(p.modelHorizon);
+    const autoAdapt = p.modelAutoAdapt !== false;
+    const effHorizon = autoAdapt ? 2.5 : p.modelHorizon;
+    const H = barsFromHours(effHorizon);
     const tillTs = Date.now();
     const todayStartMsk = Math.floor((tillTs + MSK) / DAY) * DAY - MSK;
     const fromTs = todayStartMsk - 1650 * DAY;
@@ -991,11 +1014,18 @@ async function runStabilityLoop(targetId, runRow, st) {
     const trainLen = Math.round(p.modelTrainDays * bpd), testLen = Math.round(20 * bpd);
     const chosen = p.modelType in MODELS ? p.modelType : 'attention';
     const realCost = (p.commissionPct + p.slippagePct) / 100;
-    const K = p.modelTopK, dir = p.modelDirection, slots = dir === 'long' ? K : 2 * K;
-    const autoAdapt = p.modelAutoAdapt !== false;
+    const rawTopK = Number(p.modelTopK ?? 2);
+    const K = rawTopK > 0 ? rawTopK : 4;
+    const dir = p.modelDirection, slots = dir === 'long' ? K : 2 * K;
     const effMinEdge = autoAdapt ? 2.5 : p.modelMinEdge;
     const exitRatio = Number(p.modelExitRatio ?? 0.5);
     const mktFilter = p.modelMarketFilter === 'ma', invVol = p.modelAllocMode === 'invvol';
+    const baseSymMult = Float64Array.from(tokens, (tk) => symbolEdgeMult(tk.symbol));
+    const divCal = buildDividendCalendar(ds);
+    const divRule = (i, t) => {
+      const nd = nextDividendAt(divCal, i, t);
+      return nd ? dividendRules(nd.daysToEx, nd.y) : null;
+    };
     const liquid = (i, t) => tokens[i].liq[t] >= LIQ_MIN && tokens[i].open[t + 1] > 0;
     const canEnter = (i, t) => liquid(i, t) && (!tokens[i].inIndex || tokens[i].inIndex[t] === 1);
     const tsOf = (t) => timeline[Math.min(t, T - 1)];
@@ -1019,7 +1049,7 @@ async function runStabilityLoop(targetId, runRow, st) {
       const maxH = autoAdapt ? Math.round(H * 1.4) : H;
       const folds = Math.max(1, Math.ceil((T - maxH - testStart) / testLen));
       let fi = 0;
-      const preds = new Map(), sigmaAt = new Map();
+      const preds = new Map(), sigmaAt = new Map(), multAt = new Map();
       while (testStart < T - maxH - 2) {
         if (st.cancelled) throw new Error('Отменено');
         const testEnd = Math.min(testStart + testLen, T - maxH - 2);
@@ -1028,12 +1058,14 @@ async function runStabilityLoop(targetId, runRow, st) {
         emitStab({ pct, text: `Проверка устойчивости: сдвиг ${si + 1} из ${shifts.length} (${shLabel}), шаг ${fi + 1} из ${folds}…` });
         await tick();
         const f = buildFold(ds, { trainStart, testStart, testEnd, H, embedDim: p.modelEmbedDim, textWeight: p.modelTextWeight, profiles, multiHorizon: autoAdapt });
+        const foldEdgeMults = computeTokenEdgeMults(tokens, f.sigma, trainStart, testStart);
         const m = await MODELS[chosen].fit(f);
         for (let t = testStart; t < testEnd; t++) {
           const u = t - f.lo;
           if (!f.yok[u]) continue;
           preds.set(t, MODELS[chosen].predict(m, f, u));
           sigmaAt.set(t, f.sigma);
+          multAt.set(t, foldEdgeMults);
         }
         testStart = testEnd;
         fi++;
@@ -1051,7 +1083,7 @@ async function runStabilityLoop(targetId, runRow, st) {
       const stockAllowed = (i) => !autoAdapt || !isStockQuarantined(stockCnt[i], stockPnl[i]);
       const curExitRatio = autoAdapt ? 0.95 : exitRatio;
       const stepBars = autoAdapt ? Math.max(3, Math.floor(H / 5)) : H;
-      const maxSlotWeight = dir === 'long' ? Math.min(0.45, Math.max(1 / K, 1.35 / K)) : Math.min(0.35, 1.4 / (2 * K));
+      const maxSlotWeight = dir === 'long' ? Math.min(0.58, Math.max(1 / K, 1.8 / K)) : Math.min(0.75, 3.0 / (2 * K));
       let closedThisBar = new Set();
       const closePos = (i, h, t) => {
         const exitPrice = px(i, t);
@@ -1075,9 +1107,14 @@ async function runStabilityLoop(targetId, runRow, st) {
           for (let i = 0; i < N; i++) { stockPnl[i] *= QUARANTINE_DECAY; stockCnt[i] *= QUARANTINE_DECAY; }
         }
         const pr = preds.get(t), sg = sigmaAt.get(t);
+        const symMult = multAt.get(t) || baseSymMult;
         const bear = isMarketDown(ds, t);
         const mktDown = mktFilter && bear;
         const barTs = tsOf(t);
+        for (const [i, h] of [...held]) {
+          const r = divRule(i, t);
+          if (r && (h.side === 'long' ? r.exitLong : r.exitShort)) closePos(i, h, tIn);
+        }
         if (autoAdapt) {
           for (const [i, h] of [...held]) {
             if (shouldExitBeforeNight(barTs, tsOf(h.entryT), stepBars, BAR_INTERVAL)) closePos(i, h, tIn);
@@ -1085,29 +1122,64 @@ async function runStabilityLoop(targetId, runRow, st) {
         }
         const timeOk = !autoAdapt || canEnterIntraday(barTs, H, BAR_INTERVAL);
         const canOpenAt = (i) => timeOk && !held.has(i) && !closedThisBar.has(i) && stockAllowed(i) && canEnter(i, t);
+        const okLong = (i) => !divRule(i, t)?.blockLong && (!autoAdapt || !isRegimeShocked(ds, i, t, 'long'));
+        const okShort = (i) => !divRule(i, t)?.blockShort && (!autoAdapt || !isRegimeShocked(ds, i, t, 'short'));
         const edge = (i) => pr[i] * sg[i] * Math.sqrt(H);
         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) * symbolEdgeMult(tokens[i].symbol);
-            if (!(h.side === 'long' ? e > req : e < -req) || !liquid(i, t)) closePos(i, h, tIn);
+            const req = (autoAdapt && barsHeld <= 2 * stepBars ? earlyExitNeed : exitNeed) * symMult[i];
+            const shocked = autoAdapt && isRegimeShocked(ds, i, t, h.side);
+            if (shocked || !(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 || !timeOk) ? [] : [...pr.keys()].filter((i) => canOpenAt(i) && edge(i) > needL * symbolEdgeMult(tokens[i].symbol)).sort((a, b) => pr[b] - pr[a]);
-          const candS = !timeOk ? [] : [...pr.keys()].filter((i) => canOpenAt(i) && edge(i) < -needS * symbolEdgeMult(tokens[i].symbol)).sort((a, b) => pr[a] - pr[b]);
+          const candL = (mktDown || !timeOk) ? [] : [...pr.keys()].filter((i) => edge(i) > needL * symMult[i] && canOpenAt(i) && okLong(i)).sort((a, b) => pr[b] - pr[a]);
+          const candS = !timeOk ? [] : [...pr.keys()].filter((i) => edge(i) < -needS * symMult[i] && canOpenAt(i) && okShort(i)).sort((a, b) => pr[a] - pr[b]);
+          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);
+            }
+          }
           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) {
           for (const [i, h] of [...held]) {
             const e = edge(i), barsHeld = tIn - h.entryT;
-            const req = autoAdapt && barsHeld <= 2 * stepBars ? earlyExitNeed : exitNeed;
-            if (!(e > req) || !liquid(i, t)) closePos(i, h, tIn);
+            const req = (autoAdapt && barsHeld <= 2 * stepBars ? earlyExitNeed : exitNeed) * symMult[i];
+            const shocked = autoAdapt && isRegimeShocked(ds, i, t, 'long');
+            if (shocked || !(e > req) || !liquid(i, t)) closePos(i, h, tIn);
           }
           const needL = autoAdapt && bear ? need * 1.25 : need;
-          const cand = (mktDown || !timeOk) ? [] : [...pr.keys()].filter((i) => canOpenAt(i) && edge(i) > needL).sort((a, b) => pr[b] - pr[a]).slice(0, Math.max(0, K - held.size));
+          const rawCand = (mktDown || !timeOk) ? [] : [...pr.keys()].filter((i) => edge(i) > needL * symMult[i] && canOpenAt(i) && okLong(i)).sort((a, b) => pr[b] - pr[a]);
+          const usedNow = [...held.values()].reduce((s, h) => s + h.alloc, 0);
+          if (autoAdapt && usedNow > equity * 0.65 && rawCand.length > 0) {
+            const bestNewEdge = edge(rawCand[0]);
+            if (bestNewEdge >= need * 2.2) {
+              let weakestIdx = -1, weakestE = Infinity;
+              for (const [i] of held) {
+                const curSignedE = 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);
+            }
+          }
+          const cand = rawCand.slice(0, Math.max(0, K - held.size));
           order = [...held.keys(), ...cand];
         } else {
           const cand = (mktDown || !timeOk) ? [] : [...pr.keys()].filter((i) => !closedThisBar.has(i) && stockAllowed(i) && pr[i] > 0 && canEnter(i, t)).sort((a, b) => pr[b] - pr[a]).slice(0, K);
@@ -1125,11 +1197,25 @@ async function runStabilityLoop(targetId, runRow, st) {
         }
         const usedStart = [...held.values()].reduce((s, h) => s + h.alloc, 0);
         let avail = Math.max(0, equity * 0.99 - usedStart);
+        const activeTotal = Math.max(2, held.size + newEntries.length);
+        const dynSlotWeight = autoAdapt
+          ? Math.min(dir === 'long' ? 0.58 : 0.75, Math.max(maxSlotWeight, (dir === 'long' ? 1.8 : 3.0) / Math.min(slots, activeTotal + 1)))
+          : maxSlotWeight;
+        if (autoAdapt && newEntries.length > 1) {
+          newEntries.sort((a, b) => Math.abs(b[2] ?? 0) - Math.abs(a[2] ?? 0));
+        }
+        const edgeWeights = newEntries.map(([i, , edgeAt]) => {
+          const effE = edgeAt !== null && edgeAt !== undefined ? Math.abs(edgeAt) : (sg ? Math.abs(pr[i] * sg[i] * Math.sqrt(H)) : 0);
+          return Math.max(0.0001, effE);
+        });
+        let remWeightSum = edgeWeights.reduce((a, b) => a + b, 0);
         for (let idx = 0; idx < newEntries.length; idx++) {
-          const [i, side, edgeAt] = newEntries[idx];
-          const effEdge = edgeAt !== null && edgeAt !== undefined ? Math.abs(edgeAt) : (sg ? Math.abs(pr[i] * sg[i] * Math.sqrt(H)) : 0);
-          const conv = autoAdapt && need > 0 && effEdge > 0 ? Math.min(1.20, Math.max(0.85, 0.80 + 0.20 * (effEdge / need))) : 1;
-          const baseAlloc = autoAdapt ? Math.min(equity * maxSlotWeight * conv, avail / Math.max(1, newEntries.length - idx)) : Math.min(equity / slots, avail / Math.max(1, newEntries.length - idx));
+          const [i, side] = newEntries[idx];
+          const effEdge = edgeWeights[idx];
+          const conv = autoAdapt && need > 0 && effEdge > 0 ? Math.min(1.65, Math.max(0.85, 0.80 + 0.30 * (effEdge / need))) : 1;
+          const propShare = autoAdapt && remWeightSum > 0 ? avail * (effEdge / remWeightSum) : avail / Math.max(1, newEntries.length - idx);
+          remWeightSum = Math.max(0, remWeightSum - effEdge);
+          const baseAlloc = autoAdapt ? Math.min(equity * dynSlotWeight * conv, propShare, avail) : Math.min(equity / slots, avail / Math.max(1, newEntries.length - idx));
           let alloc = baseAlloc;
           if (invVol && avgInv > 0 && sg[i] > 0) {
             const w = Math.max(0.4, Math.min(1.8, (1 / sg[i]) / avgInv));

package/server/strategist/tools.js

@@ -283,6 +283,7 @@ export const TOOLS = {
           динамика_проц: x.deltaPct || 0,
           сигнал_покупки: !!x.signal,
           ...(buyBlockedByDip ? { покупка_заблокирована: `сейчас бумага падает на текущей свече (${x.lastMovePct}%), сработала защита от ловли падающего ножа` } : {}),
+          ...(x.buyBlockedByOverheat ? { покупка_заблокирована_перегревом: `бумага уже перегрета (+${x.buyBlockedByOverheat}% сверх рынка за 1–3 дня), сработала защита от покупки на вершине пампа` } : {}),
           ...(x.buyBlockedByDiv ? { покупка_заблокирована_дивидендами: x.buyBlockedByDiv } : {}),
           ...(x.buyBlockedByNews ? { покупка_заблокирована_новостями: x.buyBlockedByNews } : {}),
           ...(x.shortSignal !== undefined ? { сигнал_шорта: !!x.shortSignal } : {}),