neuroalpha 0.3.15 → 0.3.16

package/server/data/moex.js

@@ -61,6 +61,10 @@ export async function fetchCandles(symbol, interval, from, till, { signal, onBat
   return rows;
 }
 
+// Память времени последней проверки правой границы (свежих свечей) по каждому тикеру,
+// чтобы во время серии экспериментов не опрашивать MOEX ISS по всем 100 акциям на каждом запуске
+const lastTailCheckAt = new Map(); // `${symbol}:${interval}` -> timestamp
+
 // Догружает недостающие свечи в SQLite и возвращает их из кэша.
 // Метка kv candProbe:symbol:interval — насколько раннюю историю уже спрашивали у биржи:
 // у инструментов, вышедших на биржу позже начала периода, ранней истории нет, и без метки
@@ -71,24 +75,63 @@ export async function ensureCandles(symbol, interval, fromTs, tillTs, { signal,
   const now = Date.now();
   const pKey = `candProbe:${symbol}:${interval}`;
   const probe = kvGet(pKey);
-  const covered = probe && probe.fromTs <= fromTs + 5 * DAY; // раньше этой даты точно ничего нет
-  let fetchFrom;
-  if (!range.n) fetchFrom = fromTs;
-  else {
-    if (!covered && range.min > fromTs + 5 * DAY) {
-      // один запрос: если биржа отдаёт первую свечу не раньше нашей — истории раньше не существует
-      const first = (await fetchCandles(symbol, interval, tsToDate(fromTs), null, { signal, pages: 1 }))[0];
-      if (!first || first.ts <= range.min + DAY) kvSet(pKey, { fromTs });
-      else fetchFrom = fromTs; // ранний кусок и правда есть — качаем всё
+  // Защита от ложных меток candProbe v1 (где из-за старого условия first.ts <= range.min записывалось fromTs без скачивания):
+  // валидной считаем только метку v2 (или если range.min реально доходит до fromTs)
+  const covered = probe && probe.v === 2 && probe.fromTs <= fromTs + 5 * DAY;
+
+  if (!range.n) {
+    // В базе ещё нет свечей этой бумаги — качаем весь запрошенный диапазон один раз
+    await fetchCandles(symbol, interval, tsToDate(fromTs), tillTs < now ? tsToDate(tillTs) : null, {
+      signal,
+      onBatch: (page) => saveCandles(symbol, interval, page),
+    });
+    kvSet(pKey, { v: 2, fromTs });
+    lastTailCheckAt.set(`${symbol}:${interval}`, now);
+    return loadCandles(symbol, interval, fromTs, tillTs);
+  }
+
+  // 1) ЛЕВЫЙ КРАЙ:
+  // Если в локальной базе SQLite уже накоплена история (range.n >= 500 свечей), НИКОГДА не лезем на биржу докачивать левый край
+  // при смене «Окна обучения» или «Периода исследования» — работаем мгновенно по уже сохранённым в SQLite историческим свечам!
+  if (!covered && range.n < 500 && range.min > fromTs + 5 * DAY) {
+    const first = (await fetchCandles(symbol, interval, tsToDate(fromTs), null, { signal, pages: 1 }))[0];
+    if (!first || first.ts >= range.min - DAY) {
+      kvSet(pKey, { v: 2, fromTs: Math.min(fromTs, probe?.v === 2 ? probe.fromTs : fromTs) });
+    } else {
+      const leftTill = tsToDate(range.min + DAY);
+      await fetchCandles(symbol, interval, tsToDate(fromTs), leftTill, {
+        signal,
+        onBatch: (page) => saveCandles(symbol, interval, page),
+      });
+      kvSet(pKey, { v: 2, fromTs: Math.min(fromTs, probe?.v === 2 ? probe.fromTs : fromTs) });
     }
-    // свежие свечи догружаем в любом случае
-    if (fetchFrom === undefined && range.max < Math.min(tillTs, now) - barMs(interval)) fetchFrom = range.max;
+  } else if (!probe || probe.v !== 2 || probe.fromTs > fromTs) {
+    kvSet(pKey, { v: 2, fromTs: Math.min(fromTs, range.min) });
   }
-  if (fetchFrom !== undefined) {
-    // сохраняем постранично: при обрыве акция продолжит загрузку с того места
-    await fetchCandles(symbol, interval, tsToDate(fetchFrom), tillTs < now ? tsToDate(tillTs) : null, { signal, onBatch: (page) => saveCandles(symbol, interval, page) });
-    kvSet(pKey, { fromTs: Math.min(fromTs, probe?.fromTs ?? fromTs) });
+
+  // 2) ПРАВЫЙ КРАЙ (свежие свечи текущего дня):
+  // Бесплатный контур MOEX ISS отдаёт 10-минутные свечи с задержкой ~20–30 минут.
+  // Поэтому если в SQLite уже есть свечи сегодняшней/вчерашней сессии (моложе 45 минут в торговые часы или моложе 16 часов вне сессии),
+  // или если мы уже проверяли хвост в последние 30 минут (метка хранится и в памяти, и в probe.tailCheckedAt в SQLite, переживая перезапуск сервера),
+  // то вообще не делаем сетевых запросов к Мосбирже!
+  const tailKey = `${symbol}:${interval}`;
+  const lastCheck = Math.max(lastTailCheckAt.get(tailKey) || 0, probe?.tailCheckedAt || 0);
+  const mskDate = new Date(now + MSK);
+  const mskDow = mskDate.getUTCDay();
+  const mskHour = mskDate.getUTCHours();
+  const isTradingHours = mskDow >= 1 && mskDow <= 5 && mskHour >= 9 && mskHour < 24;
+  const checkCooldownMs = isTradingHours ? 30 * 60000 : 4 * 3600000;
+  const dbIsAlreadyFresh = (now - range.max < 45 * 60000) || (!isTradingHours && now - range.max < 18 * 3600000);
+
+  if (!dbIsAlreadyFresh && range.max < Math.min(tillTs, now) - barMs(interval) && (now - lastCheck >= checkCooldownMs)) {
+    await fetchCandles(symbol, interval, tsToDate(range.max), tillTs < now ? tsToDate(tillTs) : null, {
+      signal,
+      onBatch: (page) => saveCandles(symbol, interval, page),
+    });
+    lastTailCheckAt.set(tailKey, now);
+    kvSet(pKey, { v: 2, fromTs: Math.min(fromTs, probe?.v === 2 ? probe.fromTs : range.min), tailCheckedAt: now });
   }
+
   return loadCandles(symbol, interval, fromTs, tillTs);
 }
 
@@ -147,20 +190,28 @@ async function fetchDividendsSmartlab(symbol, signal) {
   return list;
 }
 
-// Дивиденды акции с кэшем в kv на сутки; при ошибке сети — старый кэш
+// Дивиденды акции с кэшем в kv на 7 суток (включая пустой список для бездивидендных бумаг); при ошибке сети — старый кэш
 export async function ensureDividends(symbol, { signal, localOnly = false } = {}) {
   const key = `dividends:${symbol}`;
   const cached = kvGet(key);
   if (localOnly) return cached?.list || [];
-  if (cached && Date.now() - cached.at < DAY) return cached.list;
+  if (cached && Array.isArray(cached.list) && Date.now() - cached.at < 7 * DAY) return cached.list;
   let list = null;
-  try { list = await fetchDividendsIss(symbol, signal); } catch { /* нет подписки/сети */ }
+  let networkOk = false;
+  try {
+    list = await fetchDividendsIss(symbol, signal);
+    networkOk = true;
+  } catch { /* нет подписки/сети */ }
   if (!list?.length) {
-    try { list = await fetchDividendsSmartlab(symbol, signal); } catch { /* пропускаем */ }
+    try {
+      const sl = await fetchDividendsSmartlab(symbol, signal);
+      if (sl) list = sl;
+      networkOk = true;
+    } catch { /* пропускаем */ }
   }
-  if (list) {
-    kvSet(key, { at: Date.now(), list });
-    return list;
+  const finalList = Array.isArray(list) ? list : (cached?.list || []);
+  if (networkOk || Array.isArray(list)) {
+    kvSet(key, { at: Date.now(), list: finalList });
   }
-  return cached?.list || [];
+  return finalList;
 }

package/server/db.js

@@ -196,11 +196,12 @@ for (const [tbl, col, def] of [
   }
 }
 
-// Гарантируем наличие локального пользователя по умолчанию (id = 1)
+// Гарантируем наличие локального пользователя по умолчанию (id = 1, режим «Хозяин»)
 if (!db.prepare('SELECT id FROM users WHERE id = 1').get()) {
   db.prepare(`INSERT INTO users (id, email, name, pass_hash, role, plan, plan_until, notify_code, created_at)
-    VALUES (1, 'owner@neuroalpha.local', 'Пользователь', '', 'admin', 'pro', 0, 'NA-OWNER1', ?)`).run(Date.now());
+    VALUES (1, 'owner@neuroalpha.local', 'Хозяин', '', 'admin', 'owner', 0, 'NA-OWNER1', ?)`).run(Date.now());
 } else {
+  db.prepare(`UPDATE users SET plan = 'owner' WHERE id = 1 AND role = 'admin' AND plan IN ('free', 'pro')`).run();
   db.prepare("UPDATE users SET name = 'Пользователь' WHERE id = 1 AND name = 'Владелец платформы'").run();
 }
 db.exec('CREATE UNIQUE INDEX IF NOT EXISTS users_api_key ON users(api_key) WHERE api_key IS NOT NULL');

package/server/model/dataset.js

@@ -203,6 +203,14 @@ export async function loadDataset({ interval = BAR_INTERVAL, fromTs, tillTs, use
   const key = cacheKey(interval, fromTs, tillTs, useMacro, useDividends);
   const hit = datasetCache.get(key);
   if (hit && Date.now() - hit.at < 30 * 60000) return hit.ds;
+  // Если в памяти уже есть более широкий датасет (например, при изменении Окна обучения modelTrainDays),
+  // который полностью покрывает запрошенный диапазон [fromTs … tillTs], возвращаем его мгновенно без пересборки!
+  const modeKey = JSON.stringify([interval, useMacro ? 1 : 0, useDividends ? (process.env.DIVIDENDS_MODE || 1) : 0]);
+  for (const v of datasetCache.values()) {
+    if (v.modeKey === modeKey && Date.now() - v.at < 30 * 60000 && v.fromTs <= fromTs + DAY && Math.abs(v.tillTs - tillTs) < 3600000) {
+      return v.ds;
+    }
+  }
   const vocab = await ensureVocab();
   const symbols = vocab.map((v) => v.symbol);
   const raw = {};
@@ -356,7 +364,7 @@ export async function loadDataset({ interval = BAR_INTERVAL, fromTs, tillTs, use
     }
   }
   const ds = { tokens, symbols: tokens.map((t) => t.symbol), timeline, hourMsk, dowMsk, T, index, mret, mclose: mk.close, mopen: mk.open, macro, barsPerDay: days ? Math.round(T / days) : 54 };
-  datasetCache.set(key, { ds, at: Date.now() });
-  if (datasetCache.size > 2) datasetCache.delete(datasetCache.keys().next().value);
+  datasetCache.set(key, { ds, at: Date.now(), modeKey, fromTs, tillTs });
+  if (datasetCache.size > 4) datasetCache.delete(datasetCache.keys().next().value);
   return ds;
 }

package/server/model/forecast.js

@@ -6,6 +6,8 @@ import { buildFold, MODELS, HEADS, KINDS, SCALES, BETAS, LIQ_MIN, FEATURE_WARMUP
 import { loadProfiles } from './profiles.js';
 import { isMarketDown } from './research.js';
 import { newsForSymbols } from '../news/index.js';
+import { kvGet, kvSet } from '../db.js';
+import { hub } from '../hub.js';
 
 const trainedModelCache = new Map(); // fitKey -> { dayMsk, trainedAt, fTrain, fitted, snap }
 let baseState = null; // { key, trainedAt, ds, last, r, snap, prevExpMap, prevRankMap, lastTickResult, lastTickAt }
@@ -176,22 +178,23 @@ function applyLivePricesToFold(ds, f, u, fitted, liveSnap) {
     }
   }
 
-  // 2) пересчитываем признаки масштаба 0 (последний час) в точке u
-  const sc0 = SCALES[0];
-  const invP = 1 / Math.sqrt(sc0.len), invF = invP / 1.5;
-  const Xp0 = f.X[0][0], Xf0 = f.X[1][0];
-  for (let i = 0; i < N; i++) {
-    let sp = 0, sf = 0;
-    for (let k = 0; k < sc0.len; k++) {
-      const uk = u - k;
-      if (uk < 0) break;
-      const zk = f.z[uk * N + i];
-      sp += zk;
-      sf += zk * Math.min(4, ds.tokens[i].valRatio[f.lo + uk]);
+  // 2) пересчитываем все масштабы SCALES в точке u (как в buildInferenceFoldAt)
+  SCALES.forEach((sc, si) => {
+    const Xp = f.X[0][si], Xf = f.X[1][si];
+    const invP = 1 / Math.sqrt(sc.len), invF = invP / 1.5;
+    for (let i = 0; i < N; i++) {
+      let sp = 0, sf = 0;
+      for (let k = 0; k < sc.len; k++) {
+        const uk = u - sc.from - k;
+        if (uk < 0) break;
+        const zk = f.z[uk * N + i];
+        sp += zk;
+        sf += zk * Math.min(4, ds.tokens[i].valRatio[f.lo + uk]);
+      }
+      Xp[u * N + i] = sp * invP;
+      Xf[u * N + i] = sf * invF;
     }
-    Xp0[u * N + i] = sp * invP;
-    Xf0[u * N + i] = sf * invF;
-  }
+  });
 
   // 3) пересчитываем головы внимания F[hi][u*N + j] в точке u
   const att = fitted.attention;
@@ -240,7 +243,9 @@ export async function predictAt(ds, p, idx, { explain = true, liveSnap = null, f
   const profiles = p.modelTextWeight > 0 ? loadProfiles() : null;
   const f = buildFold(ds, { trainStart, testStart: idx, testEnd: idx + 1, H, embedDim: p.modelEmbedDim, textWeight: p.modelTextWeight, profiles, multiHorizon: autoAdapt });
   const u = idx - f.lo;
-  const list = [...new Set(explain ? Object.keys(MODELS) : ['attention', chosen])];
+  // Обучаем только выбранную модель (и attention для объяснения соседей и весов голов),
+  // не тратя 15 секунд на холостое обучение матрицы leadlag, которая в прогнозе и живой торговле не используется!
+  const list = [...new Set(['attention', chosen])];
   const fitted = {};
   for (const n of list) {
     fitted[n] = await MODELS[n].fit(f);
@@ -283,6 +288,7 @@ function buildPredictionRows(ds, p, idx, f, u, fitted, chosen, H, effMinEdge, au
   const dir = p.modelDirection || 'long';
   const needL = autoAdapt && bear ? threshold * 1.25 : threshold;
   const needS = autoAdapt && dir === 'longshort' ? (bear ? threshold * 0.90 : threshold * 1.25) : threshold;
+  const shortableMap = kvGet('tbankShortableMap')?.map || null;
   let sInv = 0, nInv = 0;
   for (let i = 0; i < ds.tokens.length; i++) if (f.sigma[i] > 0 && ds.tokens[i].liq[idx] >= LIQ_MIN) { sInv += 1 / f.sigma[i]; nInv++; }
   const avgInv = nInv ? sInv / nInv : 0;
@@ -290,6 +296,8 @@ function buildPredictionRows(ds, p, idx, f, u, fitted, chosen, H, effMinEdge, au
     const exp = preds[chosen][i] * f.sigma[i] * Math.sqrt(H);
     const weight = avgInv > 0 && f.sigma[i] > 0 ? Math.max(0.4, Math.min(1.8, (1 / f.sigma[i]) / avgInv)) : 1;
     const livePx = liveSnap?.prices?.get(tk.symbol) || tk.close[idx] || 0;
+    const rawShortHit = dir !== 'long' && tk.liq[idx] >= LIQ_MIN && exp < -needS;
+    const shortBlockedByBroker = Boolean(rawShortHit && shortableMap && shortableMap[tk.symbol] === false);
     const row = {
       i, symbol: tk.symbol, name: tk.name,
       price: round(livePx, 4),
@@ -300,7 +308,10 @@ function buildPredictionRows(ds, p, idx, f, u, fitted, chosen, H, effMinEdge, au
       weight: round(weight, 3),
       signal: tk.liq[idx] >= LIQ_MIN && exp > needL,
     };
-    if (dir !== 'long') row.shortSignal = tk.liq[idx] >= LIQ_MIN && exp < -needS;
+    if (dir !== 'long') {
+      row.shortSignal = rawShortHit && !shortBlockedByBroker;
+      if (shortBlockedByBroker) row.shortBlockedByBroker = true;
+    }
     if (explain) {
       const ex = explainAttention(fitted.attention, f, u, i);
       row.influences = ex.neighbors.map((x) => ({ symbol: ds.tokens[x.i].symbol, contribPct: round(x.contrib * f.sigma[i] * Math.sqrt(H) * 100, 3), closeness: round(f.cos[i][x.i], 2) }));
@@ -308,7 +319,7 @@ function buildPredictionRows(ds, p, idx, f, u, fitted, chosen, H, effMinEdge, au
     }
     return row;
   });
-  return { f, u, fitted, chosen, threshold, marketDown: bear, rows };
+  return { f, u, fitted, chosen, threshold, needL, needS, marketDown: bear, rows };
 }
 
 // Новости — только в прогнозе «сейчас»
@@ -387,15 +398,36 @@ export async function forecastNow(input, { force = false, onProgress } = {}) {
       at: now,
       liveTs,
       bar: fmtLiveBarLabel(barTs, liveSnap ? liveTs : null),
+      buyThresholdPct: round((r.needL ?? r.threshold) * 100, 3),
+      shortThresholdPct: round((r.needS ?? r.threshold) * 100, 3),
+      marketDown: r.marketDown,
       rows: sortedRows,
     };
     baseState.lastTickResult = result;
     baseState.lastTickAt = now;
+    kvSet('lastForecastSnap', { key, result });
+    hub.emit({ type: 'trading:pulse', kind: 'radar', ts: now, bar: result.bar, signals: sortedRows.filter((x) => x.signal || x.shortSignal).length });
     return withNews(result, p);
   }
 
+  // 2б) Сразу после перезапуска сервера (пока baseState ещё не прогрет в RAM):
+  // если в SQLite есть свежий снимок прогноза с теми же настройками (моложе 4 часов),
+  // мгновенно отдаём его пользователю за 0 мс, а пересчёт свежих котировок запускаем параллельно в фоне!
+  if (!force && !baseState) {
+    const saved = kvGet('lastForecastSnap');
+    if (saved?.result && saved.key === key && now - (saved.result.at || 0) < 4 * 3600000) {
+      if (!inflight.has(key)) {
+        setImmediate(() => {
+          forecastNow(p, { force: true }).catch(() => {});
+        });
+      }
+      return withNews(saved.result, p);
+    }
+  }
+
   if (!force && inflight.has(key)) return withNews(await inflight.get(key), p);
   const task = (async () => {
+    hub.emit({ type: 'trading:pulse', kind: 'train', ts: now, text: 'Обновление котировок и расчёт прогноза…' });
     const trainedToday = !force && isModelTrainedToday(p, now);
     const windowDays = trainedToday ? 7 : Math.ceil(p.modelTrainDays * 1.5 + 25);
     const [ds, liveSnap] = await Promise.all([
@@ -416,7 +448,10 @@ export async function forecastNow(input, { force = false, onProgress } = {}) {
       liveTs,
       barTs,
       bar: fmtLiveBarLabel(barTs, liveSnap ? liveTs : null),
-      horizon: effHorizon, direction: p.modelDirection, model: r.chosen, thresholdPct: round(r.threshold * 100, 3), marketDown: r.marketDown,
+      horizon: effHorizon, direction: p.modelDirection, model: r.chosen, thresholdPct: round(r.threshold * 100, 3),
+      buyThresholdPct: round((r.needL ?? r.threshold) * 100, 3),
+      shortThresholdPct: round((r.needS ?? r.threshold) * 100, 3),
+      marketDown: r.marketDown,
       rows: sortedRows,
       map: { symbols: ds.tokens.map((t) => t.symbol), names: ds.tokens.map((t) => t.name), pts: snap.pts.map(([x, y]) => [round(x, 3), round(y, 3)]), cl: snap.clusters },
       heads: HEADS.map((h, i) => ({ label: h.label, coef: round(r.fitted.attention.coef[i], 4) })),
@@ -437,6 +472,8 @@ export async function forecastNow(input, { force = false, onProgress } = {}) {
       lastTickResult: result,
       lastTickAt: now,
     };
+    kvSet('lastForecastSnap', { key, result });
+    hub.emit({ type: 'trading:pulse', kind: 'radar', ts: now, bar: result.bar, signals: sortedRows.filter((x) => x.signal || x.shortSignal).length });
     return result;
   })().finally(() => inflight.delete(key));
   inflight.set(key, task);

package/server/model/live.js

@@ -328,24 +328,39 @@ class LiveEngine {
       saveTrade(s.runId, t);
       hub.emit({ type: 'paper:trade', runId: s.runId, trade: t });
     }
-    const K = s.params.modelTopK;
+    const rawTopK = Number(s.params.modelTopK ?? 2);
+    const K = rawTopK > 0 ? rawTopK : 4;
     const dir = this.#direction(s);
     const slots = dir === 'long' ? K : 2 * K;
     const autoAdapt = s.params.modelAutoAdapt !== false;
-    const maxSlotWeight = dir === 'long' ? Math.min(0.48, Math.max(1 / K, 1.4 / K)) : Math.min(0.48, 1.9 / (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));
     const invVol = s.params.modelAllocMode === 'invvol';
     const effMinEdge = autoAdapt ? 2.5 : s.params.modelMinEdge;
     const needPct = effMinEdge * 2 * (s.params.commissionPct + s.params.slippagePct);
     const buyOrders = s.pending.filter((x) => x.action === 'buy' || x.action === 'short');
+    if (autoAdapt && buyOrders.length > 1) {
+      buyOrders.sort((a, b) => Math.abs(b.expectedPct || 0) - Math.abs(a.expectedPct || 0));
+    }
     const usedStart = [...s.held.values()].reduce((sum, h) => sum + h.alloc, 0);
     let avail = Math.max(0, s.equity * 0.99 - usedStart);
+    const activeTotal = Math.max(2, s.held.size + buyOrders.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;
+    let remWeightSum = buyOrders.reduce((sum, o) => sum + Math.max(0.01, Math.abs(o.expectedPct || 0)), 0);
     for (let idx = 0; idx < buyOrders.length; idx++) {
       const o = buyOrders[idx];
       const side = o.action === 'short' ? 'short' : 'long';
       const px = price(o.symbol);
-      if (s.held.has(o.symbol) || !(px > 0) || [...s.held.values()].filter((h) => h.side === side).length >= K) continue;
-      const conv = autoAdapt && needPct > 0 && o.expectedPct ? Math.min(1.25, Math.max(0.85, 0.80 + 0.25 * (Math.abs(o.expectedPct) / needPct))) : 1;
-      const baseAlloc = autoAdapt ? Math.min(s.equity * maxSlotWeight * conv, avail / Math.max(1, buyOrders.length - idx)) : Math.min(s.equity / slots, avail / Math.max(1, buyOrders.length - idx));
+      const wCur = Math.max(0.01, Math.abs(o.expectedPct || 0));
+      if (s.held.has(o.symbol) || !(px > 0) || [...s.held.values()].filter((h) => h.side === side).length >= K) {
+        remWeightSum = Math.max(0, remWeightSum - wCur);
+        continue;
+      }
+      const conv = autoAdapt && needPct > 0 && o.expectedPct ? Math.min(1.65, Math.max(0.85, 0.80 + 0.30 * (Math.abs(o.expectedPct) / needPct))) : 1;
+      const propShare = autoAdapt && remWeightSum > 0 ? avail * (wCur / remWeightSum) : avail / Math.max(1, buyOrders.length - idx);
+      remWeightSum = Math.max(0, remWeightSum - wCur);
+      const baseAlloc = autoAdapt ? Math.min(s.equity * dynSlotWeight * conv, propShare, avail) : Math.min(s.equity / slots, avail / Math.max(1, buyOrders.length - idx));
       let alloc = baseAlloc;
       if (invVol && o.weight > 0) {
         alloc = Math.min(baseAlloc * o.weight, avail / Math.max(1, buyOrders.length - idx));
@@ -386,7 +401,9 @@ class LiveEngine {
       const r = await predictAt(ds, p, idx);
       const row = new Map(r.rows.map((x) => [x.symbol, x]));
       const dir = this.#direction(s);
-      const K = p.modelTopK;
+      const rawTopK = Number(p.modelTopK ?? 2);
+      const autoK = rawTopK === 0 || autoAdapt;
+      const K = rawTopK > 0 ? rawTopK : 4;
       const closing = new Set();
       const closePos = (sym, why) => {
         const x = row.get(sym);
@@ -428,6 +445,13 @@ class LiveEngine {
           if (quarantined.has(x.symbol)) { step.decisions.push({ action: 'skip', symbol: x.symbol, text: 'Пропущена: в карантине после серии убыточных сделок' }); continue; }
           const b = nb?.get(x.symbol)?.[side === 'buy' ? 'bad' : 'good'];
           if (b) { step.decisions.push({ action: 'skip', symbol: x.symbol, text: `Пропущена: ${side === 'buy' ? 'плохая' : 'хорошая'} новость — ${b.gist}` }); continue; }
+          if (autoK && out.length >= 1) {
+            const bestE = Math.abs(out[0].expected);
+            const curE = Math.abs(x.expected);
+            const relMin = out.length === 1 ? 0.62 : 0.78;
+            const absMin = out.length === 1 ? r.threshold * 1.15 : r.threshold * 1.45;
+            if (!(curE >= bestE * relMin && curE >= absMin)) break;
+          }
           out.push(x);
         }
         return out;

package/server/model/models.js

@@ -131,12 +131,66 @@ export function buildFold(ds, { trainStart, testStart, testEnd, H, embedDim, tex
   const diag = Array.from({ length: N }, (_, i) => Math.sqrt(Math.max(C[i][i], 1e-9)));
   for (let i = 0; i < N; i++) for (let j = 0; j < N; j++) C[i][j] /= diag[i] * diag[j];
   const eig = eigenSym(C, { maxSweeps: 30 });
-  const d = Math.min(embedDim, N - 1);
-  const emb = Array.from({ length: N }, (_, i) => Float64Array.from({ length: d }, (_, c) => eig.vectors[c][i] * Math.sqrt(Math.max(eig.values[c], 0))));
-  const embN = emb.map((e) => { const n = Math.hypot(...e) || 1; return e.map((v) => v / n); });
+  const rawEmbDim = Math.round(Number(embedDim ?? 0));
+  let reqDim;
+  if (rawEmbDim <= 0) {
+    // Авто-калибровка размерности эмбеддинга по спектру случайных матриц (закон Марченко–Пастура с поправкой на главные моды):
+    // оцениваем дисперсию фонового шума sigmaBulk по средней части спектра (исключая главные рыночные моды сверху
+    // и вырожденные парные моды обычка/преф снизу) и отбираем структурные собственные числа выше границы lambdaPlus
+    const cutLo = Math.floor(eig.values.length * 0.32);
+    const cutHi = Math.max(cutLo + 1, Math.floor(eig.values.length * 0.92));
+    const bulkSlice = eig.values.slice(cutLo, cutHi);
+    const sigmaBulk = bulkSlice.reduce((a, b) => a + b, 0) / Math.max(1, bulkSlice.length);
+    const effSamples = Math.min(u1 - u0, 90 * 93) * 0.90;
+    const qRatio = N / Math.max(N + 1, effSamples);
+    const lambdaPlus = sigmaBulk * ((1 + Math.sqrt(qRatio)) ** 2);
+    let sigCount = 0;
+    for (let c = 0; c < eig.values.length; c++) {
+      if (eig.values[c] >= lambdaPlus) sigCount++;
+    }
+    reqDim = Math.max(16, Math.min(36, sigCount));
+  } else {
+    reqDim = Math.max(2, Math.min(1000, rawEmbDim));
+  }
+  const baseDim = Math.min(reqDim, N - 1);
+  const buildExtendedEmb = (ev) => Array.from({ length: N }, (_, i) => {
+    const vec = new Float64Array(reqDim);
+    for (let c = 0; c < baseDim; c++) {
+      vec[c] = ev.vectors[c][i] * Math.sqrt(Math.max(ev.values[c], 0));
+    }
+    if (reqDim > baseDim) {
+      let idx = baseDim;
+      const topM = Math.min(baseDim, 45);
+      for (let a = 0; a < topM && idx < reqDim; a++) {
+        for (let b = a; b < topM && idx < reqDim; b++) {
+          const scale = a === b ? 0.5 : 0.70710678;
+          vec[idx++] = vec[a] * vec[b] * scale;
+        }
+      }
+      for (let a = 0; a < topM && idx < reqDim; a++) {
+        for (let b = a + 1; b < topM && idx < reqDim; b++) {
+          for (let g = b + 1; g < topM && idx < reqDim; g++) {
+            vec[idx++] = vec[a] * vec[b] * vec[g] * 0.5;
+          }
+        }
+      }
+    }
+    return vec;
+  });
+  const normVec = (e) => {
+    let s = 0;
+    for (let c = 0; c < e.length; c++) s += e[c] * e[c];
+    const n = Math.sqrt(s) || 1;
+    const out = new Float64Array(e.length);
+    for (let c = 0; c < e.length; c++) out[c] = e[c] / n;
+    return out;
+  };
+  const d = reqDim;
+  const emb = buildExtendedEmb(eig);
+  const embN = emb.map(normVec);
   const cos = matrix(N, N);
   for (let i = 0; i < N; i++) for (let j = 0; j < N; j++) { let s = 0; for (let c = 0; c < d; c++) s += embN[i][c] * embN[j][c]; cos[i][j] = s; }
-  let eigVals = eig.values.slice(0, d);
+  let eigVals = eig.values.slice(0, baseDim);
 
   // ---------- смешивание с «текстовой» близостью (устойчивые признаки бизнеса из профилей ИИ) ----------
   // итог: cos = (1−w)·близость по поведению + w·близость по центрированным профилям;
@@ -164,13 +218,12 @@ export function buildFold(ds, { trainStart, testStart, testEnd, H, embedDim, tex
       }
       // эмбеддинги и «головы внимания» дальше используют смешанную матрицу
       const em = eigenSym(cos, { maxSweeps: 30 });
+      const extEm = buildExtendedEmb(em);
       for (let i = 0; i < N; i++) {
-        const e = Float64Array.from({ length: d }, (_, c) => em.vectors[c][i] * Math.sqrt(Math.max(em.values[c], 0)));
-        const n = Math.hypot(...e) || 1;
-        emb[i] = e;
-        embN[i] = e.map((v) => v / n);
+        emb[i] = extEm[i];
+        embN[i] = normVec(extEm[i]);
       }
-      eigVals = em.values.slice(0, d);
+      eigVals = em.values.slice(0, baseDim);
     }
   }
 
@@ -214,7 +267,7 @@ export function buildFold(ds, { trainStart, testStart, testEnd, H, embedDim, tex
     if (list.length) macro = { list };
   }
 
-  return { N, lo, hi, W, trainStart, testStart, testEnd, H, Hfast, Hslow, multiHorizon, beta, sigma, z, has, liq, X, yz, yraw, yok, emb, embN, cos, eigenvalues: eigVals, macro };
+  return { N, lo, hi, W, trainStart, testStart, testEnd, H, Hfast, Hslow, multiHorizon, beta, sigma, z, vr, has, liq, X, yz, yraw, yok, emb, embN, cos, eigenvalues: eigVals, macro };
 }
 
 // Ликвидная акция: сделки хотя бы в 15 из последних 20 свечей
@@ -330,31 +383,60 @@ export function attentionMatrices(f) {
 export function headFeatures(f, As) {
   const { N, W } = f;
   const F = HEADS.map(() => new Float32Array(W * N));
+  // По линейности умножения на матрицу внимания A (постоянную внутри фолда):
+  // сначала один раз на свечу u умножаем матрицы A[0] и A[1] на базовые ряды zp = z и zf = z * vr,
+  // а затем за O(W * N) берём скользящие суммы по 3 масштабам SCALES (в 3 раза быстрее при 100% совпадении результата)
+  const zp = f.z;
+  const zf = new Float64Array(W * N);
+  if (f.vr) {
+    for (let k = 0; k < W * N; k++) zf[k] = zp[k] * f.vr[k];
+  }
+  const A0 = As[0], A1 = As[1];
+  const Ap0 = new Float64Array(W * N), Af0 = new Float64Array(W * N);
+  const Ap1 = new Float64Array(W * N), Af1 = new Float64Array(W * N);
+  for (let u = 0; u < W; u++) {
+    const off = u * N;
+    for (let j = 0; j < N; j++) {
+      let sp0 = 0, sf0 = 0, sp1 = 0, sf1 = 0;
+      const row = j * N;
+      for (let i = 0; i < N; i++) {
+        const w0 = A0[row + i], w1 = A1[row + i];
+        const k = off + i;
+        const vp = zp[k], vf = zf[k];
+        sp0 += w0 * vp; sf0 += w0 * vf;
+        sp1 += w1 * vp; sf1 += w1 * vf;
+      }
+      const kj = off + j;
+      Ap0[kj] = sp0; Af0[kj] = sf0;
+      Ap1[kj] = sp1; Af1[kj] = sf1;
+    }
+  }
   for (let bIdx = 0; bIdx < BETAS.length; bIdx++) {
     const betaVal = BETAS[bIdx].v;
-    const A = As[bIdx];
-    const hIdxs = [];
-    for (let hi = 0; hi < HEADS.length; hi++) if (HEADS[hi].beta === betaVal) hIdxs.push(hi);
-    const Xs = hIdxs.map((hi) => f.X[HEADS[hi].kind === 'price' ? 0 : 1][HEADS[hi].scale]);
-    const Fs = hIdxs.map((hi) => F[hi]);
-    const [X0, X1, X2, X3, X4, X5] = Xs;
-    const [F0, F1, F2, F3, F4, F5] = Fs;
-    for (let u = FEATURE_WARMUP; u < W; u++) {
-      const off = u * N;
-      for (let j = 0; j < N; j++) {
-        let s0 = 0, s1 = 0, s2 = 0, s3 = 0, s4 = 0, s5 = 0;
-        const row = j * N;
-        for (let i = 0; i < N; i++) {
-          const w = A[row + i];
-          const k = off + i;
-          s0 += w * X0[k]; s1 += w * X1[k]; s2 += w * X2[k];
-          s3 += w * X3[k]; s4 += w * X4[k]; s5 += w * X5[k];
+    const Ap = bIdx === 0 ? Ap0 : Ap1;
+    const Af = bIdx === 0 ? Af0 : Af1;
+    SCALES.forEach((sc, si) => {
+      const hP = HEADS.findIndex((h) => h.beta === betaVal && h.kind === 'price' && h.scale === si);
+      const hF = HEADS.findIndex((h) => h.beta === betaVal && h.kind === 'flow' && h.scale === si);
+      const Fp = F[hP], Ff = F[hF];
+      const invP = 1 / Math.sqrt(sc.len), invF = invP / 1.5;
+      const sp = new Float64Array(N), sf = new Float64Array(N);
+      for (let u = 0; u < W; u++) {
+        const a = u - sc.from, b = u - sc.from - sc.len;
+        if (a >= 0) {
+          const offA = a * N;
+          for (let j = 0; j < N; j++) { sp[j] += Ap[offA + j]; sf[j] += Af[offA + j]; }
+        }
+        if (b >= 0) {
+          const offB = b * N;
+          for (let j = 0; j < N; j++) { sp[j] -= Ap[offB + j]; sf[j] -= Af[offB + j]; }
+        }
+        if (u >= FEATURE_WARMUP) {
+          const offU = u * N;
+          for (let j = 0; j < N; j++) { Fp[offU + j] = sp[j] * invP; Ff[offU + j] = sf[j] * invF; }
         }
-        const kj = off + j;
-        F0[kj] = s0; F1[kj] = s1; F2[kj] = s2;
-        F3[kj] = s3; F4[kj] = s4; F5[kj] = s5;
       }
-    }
+    });
   }
   return F;
 }