neuroalpha 0.3.13 → 0.3.15

package/server/model/forecast.js

@@ -1,21 +1,127 @@
 // Copyright (c) 2026 Roman A. Perepelkin. All rights reserved. Proprietary software.
 import { normalizeParams } from '../settings.js';
-import { round, DAY, fmtBarMsk } from '../util.js';
+import { round, DAY, MSK, fmtBarMsk } from '../util.js';
 import { loadDataset, barsFromHours, BAR_MS } from './dataset.js';
-import { buildFold, MODELS, HEADS, SCALES, BETAS, LIQ_MIN, FEATURE_WARMUP, explainAttention, mapSnapshot } from './models.js';
+import { buildFold, MODELS, HEADS, KINDS, SCALES, BETAS, LIQ_MIN, FEATURE_WARMUP, explainAttention, mapSnapshot } from './models.js';
 import { loadProfiles } from './profiles.js';
 import { isMarketDown } from './research.js';
 import { newsForSymbols } from '../news/index.js';
 
+const trainedModelCache = new Map(); // fitKey -> { dayMsk, trainedAt, fTrain, fitted, snap }
 let baseState = null; // { key, trainedAt, ds, last, r, snap, prevExpMap, prevRankMap, lastTickResult, lastTickAt }
 const inflight = new Map();
 
+// Быстрый расчёт признаков контекста в одной точке idx без переобучения матрицы внимания и весов (за ~1-2 мс)
+function buildInferenceFoldAt(ds, idx, fTrain, fitted, liveSnap = null) {
+  const { tokens, mret, mclose } = 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 z = new Float64Array(W * N);
+  const vr = new Float64Array(W * N);
+  for (let uk = 0; uk < W; uk++) {
+    const t = lo + uk;
+    const isLast = uk === u && liveSnap?.prices?.size > 0;
+    const mPrev = mclose?.[t - 1] || 0;
+    const mt = isLast && liveSnap.imoexPrice > 0 && mPrev > 0 ? Math.log(liveSnap.imoexPrice / mPrev) : 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;
+      z[uk * N + i] = Math.max(-8, Math.min(8, e / sigma[i]));
+      vr[uk * N + i] = Math.min(4, tk.valRatio[t]);
+    }
+  }
+
+  const X = KINDS.map(() => SCALES.map(() => new Float32Array(W * N)));
+  SCALES.forEach((sc, si) => {
+    const Xp = X[0][si], Xf = 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 = z[uk * N + i];
+        sp += zk;
+        sf += zk * vr[uk * N + i];
+      }
+      Xp[u * N + i] = sp * invP;
+      Xf[u * N + i] = sf * invF;
+    }
+  });
+
+  let macro = null;
+  if (fTrain.macro?.list?.length && ds.macro?.length) {
+    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));
+          }
+          zs[si * W + u] = sum / Math.sqrt(sc.len);
+        });
+      }
+      return { id: mTrain.id, label: mTrain.label, b: mTrain.b, zs };
+    });
+    macro = { list };
+  }
+
+  const f = { N, lo, hi: idx + 1, W, beta, sigma, z, X, cos, emb: fTrain.emb, embN: fTrain.embN, macro };
+  const att = fitted.attention;
+  let fittedForStep = fitted;
+  if (att?.As) {
+    const F = HEADS.map(() => new Float32Array(W * N));
+    const off = u * N;
+    for (let hi = 0; hi < HEADS.length; hi++) {
+      const h = HEADS[hi];
+      const bIdx = BETAS.findIndex((b) => b.v === h.beta);
+      const A = att.As[bIdx];
+      const Xh = X[h.kind === 'price' ? 0 : 1][h.scale];
+      const Fh = F[hi];
+      for (let j = 0; j < N; j++) {
+        let s = 0;
+        const row = j * N;
+        for (let i = 0; i < N; i++) s += A[row + i] * Xh[off + i];
+        Fh[off + j] = s;
+      }
+    }
+    fittedForStep = { ...fitted, attention: { ...att, F } };
+  }
+  return { f, u, fitted: fittedForStep };
+}
+
 export const lastClosedIndex = (ds, now = Date.now()) => {
   let last = ds.T - 1;
   while (last > 0 && ds.timeline[last] + BAR_MS > now) last--;
   return last;
 };
 
