neuroalpha 0.6.1 → 0.6.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neuroalpha",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "НейроАльфа — ИИ-автопилот для рынка акций Мосбиржи: эмбеддинги акций, самообучение правил, коннекторы Т-Банк / БКС / Финам / Алор и боты Telegram / MAX",
   "author": "Roman A. Perepelkin",
   "license": "UNLICENSED",

package/public/app.js

@@ -1166,6 +1166,27 @@ async function loadForecast(force, silent = false) {
       nearByDay.get(dk).push(ep);
     }
     const nearDays = [...nearByDay.keys()].sort((a, b) => b.localeCompare(a));
+    const dayCountsStr = (arr) => `${arr.filter((x) => x.status === 'signal').length} сигн., ${arr.filter((x) => x.status === 'blocked').length} блок., ${arr.filter((x) => x.status === 'near').length} почти`;
+    const nearEpRow = (ep) => {
+      const tRange = ep.firstBar && ep.lastBar && ep.firstBar !== ep.lastBar ? `${ep.firstBar}–${ep.lastBar} (${ep.barsCount} св.)` : `${ep.peakBar || ep.lastBar || ''}`;
+      const isSh = ep.side === 'short';
+      const thrStr = `${isSh ? '−' : '+'}${fmtNum(ep.thresholdPct, 2)}%`;
+      const stBadge = ep.status === 'signal'
+        ? `<span class="tag ok">${isSh ? '✓ сигнал шорт' : '✓ сигнал купить'}</span>`
+        : ep.status === 'blocked'
+          ? '<span class="tag blocked">⛔ блок входа</span>'
+          : `<span class="tag mid">почти (${ep.peakRatioPct}%)</span>`;
+      const rowCls = ep.status === 'signal' ? ' class="best"' : ep.status === 'blocked' ? ' class="fc-blocked"' : '';
+      return `<tr${rowCls}>
+        <td class="muted small" style="white-space:nowrap">${esc(tRange)}</td>
+        <td style="white-space:nowrap"><span class="sym-link" data-sym="${esc(ep.symbol)}" title="Открыть досье акции ${esc(ep.symbol)}"><b>${esc(ep.symbol)}</b> <span class="muted small">${esc(ep.name || '')}</span></span></td>
+        <td class="${isSh ? 'neg' : 'pos'} small" style="white-space:nowrap">${isSh ? 'В шорт' : 'В покупку'}</td>
+        <td class="num ${cls(ep.peakExpectedPct)}" style="white-space:nowrap"><b>${fmtPct(ep.peakExpectedPct, 2)}</b></td>
+        <td class="num muted small" style="white-space:nowrap">${thrStr}</td>
+        <td class="num small" style="white-space:nowrap"><b>${ep.peakRatioPct}%</b></td>
+        <td class="small" style="white-space:normal">${stBadge} <span class="muted">${esc(ep.reasonText || '')}</span></td>
+      </tr>`;
+    };
     const buildNearInnerHtml = () => {
       if (nearDayFilter !== 'all' && !nearByDay.has(nearDayFilter)) nearDayFilter = '';
       const activeNearDay = nearDayFilter || nearDays[0] || 'all';

package/server/brokers/index.js

@@ -1706,10 +1706,19 @@ const entryImpulseWatch = new Map(); // `${accId}:${symbol}:${side}` -> { firstT
 // Фильтр затухания минутного импульса перед входом (Impulse Exhaustion):
 // не даёт продавать в шорт посередине вертикально растущей минутной свечи (или покупать в полёт падающего ножа),
 // дожидаясь остановки разгона и подтверждённого отката от пика/дна (с шагом проверки 20 секунд; без принудительного входа по таймауту)
+// Порог удержания уже взятого на прицел сигнала в entryImpulseWatch: пока ждём минутного отката,
+// само ожидание возврата к среднему неизбежно немного снижается — не теряем сигнал, пока он держится >= 90% порога (до 6 минут)
+const IMPULSE_WATCH_HOLD_RATIO = 0.90;
+const IMPULSE_WATCH_TTL_MS = 6 * 60000;
+const isOnImpulseWatch = (accId, sym, side, nowTs = Date.now()) => {
+  const w = entryImpulseWatch.get(`${accId}:${sym}:${side}`);
+  return Boolean(w && nowTs - w.firstTs <= IMPULSE_WATCH_TTL_MS && nowTs - w.lastTs <= IMPULSE_WATCH_TTL_MS);
+};
+
 async function filterByImpulseExhaustion(acc, cands, side, specs, nowTs = Date.now()) {
   if (!cands.length || acc.broker !== 'tbank' || !acc.token) return { ready: cands, deferred: [] };
   for (const [k, v] of entryImpulseWatch) {
-    if (nowTs - v.lastTs > 15 * 60000) entryImpulseWatch.delete(k);
+    if (nowTs - v.lastTs > IMPULSE_WATCH_TTL_MS || nowTs - v.firstTs > IMPULSE_WATCH_TTL_MS) entryImpulseWatch.delete(k);
   }
   const ready = [];
   const deferred = [];
@@ -1750,9 +1759,12 @@ async function filterByImpulseExhaustion(acc, cands, side, specs, nowTs = Date.n
       const pullbackPct = recentHigh > 0 ? ((recentHigh - curPx) / recentHigh) * 100 : 0;
       const pullbackTicks = recentHigh > 0 ? (recentHigh - curPx) / step : 0;
       const barTurnedDown = Boolean(last1m && prev1m && last1m.close <= last1m.open && last1m.high <= prev1m.high + step * 0.5);
+      // Если внутри самой минутной свечи цена уже взлетела до recentHigh и откатилась от пика на >= 1,4× порога отката (и >= 0,55%),
+      // разворот с вершины уже состоялся — не ждём следующей минутной свечи!
+      const intrabarReversalDown = Boolean(last1m && pullbackPct >= Math.max(0.55, minPullbackPct * 1.4) && pullbackTicks >= 4 && curPx <= last1m.high - step * 3);
       const peakedAndPulledBack = pullbackPct >= minPullbackPct && pullbackTicks >= 2 && (!last1m || last1m.close <= last1m.open + step * 0.5);
       const tickedDownFromPrev = Boolean(!isStrongSurge && prevW && curPx <= prevW.lastPx - step && pullbackTicks >= 2 && pullbackPct >= 0.12);
-      const readyShort = isStrongSurge ? (peakedAndPulledBack && barTurnedDown) : (peakedAndPulledBack || barTurnedDown || tickedDownFromPrev);
+      const readyShort = isStrongSurge ? (peakedAndPulledBack && (barTurnedDown || intrabarReversalDown)) : (peakedAndPulledBack || barTurnedDown || tickedDownFromPrev);
       if (readyShort) {
         entryImpulseWatch.delete(wKey);
         r.price = curPx;
@@ -1765,10 +1777,11 @@ async function filterByImpulseExhaustion(acc, cands, side, specs, nowTs = Date.n
       const recentLow = Math.min(prevW?.extremePx || Infinity, min1m);
       const bouncePct = Number.isFinite(recentLow) && recentLow > 0 ? ((curPx - recentLow) / recentLow) * 100 : 0;
       const bounceTicks = Number.isFinite(recentLow) && recentLow > 0 ? (curPx - recentLow) / step : 0;
-      const barTurnedUp = Boolean(last1m && prev1m && last1m.close >= last1m.open && last1m.low >= prev1m.low - step * 0.5);
+      const barTurnedUp = Boolean(last1m && prev1m && last1m.low >= prev1m.low - step * 0.5 && last1m.close >= last1m.open);
+      const intrabarReversalUp = Boolean(last1m && bouncePct >= Math.max(0.55, minPullbackPct * 1.4) && bounceTicks >= 4 && curPx >= last1m.low + step * 3);
       const bottomedAndBounced = bouncePct >= minPullbackPct && bounceTicks >= 2 && (!last1m || last1m.close >= last1m.open - step * 0.5);
       const tickedUpFromPrev = Boolean(!isStrongSurge && prevW && curPx >= prevW.lastPx + step && bounceTicks >= 2 && bouncePct >= 0.12);
-      const readyLong = isStrongSurge ? (bottomedAndBounced && barTurnedUp) : (bottomedAndBounced || barTurnedUp || tickedUpFromPrev);
+      const readyLong = isStrongSurge ? (bottomedAndBounced && (barTurnedUp || intrabarReversalUp)) : (bottomedAndBounced || barTurnedUp || tickedUpFromPrev);
       if (readyLong) {
         entryImpulseWatch.delete(wKey);
         r.price = curPx;
@@ -1972,10 +1985,14 @@ export async function prepareBrokerOrders(id, { onlyEntries = false, scheduledBa
   const divGuardOf = (sym, px) => liveDividendGuard(sym, Number(px) || specs[sym]?.lastPrice || 0, nowTs);
   const divBlocked = [];
   const entryTimeOk = timeOk && !edgeWarn && !exitsOnly;
-  const buyCands = !entryTimeOk ? [] : fc.rows.filter((r) => r.signal && r.expectedPct >= reqBuyEdgeOf(r.symbol) && !isInCooldown(r.symbol) && !isDayBlocked(r.symbol, 'buy') && !quarantined.has(r.symbol) && !nb?.get(r.symbol)?.bad)
+  const canBuyRow = (r) => (r.signal && r.expectedPct >= reqBuyEdgeOf(r.symbol))
+    || (isOnImpulseWatch(acc.id, r.symbol, 'buy', nowTs) && r.liquid && r.inIndex !== false && !r.buyBlockedByDip && !r.buyBlockedByOverheat && !r.buyBlockedByDiv && !r.buyBlockedByNews && r.expectedPct >= reqBuyEdgeOf(r.symbol) * IMPULSE_WATCH_HOLD_RATIO);
+  const canShortRow = (r) => (r.shortSignal && r.expectedPct <= -reqShortEdgeOf(r.symbol))
+    || (isOnImpulseWatch(acc.id, r.symbol, 'short', nowTs) && r.liquid && r.inIndex !== false && r.shortAllowed !== false && !r.shortBlockedBySqueeze && !r.shortBlockedByDiv && !r.shortBlockedByNews && r.expectedPct <= -reqShortEdgeOf(r.symbol) * IMPULSE_WATCH_HOLD_RATIO);
+  const buyCands = !entryTimeOk ? [] : fc.rows.filter((r) => canBuyRow(r) && !isInCooldown(r.symbol) && !isDayBlocked(r.symbol, 'buy') && !quarantined.has(r.symbol) && !nb?.get(r.symbol)?.bad)
     .filter((r) => { const g = divGuardOf(r.symbol, r.price); if (g?.blockLong) { divBlocked.push(`${r.symbol} (отсечка ${g.exDate}, ${g.yieldPct}%)`); return false; } return true; })
     .sort((a, b) => b.expectedPct - a.expectedPct).slice(0, K);
-  const allShortSignals = (rawDir !== 'long' && entryTimeOk) ? fc.rows.filter((r) => r.shortSignal && r.expectedPct <= -reqShortEdgeOf(r.symbol) && (!autoAdapt || canEnterIntraday(nowTs, H, BAR_INTERVAL, 'short', r.symbol)) && !isInCooldown(r.symbol) && !isDayBlocked(r.symbol, 'short') && !quarantined.has(r.symbol) && !nb?.get(r.symbol)?.good)
+  const allShortSignals = (rawDir !== 'long' && entryTimeOk) ? fc.rows.filter((r) => canShortRow(r) && (!autoAdapt || canEnterIntraday(nowTs, H, BAR_INTERVAL, 'short', r.symbol)) && !isInCooldown(r.symbol) && !isDayBlocked(r.symbol, 'short') && !quarantined.has(r.symbol) && !nb?.get(r.symbol)?.good)
     .filter((r) => { const g = divGuardOf(r.symbol, r.price); if (g?.blockShort) { divBlocked.push(`${r.symbol} (отсечка ${g.exDate}, ${g.yieldPct}%)`); return false; } return true; })
     .sort((a, b) => a.expectedPct - b.expectedPct) : [];
   const nonShortableSkipped = [];

package/server/model/forecast.js

@@ -19,17 +19,29 @@ const inflight = new Map();
 const inflightStartedAt = new Map();
 let nearSignalsCache = { key: null, scannedBarTs: 0, episodesMap: new Map(), list: [] };
 
-// Синхронная живая доходность индекса относительно закрытия свечи idx-1:
-// если есть живые котировки акций индекса (из Т-Банка с 0 сек задержки или из MOEX ISS),
-// считаем средневзвешенную лог-доходность по весам индекса, чтобы не сравнивать секундные цены акций Т-Банка
-// с отстающим на 15–20 минут значением IMOEX из бесплатного контура MOEX ISS!
+// Синхронная живая доходность индекса относительно базовой закрытой свечи baseIdx:
+// если последняя закрытая 10-минутная свеча idx уже закончилась (liveSnap.ts >= barTs + BAR_MS), живая цена относится к НОВОЙ
+// формирующейся свече после idx — поэтому базой служит tk.close[idx], а не tk.close[idx - 1]. Иначе два подряд растущих бара
+// складывались в одну точку и упирались в потолок 8σ одной свечи!
+const liveBaseIndexOf = (ds, idx, liveSnap) => {
+  const barTs = ds.timeline?.[idx] || 0;
+  return (liveSnap?.ts && barTs > 0 && liveSnap.ts >= barTs + BAR_MS) ? idx : Math.max(0, idx - 1);
+};
+const liveElapsedBarsOf = (ds, idx, liveSnap) => {
+  const barTs = ds.timeline?.[idx] || 0;
+  if (!(liveSnap?.ts && barTs > 0)) return 1;
+  const startTs = liveSnap.ts >= barTs + BAR_MS ? barTs + BAR_MS : barTs;
+  return Math.max(1, (liveSnap.ts - startTs) / BAR_MS);
+};
+
 function computeLiveMarketReturn(ds, idx, liveSnap) {
   if (idx < 1 || idx >= ds.T) return 0;
   if (liveSnap?.prices?.size > 0) {
+    const baseIdx = liveBaseIndexOf(ds, idx, liveSnap);
     let wSum = 0, rSum = 0, cnt = 0;
     for (const tk of ds.tokens) {
       if (tk.inIndex && !tk.inIndex[idx]) continue;
-      const prevPx = tk.close[idx - 1];
+      const prevPx = tk.close[baseIdx];
       const livePx = liveSnap.prices.get(tk.symbol);
       if (livePx > 0 && prevPx > 0) {
         const w = tk.weight > 0 ? tk.weight : 1;
@@ -39,44 +51,53 @@ function computeLiveMarketReturn(ds, idx, liveSnap) {
       }
     }
     if (cnt >= 15 && wSum > 0) return rSum / wSum;
-    const mPrev = ds.mclose?.[idx - 1] || 0;
+    const mPrev = ds.mclose?.[baseIdx] || 0;
     if (liveSnap.imoexPrice > 0 && mPrev > 0) return Math.log(liveSnap.imoexPrice / mPrev);
   }
   return ds.mret[idx] || 0;
 }
 
-// Быстрый расчёт признаков контекста в одной точке idx без переобучения матрицы внимания и весов (за ~1-2 мс)
+// Быстрый расчёт признаков контекста в одной точке idx без переобучения матрицы внимания и весов (за ~1-2 мс).
+// Выделяется дополнительный живой слот u+1, чтобы при формировании новой свечи (после закрытия idx) не затирать закрытую свечу idx!
 function buildInferenceFoldAt(ds, idx, fTrain, fitted, liveSnap = null) {
   const { tokens, mret } = ds;
   const N = fTrain.N;
   const { beta, sigma, cos } = fTrain;
   const lo = Math.max(1, idx - FEATURE_WARMUP - 2);
-  const u = idx - lo;
-  const W = u + 1;
+  const uClosed = idx - lo;
+  const barTs = ds.timeline[idx] || 0;
+  const hasNewLiveBar = Boolean(liveSnap?.prices?.size > 0 && liveSnap.ts && barTs > 0 && liveSnap.ts >= barTs + BAR_MS);
+  const u = hasNewLiveBar ? uClosed + 1 : uClosed;
+  const W = uClosed + 2;
 
   const z = new Float64Array(W * N);
   const vr = new Float64Array(W * N);
-  const barTs = ds.timeline[idx] || 0;
-  const elapsedBars = liveSnap?.ts && barTs > 0 ? Math.max(1, (liveSnap.ts - barTs) / BAR_MS) : 1;
-  const liveScale = 1 / Math.sqrt(elapsedBars);
-  const mLive = liveSnap?.prices?.size > 0 ? computeLiveMarketReturn(ds, idx, liveSnap) : (mret[idx] || 0);
-  for (let uk = 0; uk < W; uk++) {
+  for (let uk = 0; uk <= uClosed; uk++) {
     const t = lo + uk;
-    const isLast = uk === u && liveSnap?.prices?.size > 0;
-    const mt = isLast ? mLive : mret[t];
+    const mt = mret[t];
     for (let i = 0; i < N; i++) {
       const tk = tokens[i];
-      let rt = tk.ret[t];
-      if (isLast) {
-        const prevPx = tk.close[t - 1];
-        const livePx = liveSnap.prices.get(tk.symbol);
-        if (livePx > 0 && prevPx > 0) rt = Math.log(livePx / prevPx);
-      }
-      const e = (rt - beta[i] * mt) * (isLast ? liveScale : 1);
+      const e = tk.ret[t] - beta[i] * mt;
       z[uk * N + i] = Math.max(-8, Math.min(8, e / sigma[i]));
       vr[uk * N + i] = Math.min(4, tk.valRatio[t]);
     }
   }
+  vr[(uClosed + 1) * N] = 1;
+  for (let i = 0; i < N; i++) vr[(uClosed + 1) * N + i] = Math.min(4, tokens[i].valRatio[idx]);
+
+  if (liveSnap?.prices?.size > 0) {
+    const baseIdx = liveBaseIndexOf(ds, idx, liveSnap);
+    const liveScale = 1 / Math.sqrt(liveElapsedBarsOf(ds, idx, liveSnap));
+    const mLive = computeLiveMarketReturn(ds, idx, liveSnap);
+    for (let i = 0; i < N; i++) {
+      const tk = tokens[i];
+      const prevPx = tk.close[baseIdx];
+      const livePx = liveSnap.prices.get(tk.symbol);
+      const rt = (livePx > 0 && prevPx > 0) ? Math.log(livePx / prevPx) : (hasNewLiveBar ? 0 : tk.ret[idx]);
+      const e = (rt - beta[i] * mLive) * liveScale;
+      z[u * N + i] = Math.max(-8, Math.min(8, e / sigma[i]));
+    }
+  }
 
   const X = KINDS.map(() => SCALES.map(() => new Float32Array(W * N)));
   SCALES.forEach((sc, si) => {
@@ -101,17 +122,19 @@ function buildInferenceFoldAt(ds, idx, fTrain, fitted, liveSnap = null) {
     const list = fTrain.macro.list.map((mTrain) => {
       const dm = ds.macro.find((x) => x.id === mTrain.id);
       const zs = new Float32Array(SCALES.length * W);
-      if (dm) {
-        const msig = mTrain.msig || 1e-3;
-        SCALES.forEach((sc, si) => {
-          let sum = 0;
-          for (let k = 0; k < sc.len; k++) {
-            const t = idx - sc.from - k;
-            if (t >= 0) sum += Math.max(-8, Math.min(8, dm.ret[t] / msig));
+        if (dm) {
+          const msig = mTrain.msig || 1e-3;
+          for (const uk of [uClosed, uClosed + 1]) {
+            SCALES.forEach((sc, si) => {
+              let sum = 0;
+              for (let k = 0; k < sc.len; k++) {
+                const t = Math.min(idx, lo + uk - sc.from - k);
+                if (t >= 0) sum += Math.max(-8, Math.min(8, dm.ret[t] / msig));
+              }
+              zs[si * W + uk] = sum / Math.sqrt(sc.len);
+            });
           }
-          zs[si * W + u] = sum / Math.sqrt(sc.len);
-        });
-      }
+        }
       return { id: mTrain.id, label: mTrain.label, b: mTrain.b, zs };
     });
     macro = { list };
@@ -213,27 +236,33 @@ async function fetchLiveMoexSnapshot() {
   }
 }
 
-// Мгновенное обновление последней точки контекста u в уже обученной модели по живым котировкам (за ~2 мс)
-function applyLivePricesToFold(ds, f, u, fitted, liveSnap) {
-  if (!liveSnap?.prices?.size) return;
-  const idx = f.lo + u;
-  if (idx < 1 || idx >= ds.T) return;
+// Мгновенное обновление живой точки контекста в уже обученной модели по живым котировкам (за ~2 мс).
+// Возвращает индекс активной точки u (uClosed или uClosed+1, если после закрытия свечи idx уже идёт новая свеча).
+function applyLivePricesToFold(ds, f, idx, fitted, liveSnap) {
+  const uClosed = idx - f.lo;
+  if (!liveSnap?.prices?.size || idx < 1 || idx >= ds.T) return uClosed;
   const N = f.N;
-  const mLive = computeLiveMarketReturn(ds, idx, liveSnap);
   const barTs = ds.timeline[idx] || 0;
-  const elapsedBars = liveSnap.ts && barTs > 0 ? Math.max(1, (liveSnap.ts - barTs) / BAR_MS) : 1;
-  const liveScale = 1 / Math.sqrt(elapsedBars);
+  const hasNewLiveBar = Boolean(liveSnap.ts && barTs > 0 && liveSnap.ts >= barTs + BAR_MS && uClosed + 1 < f.W);
+  const u = hasNewLiveBar ? uClosed + 1 : uClosed;
+  // восстанавливаем чистую закрытую свечу idx на случай, если на предыдущем тике она обновлялась внутри свечи
+  for (let i = 0; i < N; i++) {
+    const tk = ds.tokens[i];
+    const e0 = tk.ret[idx] - f.beta[i] * ds.mret[idx];
+    f.z[uClosed * N + i] = Math.max(-8, Math.min(8, e0 / f.sigma[i]));
+  }
+  const baseIdx = liveBaseIndexOf(ds, idx, liveSnap);
+  const mLive = computeLiveMarketReturn(ds, idx, liveSnap);
+  const liveScale = 1 / Math.sqrt(liveElapsedBarsOf(ds, idx, liveSnap));
 
-  // 1) пересчитываем z[u*N + i] по живой цене акции с нормировкой к масштабу одной 10-минутной свечи
+  // 1) пересчитываем z[u*N + i] по живой цене акции относительно закрытия базовой свечи
   for (let i = 0; i < N; i++) {
     const tk = ds.tokens[i];
-    const prevPx = tk.close[idx - 1];
+    const prevPx = tk.close[baseIdx];
     const livePx = liveSnap.prices.get(tk.symbol);
-    if (livePx > 0 && prevPx > 0) {
-      const ret = Math.log(livePx / prevPx);
-      const e = (ret - f.beta[i] * mLive) * liveScale;
-      f.z[u * N + i] = Math.max(-8, Math.min(8, e / f.sigma[i]));
-    }
+    const ret = (livePx > 0 && prevPx > 0) ? Math.log(livePx / prevPx) : (hasNewLiveBar ? 0 : tk.ret[idx]);
+    const e = (ret - f.beta[i] * mLive) * liveScale;
+    f.z[u * N + i] = Math.max(-8, Math.min(8, e / f.sigma[i]));
   }
 
   // 2) пересчитываем все масштабы SCALES в точке u (как в buildInferenceFoldAt)
@@ -246,8 +275,9 @@ function applyLivePricesToFold(ds, f, u, fitted, liveSnap) {
         const uk = u - sc.from - k;
         if (uk < 0) break;
         const zk = f.z[uk * N + i];
+        const t = Math.min(idx, f.lo + uk);
         sp += zk;
-        sf += zk * Math.min(4, ds.tokens[i].valRatio[f.lo + uk]);
+        sf += zk * Math.min(4, ds.tokens[i].valRatio[t]);
       }
       Xp[u * N + i] = sp * invP;
       Xf[u * N + i] = sf * invF;
@@ -272,6 +302,7 @@ function applyLivePricesToFold(ds, f, u, fitted, liveSnap) {
       }
     }
   }
+  return u;
 }
 
 // Обучение ядра модели (карта рынка + веса внимания) выполняется не чаще 1 раза в торговый день для каждого набора параметров.
@@ -357,7 +388,8 @@ function buildPredictionRows(ds, p, idx, f, u, fitted, chosen, H, effMinEdge, au
   const idx30m = Math.max(0, idx - 3);
   const idx1d = Math.max(0, idx - bpd);
   const idx3d = Math.max(0, idx - 3 * bpd);
-  const mPrevBar = idx > 0 ? (ds.mclose?.[idx - 1] || 0) : 0;
+  const baseIdx = liveBaseIndexOf(ds, idx, liveSnap);
+  const mPrevBar = idx > 0 ? (ds.mclose?.[baseIdx] || 0) : 0;
   const mLiveRet = computeLiveMarketReturn(ds, idx, liveSnap);
   const mNow = liveSnap?.prices?.size > 0 && mPrevBar > 0
     ? mPrevBar * Math.exp(mLiveRet)
@@ -368,7 +400,7 @@ function buildPredictionRows(ds, p, idx, f, u, fitted, chosen, H, effMinEdge, au
   const rows = ds.tokens.map((tk, i) => {
     let 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 prevPx = idx > 0 ? (tk.close[idx - 1] || 0) : 0;
+    const prevPx = idx > 0 ? (tk.close[baseIdx] || 0) : 0;
     const livePx = liveSnap?.prices?.get(tk.symbol) || tk.close[idx] || 0;
     const rawBarRet = (livePx > 0 && prevPx > 0) ? Math.log(livePx / prevPx) : (tk.ret?.[idx] || 0);
     const rawResPct = (rawBarRet - f.beta[i] * mLiveRet) * 100;
@@ -742,11 +774,12 @@ const fmtLiveBarLabel = (barTs, liveSnapTs) => {
 // Мгновенный пересчёт последнего среза прогноза по живым секундным котировкам (без обращения к истории свечей)
 async function tickLiveForecastState(p, now = Date.now()) {
   const liveSnap = await fetchLiveMoexSnapshot();
-  if (liveSnap) applyLivePricesToFold(baseState.ds, baseState.f, baseState.u, baseState.fitted, liveSnap);
+  const uActive = liveSnap ? applyLivePricesToFold(baseState.ds, baseState.f, baseState.last, baseState.fitted, liveSnap) : baseState.u;
+  baseState.u = uActive;
   const effHorizon = p.modelAutoAdapt !== false ? 2.5 : p.modelHorizon;
   const effMinEdge = p.modelAutoAdapt !== false ? 2.5 : p.modelMinEdge;
   const H = barsFromHours(effHorizon);
-  const r = buildPredictionRows(baseState.ds, p, baseState.last, baseState.f, baseState.u, baseState.fitted, baseState.chosen, H, effMinEdge, p.modelAutoAdapt !== false, true, liveSnap);
+  const r = buildPredictionRows(baseState.ds, p, baseState.last, baseState.f, uActive, baseState.fitted, baseState.chosen, H, effMinEdge, p.modelAutoAdapt !== false, true, liveSnap);
   const sortedRows = r.rows.map(({ i, expected, ...x }) => ({ ...x, cluster: baseState.snap.clusters[i] })).sort((a, b) => b.expectedPct - a.expectedPct);
   attachDeltas(sortedRows, baseState);
   const liveTs = liveSnap?.ts || now;