+export const isModelTrainedToday = (p, now = Date.now()) => {
+  const autoAdapt = p.modelAutoAdapt !== false;
+  const effHorizon = autoAdapt ? 2.5 : p.modelHorizon;
+  const chosen = p.modelType in MODELS ? p.modelType : 'attention';
+  const todayMsk = new Date(now + MSK).toISOString().slice(0, 10);
+  const prefix = JSON.stringify([autoAdapt, chosen, effHorizon, p.modelTrainDays, p.modelEmbedDim, p.modelUseMacro, p.modelUseDividends, p.modelTextWeight]).slice(0, -1);
+  for (const [k, v] of trainedModelCache) {
+    if (v.dayMsk === todayMsk && k.startsWith(prefix)) return true;
+  }
+  return false;
+};
+
 // Быстрое получение живых цен Мосбиржи (TQBR + IMOEX) за 1 лёгкий запрос (~80 мс)
 async function fetchLiveMoexSnapshot() {
   try {
@@ -107,28 +213,63 @@ function applyLivePricesToFold(ds, f, u, fitted, liveSnap) {
   }
 }
 
-// Обучение на окне, заканчивающемся свечой idx, и прогноз по этой свече.
-// Возвращает строки по всем акциям: ожидаемое движение (относительно рынка), сигнал покупки, кто влияет.
-export async function predictAt(ds, p, idx, { explain = true, liveSnap = null } = {}) {
+// Обучение ядра модели (карта рынка + веса внимания) выполняется не чаще 1 раза в торговый день для каждого набора параметров.
+// На всех свечах внутри дня выполняется быстрый расчёт прогноза по уже обученным весам (buildInferenceFoldAt).
+export async function predictAt(ds, p, idx, { explain = true, liveSnap = null, forceTrain = false } = {}) {
   const autoAdapt = p.modelAutoAdapt !== false;
   const effHorizon = autoAdapt ? 2.5 : p.modelHorizon;
   const effMinEdge = autoAdapt ? 2.5 : p.modelMinEdge;
   const H = barsFromHours(effHorizon);
   const maxH = autoAdapt ? Math.round(H * 1.4) : H;
+  const chosen = p.modelType in MODELS ? p.modelType : 'attention';
+  const fitKey = JSON.stringify([autoAdapt, chosen, effHorizon, p.modelTrainDays, p.modelEmbedDim, p.modelUseMacro, p.modelUseDividends, p.modelTextWeight, ds.tokens.length]);
+  const barDayMsk = new Date((ds.timeline[idx] || Date.now()) + MSK).toISOString().slice(0, 10);
+
+  const cached = trainedModelCache.get(fitKey);
+  if (!forceTrain && cached && cached.dayMsk === barDayMsk && cached.fTrain.N === ds.tokens.length) {
+    const inf = buildInferenceFoldAt(ds, idx, cached.fTrain, cached.fitted, liveSnap);
+    return {
+      ...buildPredictionRows(ds, p, idx, inf.f, inf.u, inf.fitted, chosen, H, effMinEdge, autoAdapt, explain, liveSnap),
+      snap: cached.snap,
+      trainedAt: cached.trainedAt,
+    };
+  }
+
   const trainLen = Math.round(p.modelTrainDays * ds.barsPerDay);
   const trainStart = Math.max(FEATURE_WARMUP + maxH + 2, idx - trainLen);
-  // «текстовая» часть карты: устойчивые описания бизнеса (профили готовятся отдельно, здесь только читаем)
   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 chosen = p.modelType in MODELS ? p.modelType : 'attention';
   const list = [...new Set(explain ? Object.keys(MODELS) : ['attention', chosen])];
   const fitted = {};
   for (const n of list) {
     fitted[n] = await MODELS[n].fit(f);
   }
+  const snap = mapSnapshot(f);
+  // Освобождаем тяжёлые полные 90-дневные буферы признаков из памяти, оставляя только структурное ядро модели на день
+  const fTrain = {
+    N: f.N,
+    beta: f.beta,
+    sigma: f.sigma,
+    cos: f.cos,
+    emb: f.emb,
+    embN: f.embN,
+    eigenvalues: f.eigenvalues,
+    macro: f.macro ? { list: f.macro.list.map((m) => ({ id: m.id, label: m.label, b: m.b })) } : null,
+  };
+  const lightFitted = {
+    ...fitted,
+    ...(fitted.attention ? { attention: { ...fitted.attention, F: null } } : {}),
+  };
+  const trainedAt = Date.now();
+  trainedModelCache.set(fitKey, { dayMsk: barDayMsk, trainedAt, fTrain, fitted: lightFitted, snap });
+
   if (liveSnap) applyLivePricesToFold(ds, f, u, fitted, liveSnap);
-  return buildPredictionRows(ds, p, idx, f, u, fitted, chosen, H, effMinEdge, autoAdapt, explain, liveSnap);
+  return {
+    ...buildPredictionRows(ds, p, idx, f, u, fitted, chosen, H, effMinEdge, autoAdapt, explain, liveSnap),
+    snap,
+    trainedAt,
+  };
 }
 
 function buildPredictionRows(ds, p, idx, f, u, fitted, chosen, H, effMinEdge, autoAdapt, explain, liveSnap = null) {
@@ -210,6 +351,14 @@ function attachDeltas(rows, stateObj) {
   }
 }
 
+const fmtLiveBarLabel = (barTs, liveSnapTs) => {
+  if (liveSnapTs && (!barTs || liveSnapTs > barTs + BAR_MS)) {
+    const liveTime = fmtBarMsk(liveSnapTs).slice(-5);
+    return `${fmtBarMsk(barTs || liveSnapTs)} · котировки ${liveTime}`;
+  }
+  return fmtBarMsk(barTs || liveSnapTs || Date.now());
+};
+
 // Прогноз на ближайшие H часов с живым поминутным обновлением котировок (без переобучения тяжёлого окна каждую минуту)
 export async function forecastNow(input, { force = false, onProgress } = {}) {
   const p = normalizeParams(input);
@@ -223,18 +372,21 @@ export async function forecastNow(input, { force = false, onProgress } = {}) {
   if (!force && baseState && baseState.key === key && baseState.lastTickResult && now - baseState.lastTickAt < 15000) {
     return withNews(baseState.lastTickResult, p);
   }
-  // 2) Если базовая модель обучена менее 10 минут назад и нет force — делаем быстрый живой пересчёт (~80 мс запрос + 2 мс математика)
-  if (!force && baseState && baseState.key === key && now - baseState.trainedAt < 10 * 60000) {
+  // 2) Если срез свечей обновлялся менее 2 минут назад и нет force — делаем быстрый живой пересчёт (~80 мс запрос + 2 мс математика)
+  if (!force && baseState && baseState.key === key && now - baseState.dsLoadedAt < 2 * 60000) {
     const liveSnap = await fetchLiveMoexSnapshot();
     if (liveSnap) applyLivePricesToFold(baseState.ds, baseState.f, baseState.u, baseState.fitted, liveSnap);
     const H = barsFromHours(effHorizon);
     const r = buildPredictionRows(baseState.ds, p, baseState.last, baseState.f, baseState.u, baseState.fitted, baseState.chosen, H, effMinEdge, autoAdapt, 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;
+    const barTs = baseState.ds.timeline[baseState.last];
     const result = {
       ...baseState.lastTickResult,
       at: now,
-      liveTs: liveSnap?.ts || now,
+      liveTs,
+      bar: fmtLiveBarLabel(barTs, liveSnap ? liveTs : null),
       rows: sortedRows,
     };
     baseState.lastTickResult = result;
@@ -244,21 +396,26 @@ export async function forecastNow(input, { force = false, onProgress } = {}) {
 
   if (!force && inflight.has(key)) return withNews(await inflight.get(key), p);
   const task = (async () => {
+    const trainedToday = !force && isModelTrainedToday(p, now);
+    const windowDays = trainedToday ? 7 : Math.ceil(p.modelTrainDays * 1.5 + 25);
     const [ds, liveSnap] = await Promise.all([
-      loadDataset({ fromTs: now - Math.ceil(p.modelTrainDays * 1.5 + 25) * DAY, tillTs: now, useMacro: p.modelUseMacro, useDividends: p.modelUseDividends, onProgress }),
+      loadDataset({ fromTs: now - windowDays * DAY, tillTs: now, useMacro: p.modelUseMacro, useDividends: p.modelUseDividends, onProgress }),
       fetchLiveMoexSnapshot(),
     ]);
     const last = lastClosedIndex(ds, now);
-    const r = await predictAt(ds, p, last, { explain: true, liveSnap });
-    const snap = mapSnapshot(r.f);
+    const r = await predictAt(ds, p, last, { explain: true, liveSnap, forceTrain: Boolean(force) });
+    const snap = r.snap || mapSnapshot(r.f);
     const sortedRows = r.rows.map(({ i, expected, ...x }) => ({ ...x, cluster: snap.clusters[i] })).sort((a, b) => b.expectedPct - a.expectedPct);
     const stateObj = baseState && baseState.key === key ? baseState : { prevExpMap: null, prevRankMap: null };
     attachDeltas(sortedRows, stateObj);
+    const liveTs = liveSnap?.ts || now;
+    const barTs = ds.timeline[last];
     const result = {
       at: now,
-      liveTs: liveSnap?.ts || now,
-      barTs: ds.timeline[last],
-      bar: fmtBarMsk(ds.timeline[last]),
+      trainedAt: r.trainedAt || now,
+      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,
       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 },
@@ -266,7 +423,8 @@ export async function forecastNow(input, { force = false, onProgress } = {}) {
     };
     baseState = {
       key,
-      trainedAt: now,
+      trainedAt: r.trainedAt || now,
+      dsLoadedAt: now,
       ds,
       last,
       f: r.f,

package/server/model/live.js

@@ -5,7 +5,7 @@ import { round, DAY, MSK, fmtBarMsk } from '../util.js';
 import { hub } from '../hub.js';
 import { latestBarTs } from '../data/moex.js';
 import { loadDataset, barsFromHours, BAR_MS, BAR_INTERVAL } from './dataset.js';
-import { predictAt, lastClosedIndex } from './forecast.js';
+import { predictAt, lastClosedIndex, isModelTrainedToday } from './forecast.js';
 import { computeReport, downsample } from './metrics.js';
 import { MODELS } from './models.js';
 import { blockingNews } from '../news/index.js';
@@ -90,12 +90,32 @@ class LiveEngine {
       const status = returnPct < expPct - bandPct ? 'below' : returnPct > expPct + bandPct ? 'above' : 'inside';
       corridor = { runId: s.benchmark.runId, expectedPct: expPct, bandPct, minPct: round(expPct - bandPct, 1), maxPct: round(expPct + bandPct, 1), histReturnPct: s.benchmark.returnPct, histMaxDdPct: s.benchmark.maxDrawdownPct, status };
     }
+    const tradesList = [...(s.trades || [])].reverse().slice(0, 120).map((t) => ({
+      symbol: t.symbol,
+      side: t.side || 'long',
+      qty: t.qty || 0,
+      entryTs: t.entryTs,
+      exitTs: t.exitTs,
+      entryPrice: t.entryPrice || 0,
+      exitPrice: t.exitPrice || 0,
+      pnl: round(Number(t.pnl || 0), 2),
+      pnlPct: round(Number(t.pnlPct || 0), 2),
+      commission: round(Number(t.commission || 0), 2),
+      barsHeld: t.barsHeld || 0,
+      reasonEntry: t.reasonEntry || '',
+      reasonExit: t.reasonExit || '',
+    }));
+    const realizedPnl = round((s.trades || []).reduce((sum, t) => sum + (Number(t.pnl) || 0), 0), 2);
+    const totalCommission = round((s.trades || []).reduce((sum, t) => sum + (Number(t.commission) || 0), 0), 2);
     return {
       running: s.running, runId: s.runId, name: s.name || `Виртуальный счёт №${s.runId}`,
       baseRunId: s.baseRunId || null, benchmark: s.benchmark || null, corridor,
       params: s.params, startedAt: s.startedAt, stoppedAt: s.stoppedAt || null, lastBarTs: s.lastBarTs,
       error: s.error, busy: s.busy, snapshot: snap, returnPct, pnl,
-      recent: s.recent.slice(0, 20), metrics: s.metrics,
+      realizedPnl, totalCommission,
+      trades: tradesList,
+      curve: downsample(s.curve || [], 120),
+      recent: s.recent.slice(0, 25), metrics: s.metrics,
     };
   }
 
@@ -179,7 +199,9 @@ class LiveEngine {
       if (!run || run.mode !== 'paper' || !st.params?.modelHorizon) continue;
       const isRunning = Boolean(st.running && run.status === 'running');
       const trades = getTrades(st.runId).map((t) => ({
-        symbol: t.symbol, side: t.side, pnl: t.pnl, pnlPct: t.pnl_pct, entryTs: t.entry_ts, exitTs: t.exit_ts, commission: t.commission,
+        symbol: t.symbol, side: t.side, qty: t.qty, entryPrice: t.entry_price, exitPrice: t.exit_price,
+        pnl: t.pnl, pnlPct: t.pnl_pct, entryTs: t.entry_ts, exitTs: t.exit_ts, commission: t.commission,
+        reasonEntry: t.reason_entry, reasonExit: t.reason_exit,
         barsHeld: Math.round((t.exit_ts - t.entry_ts) / 600000) * BAR_INTERVAL,
       }));
       const curve = st.curve || [];
@@ -239,7 +261,9 @@ class LiveEngine {
     try {
       const p = s.params;
       const now = Date.now();
-      const ds = await loadDataset({ fromTs: now - Math.ceil(p.modelTrainDays * 1.5 + 25) * DAY, tillTs: now, useMacro: p.modelUseMacro, useDividends: p.modelUseDividends !== false });
+      const trainedToday = isModelTrainedToday(p, now);
+      const windowDays = trainedToday ? 7 : Math.ceil(p.modelTrainDays * 1.5 + 25);
+      const ds = await loadDataset({ fromTs: now - windowDays * DAY, tillTs: now, useMacro: p.modelUseMacro, useDividends: p.modelUseDividends !== false });
       s.lastSeenTs = latest;
       changed = true;
       const bySym = new Map(ds.tokens.map((t, i) => [t.symbol, i]));
@@ -308,7 +332,7 @@ class LiveEngine {
     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.45, Math.max(1 / K, 1.35 / K)) : Math.min(0.35, 1.4 / (2 * K));
+    const maxSlotWeight = dir === 'long' ? Math.min(0.48, Math.max(1 / K, 1.4 / K)) : Math.min(0.48, 1.9 / (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);
@@ -320,7 +344,7 @@ class LiveEngine {
       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.20, Math.max(0.85, 0.80 + 0.20 * (Math.abs(o.expectedPct) / needPct))) : 1;
+      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));
       let alloc = baseAlloc;
       if (invVol && o.weight > 0) {
@@ -356,7 +380,7 @@ class LiveEngine {
     const autoAdapt = p.modelAutoAdapt !== false;
     const effHorizon = autoAdapt ? 2.5 : p.modelHorizon;
     const H = barsFromHours(effHorizon);
-    const stepBars = autoAdapt ? Math.max(2, Math.floor(H / 2)) : H;
+    const stepBars = autoAdapt ? Math.max(3, Math.floor(H / 5)) : H;
     if (s.barsSinceRebalance >= stepBars) {
       await new Promise((r) => setImmediate(r));
       const r = await predictAt(ds, p, idx);

package/server/model/research.js

@@ -312,8 +312,8 @@ async function run(runId, p, state) {
     const stockPnl = new Float64Array(N), stockCnt = new Float64Array(N);
     const stockAllowed = (i) => !autoAdapt || !(stockCnt[i] >= 3 && stockPnl[i] < -0.012);
     let curExitRatio = autoAdapt ? 0.95 : exitRatio;
-    const stepBars = autoAdapt ? Math.max(2, Math.floor(H / 2)) : 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 stepBars = autoAdapt ? Math.max(3, Math.floor(H / 5)) : H;
+    const maxSlotWeight = dir === 'long' ? Math.min(0.48, Math.max(1 / K, 1.4 / K)) : Math.min(0.48, 1.9 / (2 * K));
 
     const closePos = (i, h, t, end, why) => {
       const exitPrice = px(i, t);
@@ -405,7 +405,7 @@ async function run(runId, p, state) {
       for (let idx = 0; idx < newEntries.length; idx++) {
         const [i, side, edgeAt] = newEntries[idx];
         const effEdge = edgeAt !== null ? Math.abs(edgeAt) : (sg ? Math.abs(pr[i] * sg[i] * Math.sqrt(H)) : 0);
-        const conv = autoAdapt && needEdge > 0 && effEdge > 0 ? Math.min(1.20, Math.max(0.85, 0.80 + 0.20 * (effEdge / needEdge))) : 1;
+        const conv = autoAdapt && needEdge > 0 && effEdge > 0 ? Math.min(1.25, Math.max(0.85, 0.80 + 0.25 * (effEdge / needEdge))) : 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));
         let alloc = baseAlloc;
         if (invVol && avgInv > 0 && sg[i] > 0) {