neuroalpha 0.3.17 → 0.5.1

package/server/instance/provision.js

@@ -0,0 +1,166 @@
+// Copyright (c) 2026 Roman A. Perepelkin. All rights reserved. Proprietary software.
+// Автоматическое развёртывание облачных машин клиентов. Драйвер выбирается переменной PAAS_DRIVER:
+//   k8s     — напрямую через API Kubernetes (server-side apply). Внутри кластера берётся токен сервисного аккаунта,
+//             снаружи — K8S_API_URL + K8S_TOKEN (+ K8S_CA_FILE)
+//   webhook — POST на PAAS_WEBHOOK_URL с подписью HMAC-SHA256 (заголовок X-NA-Signature) — для собственного PaaS
+//   none    — по умолчанию: машины разворачиваются вручную по шаблону deploy/k8s/instance.yaml
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import https from 'node:https';
+import tls from 'node:tls';
+
+export const PAAS_DRIVER = String(process.env.PAAS_DRIVER || 'none').trim().toLowerCase();
+const IMAGE = String(process.env.INSTANCE_IMAGE || 'registry.odant.org/neuroalpha:latest').trim();
+const INGRESS_CLASS = String(process.env.INSTANCE_INGRESS_CLASS || 'nginx').trim();
+const TLS_SECRET = String(process.env.INSTANCE_TLS_SECRET || 'odant-wildcard-tls').trim();
+const STORAGE = String(process.env.INSTANCE_STORAGE || '5Gi').trim();
+const STORAGE_CLASS = String(process.env.INSTANCE_STORAGE_CLASS || '').trim();
+const FIELD_MANAGER = 'neuroalpha-central';
+
+export const provisioningEnabled = () => PAAS_DRIVER === 'k8s' || PAAS_DRIVER === 'webhook';
+
+// ---------- манифесты машины (то же, что deploy/k8s/instance.yaml) ----------
+function manifests(inst, env) {
+  const ns = inst.id;
+  const labels = { 'app.kubernetes.io/part-of': 'neuroalpha', 'neuroalpha/instance': inst.id };
+  const app = { app: 'neuroalpha' };
+  return [
+    { apiVersion: 'v1', kind: 'Namespace', metadata: { name: ns, labels } },
+    { apiVersion: 'v1', kind: 'Secret', metadata: { name: 'neuroalpha-instance', namespace: ns, labels }, type: 'Opaque', stringData: env },
+    {
+      apiVersion: 'v1', kind: 'PersistentVolumeClaim', metadata: { name: 'neuroalpha-data', namespace: ns, labels },
+      spec: { accessModes: ['ReadWriteOnce'], resources: { requests: { storage: STORAGE } }, ...(STORAGE_CLASS ? { storageClassName: STORAGE_CLASS } : {}) },
+    },
+    {
+      apiVersion: 'apps/v1', kind: 'Deployment', metadata: { name: 'neuroalpha', namespace: ns, labels },
+      spec: {
+        replicas: 1,
+        strategy: { type: 'Recreate' },
+        selector: { matchLabels: app },
+        template: {
+          metadata: { labels: { ...app, ...labels }, annotations: { 'neuroalpha/key-rev': crypto.createHash('sha256').update(env.INSTANCE_KEY).digest('hex').slice(0, 12) } },
+          spec: {
+            securityContext: { runAsNonRoot: true, runAsUser: 1000, fsGroup: 1000 },
+            containers: [{
+              name: 'neuroalpha',
+              image: IMAGE,
+              ports: [{ containerPort: 3000 }],
+              envFrom: [{ secretRef: { name: 'neuroalpha-instance' } }],
+              volumeMounts: [{ name: 'data', mountPath: '/data' }],
+              resources: { requests: { cpu: '500m', memory: '1Gi' }, limits: { cpu: '2', memory: '3Gi' } },
+              readinessProbe: { httpGet: { path: '/healthz', port: 3000 }, initialDelaySeconds: 10, periodSeconds: 15 },
+              livenessProbe: { httpGet: { path: '/healthz', port: 3000 }, initialDelaySeconds: 60, periodSeconds: 30, failureThreshold: 4 },
+              securityContext: { allowPrivilegeEscalation: false, capabilities: { drop: ['ALL'] } },
+            }],
+            volumes: [{ name: 'data', persistentVolumeClaim: { claimName: 'neuroalpha-data' } }],
+          },
+        },
+      },
+    },
+    { apiVersion: 'v1', kind: 'Service', metadata: { name: 'neuroalpha', namespace: ns, labels }, spec: { selector: app, ports: [{ port: 80, targetPort: 3000 }] } },
+    {
+      apiVersion: 'networking.k8s.io/v1', kind: 'Ingress',
+      metadata: { name: 'neuroalpha', namespace: ns, labels, annotations: { 'nginx.ingress.kubernetes.io/proxy-read-timeout': '3600', 'nginx.ingress.kubernetes.io/proxy-send-timeout': '3600' } },
+      spec: {
+        ingressClassName: INGRESS_CLASS,
+        tls: [{ hosts: [inst.host], secretName: TLS_SECRET }],
+        rules: [{ host: inst.host, http: { paths: [{ path: '/', pathType: 'Prefix', backend: { service: { name: 'neuroalpha', port: { number: 80 } } } }] } }],
+      },
+    },
+    {
+      apiVersion: 'networking.k8s.io/v1', kind: 'NetworkPolicy', metadata: { name: 'neuroalpha-ingress-only', namespace: ns, labels },
+      spec: {
+        podSelector: { matchLabels: app },
+        policyTypes: ['Ingress'],
+        ingress: [{ from: [{ namespaceSelector: { matchLabels: { 'kubernetes.io/metadata.name': String(process.env.INSTANCE_INGRESS_NAMESPACE || 'ingress-nginx') } } }], ports: [{ port: 3000 }] }],
+      },
+    },
+  ];
+}
+
+// ---------- драйвер k8s ----------
+function k8sConfig() {
+  const saDir = '/var/run/secrets/kubernetes.io/serviceaccount';
+  const inCluster = process.env.KUBERNETES_SERVICE_HOST && fs.existsSync(`${saDir}/token`);
+  const apiUrl = String(process.env.K8S_API_URL || (inCluster ? `https://${process.env.KUBERNETES_SERVICE_HOST}:${process.env.KUBERNETES_SERVICE_PORT || 443}` : '')).replace(/\/+$/, '');
+  const token = String(process.env.K8S_TOKEN || (inCluster ? fs.readFileSync(`${saDir}/token`, 'utf8') : '')).trim();
+  const caFile = String(process.env.K8S_CA_FILE || (inCluster ? `${saDir}/ca.crt` : '')).trim();
+  if (!apiUrl || !token) throw new Error('PAAS_DRIVER=k8s: не заданы K8S_API_URL и K8S_TOKEN (или сервер запущен вне кластера)');
+  const ca = caFile && fs.existsSync(caFile) ? [...tls.rootCertificates, fs.readFileSync(caFile, 'utf8')] : undefined;
+  return { apiUrl, token, ca };
+}
+
+const PLURAL = { Namespace: 'namespaces', Secret: 'secrets', PersistentVolumeClaim: 'persistentvolumeclaims', Deployment: 'deployments', Service: 'services', Ingress: 'ingresses', NetworkPolicy: 'networkpolicies' };
+
+function objectPath(o) {
+  const base = o.apiVersion === 'v1' ? '/api/v1' : `/apis/${o.apiVersion}`;
+  const plural = PLURAL[o.kind];
+  if (o.kind === 'Namespace') return `${base}/namespaces/${o.metadata.name}`;
+  return `${base}/namespaces/${o.metadata.namespace}/${plural}/${o.metadata.name}`;
+}
+
+function k8sRequest(cfg, method, urlPath, body, contentType = 'application/json') {
+  return new Promise((resolve, reject) => {
+    const u = new URL(cfg.apiUrl + urlPath);
+    const data = body ? Buffer.from(typeof body === 'string' ? body : JSON.stringify(body)) : null;
+    const req = https.request({
+      hostname: u.hostname, port: u.port || 443, path: u.pathname + u.search, method, ca: cfg.ca, timeout: 20000,
+      headers: { Authorization: `Bearer ${cfg.token}`, Accept: 'application/json', ...(data ? { 'Content-Type': contentType, 'Content-Length': data.length } : {}) },
+    }, (res) => {
+      let t = '';
+      res.setEncoding('utf8');
+      res.on('data', (c) => { t += c; });
+      res.on('end', () => resolve({ status: res.statusCode, text: t }));
+    });
+    req.on('timeout', () => req.destroy(new Error('Kubernetes API: таймаут')));
+    req.on('error', reject);
+    if (data) req.write(data);
+    req.end();
+  });
+}
+
+async function k8sApply(inst, env) {
+  const cfg = k8sConfig();
+  for (const o of manifests(inst, env)) {
+    const r = await k8sRequest(cfg, 'PATCH', `${objectPath(o)}?fieldManager=${FIELD_MANAGER}&force=true`, o, 'application/apply-patch+yaml');
+    if (r.status >= 300) throw new Error(`Kubernetes ${o.kind}: HTTP ${r.status} ${r.text.slice(0, 200)}`);
+  }
+}
+
+async function k8sDelete(inst) {
+  const cfg = k8sConfig();
+  const r = await k8sRequest(cfg, 'DELETE', `/api/v1/namespaces/${inst.id}`);
+  if (r.status >= 300 && r.status !== 404) throw new Error(`Kubernetes Namespace: HTTP ${r.status} ${r.text.slice(0, 200)}`);
+}
+
+// ---------- драйвер webhook (собственный PaaS) ----------
+async function webhook(action, inst, env = null) {
+  const url = String(process.env.PAAS_WEBHOOK_URL || '').trim();
+  const secret = String(process.env.PAAS_WEBHOOK_SECRET || '').trim();
+  if (!url || !secret) throw new Error('PAAS_DRIVER=webhook: не заданы PAAS_WEBHOOK_URL и PAAS_WEBHOOK_SECRET');
+  const body = JSON.stringify({
+    action, // apply | delete
+    instanceId: inst.id,
+    host: inst.host,
+    image: IMAGE,
+    env, // переменные для Secret (только при apply)
+    manifests: env ? manifests(inst, env) : undefined,
+    ts: Date.now(),
+  });
+  const sig = crypto.createHmac('sha256', secret).update(body).digest('hex');
+  const r = await fetch(url, { method: 'POST', headers: { 'Content-Type': 'application/json', 'X-NA-Signature': `sha256=${sig}` }, body, signal: AbortSignal.timeout(30000) });
+  if (!r.ok) throw new Error(`PaaS webhook ${action}: HTTP ${r.status} ${(await r.text().catch(() => '')).slice(0, 200)}`);
+}
+
+// ---------- общий интерфейс ----------
+export async function provisionApply(inst, env) {
+  if (PAAS_DRIVER === 'k8s') return k8sApply(inst, env);
+  if (PAAS_DRIVER === 'webhook') return webhook('apply', inst, env);
+  throw new Error('Автоматическое развёртывание выключено (PAAS_DRIVER=none)');
+}
+
+export async function provisionDelete(inst) {
+  if (PAAS_DRIVER === 'k8s') return k8sDelete(inst);
+  if (PAAS_DRIVER === 'webhook') return webhook('delete', inst);
+  return null;
+}

package/server/instance/signing.js

@@ -0,0 +1,71 @@
+// Copyright (c) 2026 Roman A. Perepelkin. All rights reserved. Proprietary software.
+// Подписанные токены центра (Ed25519): лицензия машины и одноразовый вход (SSO).
+// Формат: base64url(JSON-полезная нагрузка) + "." + base64url(подпись)
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { DATA_DIR } from '../config.js';
+import { centralPublicKeyCandidates } from './identity.js';
+
+const ISSUER = 'neuroalpha-central';
+
+const b64u = (buf) => Buffer.from(buf).toString('base64url');
+
+// ---------- ключ подписи центра ----------
+let privateKey = null;
+let publicKeyPem = '';
+
+function loadSigningKey() {
+  if (privateKey) return privateKey;
+  const envPem = String(process.env.LICENSE_SIGNING_KEY || '').trim();
+  const file = String(process.env.LICENSE_SIGNING_KEY_FILE || '').trim() || path.join(DATA_DIR, '.license-ed25519.pem');
+  let pem = envPem.includes('BEGIN') ? envPem.replace(/\\n/g, '\n') : '';
+  if (!pem && fs.existsSync(file)) pem = fs.readFileSync(file, 'utf8');
+  if (!pem) {
+    const { privateKey: k } = crypto.generateKeyPairSync('ed25519');
+    pem = k.export({ type: 'pkcs8', format: 'pem' });
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, pem, { mode: 0o600 });
+    console.log(`✓ Создан ключ подписи лицензий центра: ${file}`);
+  }
+  privateKey = crypto.createPrivateKey(pem);
+  publicKeyPem = crypto.createPublicKey(privateKey).export({ type: 'spki', format: 'pem' });
+  return privateKey;
+}
+
+export function centralPublicKeyPem() {
+  loadSigningKey();
+  return publicKeyPem;
+}
+
+export function signToken(payload, ttlSec) {
+  const now = Math.floor(Date.now() / 1000);
+  const body = { iss: ISSUER, iat: now, exp: now + Math.max(1, Math.round(ttlSec)), ...payload };
+  const data = b64u(JSON.stringify(body));
+  const sig = crypto.sign(null, Buffer.from(data), loadSigningKey());
+  return `${data}.${b64u(sig)}`;
+}
+
+// ---------- проверка на машине клиента (только открытый ключ центра) ----------
+function loadVerifyKey() {
+  const pem = centralPublicKeyCandidates()[0];
+  return pem ? crypto.createPublicKey(pem) : null;
+}
+
+export function verifyToken(token, { typ, aud, leewaySec = 120 } = {}) {
+  const key = loadVerifyKey();
+  if (!key) throw new Error('Не задан открытый ключ центра (LICENSE_PUBLIC_KEY)');
+  const [data, sig] = String(token || '').split('.');
+  if (!data || !sig) throw new Error('Некорректный токен');
+  const ok = crypto.verify(null, Buffer.from(data), key, Buffer.from(sig, 'base64url'));
+  if (!ok) throw new Error('Подпись токена не прошла проверку');
+  let p;
+  try { p = JSON.parse(Buffer.from(data, 'base64url').toString('utf8')); } catch { throw new Error('Некорректный токен'); }
+  const now = Math.floor(Date.now() / 1000);
+  if (p.iss !== ISSUER) throw new Error('Токен выпущен не центром НейроАльфа');
+  if (typ && p.typ !== typ) throw new Error('Неверный тип токена');
+  if (aud && String(p.aud || '').toLowerCase() !== String(aud).toLowerCase()) throw new Error('Токен выпущен для другой машины');
+  if (!(p.exp > now - leewaySec)) throw new Error('Срок действия токена истёк');
+  if (p.iat && p.iat > now + leewaySec) throw new Error('Токен из будущего — проверьте время на сервере');
+  return p;
+}

package/server/model/edge.js

@@ -0,0 +1,19 @@
+// Copyright (c) 2026 Roman A. Perepelkin. All rights reserved. Proprietary software.
+// Множители порога входа и выхода стратегии и классификация 1-го эшелона ликвидности Мосбиржи.
+// Базовый порог = 2,5 × (комиссия + проскальзывание) × 2 стороны; множители поднимают его так,
+// чтобы ожидаемое движение покрывало РЕАЛЬНЫЕ издержки с запасом.
+// По фактическим сделкам счёта Т-Банка (111 сделок) и стресс-тесту:
+//   • бумаги 1-го эшелона (SBER, T, GAZP, LKOH, YDEX и др.): реальное проскальзывание ~0,01–0,03% + комиссия 0,04% → порог ×2 (от 0,50%);
+//   • бумаги 2–3 эшелона (MRKC, NKHP, AQUA и др.): широкий спред в стакане, проскальзывание до 0,10–0,25% → порог ещё в 1,35× выше (от 0,675%).
+export const ENTRY_EDGE_MULT = 1.65;
+export const TIER2_EDGE_MULT = 1.20;
+
+// Голубые фишки и наиболее ликвидные акции 1-го эшелона Мосбиржи (глубокий стакан, минимальный спред):
+export const TIER1_LIQUID_SYMBOLS = new Set([
+  'SBER', 'SBERP', 'LKOH', 'GAZP', 'T', 'YDEX', 'ROSN', 'NVTK', 'GMKN', 'PLZL',
+  'VTBR', 'TATN', 'TATNP', 'SNGS', 'SNGSP', 'ALRS', 'CHMF', 'NLMK', 'MAGN', 'MOEX',
+  'OZON', 'HEAD', 'PHOR', 'AFLT', 'VKCO', 'MTSS', 'IRAO', 'TRNFP', 'RUAL', 'AFKS',
+  'PIKK', 'SMLT', 'POSI', 'BSPB', 'SVCB', 'SOVCOM', 'CBOM', 'FLOT', 'X5',
+]);
+
+export const symbolEdgeMult = (symbol) => (TIER1_LIQUID_SYMBOLS.has(symbol) ? 1 : TIER2_EDGE_MULT);

package/server/model/forecast.js

@@ -5,7 +5,10 @@ import { loadDataset, barsFromHours, BAR_MS } from './dataset.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 { ENTRY_EDGE_MULT, TIER1_LIQUID_SYMBOLS, symbolEdgeMult } from './edge.js';
+export { TIER1_LIQUID_SYMBOLS };
 import { newsForSymbols } from '../news/index.js';
+import { fetchTbankRealtimePrices } from '../brokers/index.js';
 import { kvGet, kvSet } from '../db.js';
 import { hub } from '../hub.js';
 
@@ -124,26 +127,36 @@ export const isModelTrainedToday = (p, now = Date.now()) => {
   return false;
 };
 
-// Быстрое получение живых цен Мосбиржи (TQBR + IMOEX) за 1 лёгкий запрос (~80 мс)
+// Быстрое получение живых цен Мосбиржи:
+// в первую очередь берёт секундные цены реального времени из T-Invest API (GetLastPrices, 0 секунд задержки!),
+// а недостающие тикеры и индекс IMOEX дополняет из MOEX ISS
 async function fetchLiveMoexSnapshot() {
   try {
-    const [rShares, rIdx] = await Promise.all([
-      fetch('https://iss.moex.com/iss/engines/stock/markets/shares/boards/TQBR/securities.json?iss.meta=off&iss.only=marketdata&marketdata.columns=SECID,LAST,MARKETPRICE,LCURRENTPRICE,VALTODAY', { signal: AbortSignal.timeout(6000) }),
+    const [tbPrices, rShares, rIdx] = await Promise.all([
+      fetchTbankRealtimePrices().catch(() => null),
+      fetch('https://iss.moex.com/iss/engines/stock/markets/shares/boards/TQBR/securities.json?iss.meta=off&iss.only=marketdata&marketdata.columns=SECID,LAST,MARKETPRICE,LCURRENTPRICE,VALTODAY', { signal: AbortSignal.timeout(6000) }).catch(() => null),
       fetch('https://iss.moex.com/iss/engines/stock/markets/index/boards/SNDX/securities/IMOEX.json?iss.meta=off&iss.only=marketdata&marketdata.columns=SECID,CURRENTVALUE,LASTVALUE', { signal: AbortSignal.timeout(6000) }).catch(() => null),
     ]);
-    if (!rShares.ok) return null;
-    const j = await rShares.json();
-    const cols = j.marketdata?.columns || [];
-    const iSec = cols.indexOf('SECID');
-    const iLast = cols.indexOf('LAST');
-    const iMkt = cols.indexOf('MARKETPRICE');
-    const iCur = cols.indexOf('LCURRENTPRICE');
     const prices = new Map();
-    for (const row of j.marketdata?.data || []) {
-      const sym = row[iSec];
-      const px = Number(row[iLast] || row[iMkt] || row[iCur] || 0);
-      if (sym && px > 0) prices.set(sym, px);
+    if (rShares?.ok) {
+      const j = await rShares.json().catch(() => null);
+      const cols = j?.marketdata?.columns || [];
+      const iSec = cols.indexOf('SECID');
+      const iLast = cols.indexOf('LAST');
+      const iMkt = cols.indexOf('MARKETPRICE');
+      const iCur = cols.indexOf('LCURRENTPRICE');
+      for (const row of j?.marketdata?.data || []) {
+        const sym = row[iSec];
+        const px = Number(row[iLast] || row[iMkt] || row[iCur] || 0);
+        if (sym && px > 0) prices.set(sym, px);
+      }
+    }
+    if (tbPrices?.size) {
+      for (const [sym, px] of tbPrices) {
+        if (px > 0) prices.set(sym, px);
+      }
     }
+    if (!prices.size) return null;
     let imoexPrice = 0;
     if (rIdx?.ok) {
       const ji = await rIdx.json().catch(() => null);
@@ -151,7 +164,7 @@ async function fetchLiveMoexSnapshot() {
       const ir = ji?.marketdata?.data?.[0];
       if (ir) imoexPrice = Number(ir[ic.indexOf('CURRENTVALUE')] || ir[ic.indexOf('LASTVALUE')] || 0);
     }
-    return { prices, imoexPrice, ts: Date.now() };
+    return { prices, imoexPrice, ts: Date.now(), realtime: Boolean(tbPrices?.size) };
   } catch {
     return null;
   }
@@ -283,7 +296,8 @@ function buildPredictionRows(ds, p, idx, f, u, fitted, chosen, H, effMinEdge, au
     preds[n] = MODELS[n].predict(fitted[n], f, u);
   }
   const cost = (p.commissionPct + p.slippagePct) / 100;
-  const threshold = effMinEdge * 2 * cost;
+  // порог ×ENTRY_EDGE_MULT: при реальных издержках ~0,09% на сторону базовый порог убыточен (см. server/model/edge.js)
+  const threshold = effMinEdge * 2 * cost * ENTRY_EDGE_MULT;
   const bear = isMarketDown(ds, idx);
   const dir = p.modelDirection || 'long';
   const needL = autoAdapt && bear ? threshold * 1.25 : threshold;
@@ -296,7 +310,18 @@ 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 lastMovePct = round(f.z[u * f.N + i] * f.sigma[i] * 100, 3);
+    // Спред-фильтр по эшелонам ликвидности:
+    // для 1-го эшелона базовый порог needL/needS (≥ 0.50%), для 2–3 эшелона (широкий спред стакана) — в TIER2_EDGE_MULT (1.35×) выше
+    const tierMult = symbolEdgeMult(tk.symbol);
+    const symNeedL = Math.max(needL * tierMult, 0.0030);
+    const symNeedS = Math.max(needS * tierMult, 0.0031);
+    // Внутрисвечной предохранитель реального времени:
+    // не даём сигнал на покупку («не ловим падающий нож»), если на текущей живой свече акция проваливается против рынка сильнее чем на -0.35%,
+    // и не даём сигнал на шорт, если на текущей живой свече акция взлетает вверх сильнее чем на +0.35%!
+    const liveBuyOk = !(liveSnap?.realtime && lastMovePct < -0.35);
+    const liveShortOk = !(liveSnap?.realtime && lastMovePct > 0.35);
+    const rawShortHit = dir !== 'long' && tk.liq[idx] >= LIQ_MIN && exp < -symNeedS && liveShortOk;
     const shortBlockedByBroker = Boolean(rawShortHit && shortableMap && shortableMap[tk.symbol] === false);
     const row = {
       i, symbol: tk.symbol, name: tk.name,
@@ -304,9 +329,9 @@ function buildPredictionRows(ds, p, idx, f, u, fitted, chosen, H, effMinEdge, au
       liquid: tk.liq[idx] >= LIQ_MIN,
       expected: exp,
       expectedPct: round(exp * 100, 3),
-      lastMovePct: round(f.z[u * f.N + i] * f.sigma[i] * 100, 3),
+      lastMovePct,
       weight: round(weight, 3),
-      signal: tk.liq[idx] >= LIQ_MIN && exp > needL,
+      signal: tk.liq[idx] >= LIQ_MIN && exp > symNeedL && liveBuyOk,
     };
     if (dir !== 'long') {
       row.shortSignal = rawShortHit && !shortBlockedByBroker;
@@ -370,6 +395,35 @@ const fmtLiveBarLabel = (barTs, liveSnapTs) => {
   return fmtBarMsk(barTs || liveSnapTs || Date.now());
 };
 
+// Мгновенный пересчёт последнего среза прогноза по живым секундным котировкам (без обращения к истории свечей)
+async function tickLiveForecastState(p, now = Date.now()) {
+  const liveSnap = await fetchLiveMoexSnapshot();
+  if (liveSnap) applyLivePricesToFold(baseState.ds, baseState.f, baseState.u, baseState.fitted, liveSnap);
+  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 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,
+    bar: fmtLiveBarLabel(barTs, liveSnap ? liveTs : null),
+    buyThresholdPct: round(Math.max((r.needL ?? r.threshold) * 100, 0.30), 3),
+    shortThresholdPct: round(Math.max((r.needS ?? r.threshold) * 100, 0.31), 3),
+    marketDown: r.marketDown,
+    rows: sortedRows,
+  };
+  baseState.lastTickResult = result;
+  baseState.lastTickAt = now;
+  kvSet('lastForecastSnap', { key: baseState.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;
+}
+
 // Прогноз на ближайшие H часов с живым поминутным обновлением котировок (без переобучения тяжёлого окна каждую минуту)
 export async function forecastNow(input, { force = false, onProgress } = {}) {
   const p = normalizeParams(input);
@@ -379,34 +433,20 @@ export async function forecastNow(input, { force = false, onProgress } = {}) {
   const key = JSON.stringify([autoAdapt, p.modelType, effHorizon, p.modelTrainDays, p.modelEmbedDim, effMinEdge, p.modelDirection, p.modelUseMacro, p.modelUseDividends, p.modelTextWeight, p.commissionPct, p.slippagePct]);
 
   const now = Date.now();
-  // 1) Если с последнего живого тика прошло меньше 15 секунд и нет force — отдаём мгновенно из памяти
-  if (!force && baseState && baseState.key === key && baseState.lastTickResult && now - baseState.lastTickAt < 15000) {
+  // 1) Если с последнего живого тика прошло меньше 8 секунд и нет force — отдаём мгновенно из памяти
+  if (!force && baseState && baseState.key === key && baseState.lastTickResult && now - baseState.lastTickAt < 8000) {
     return withNews(baseState.lastTickResult, p);
   }
-  // 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,
-      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 });
+  // 2) Если в RAM уже прогрето ядро модели (baseState):
+  //    ВСЕГДА выполняем быстрый живой пересчёт по секундным котировкам Т-Банка/Мосбиржи (~80 мс, никогда не блокируя UI),
+  //    а если с момента последнего обновления 10-минутных свечей прошло больше 10 минут — запускаем догрузку свечей параллельно в фоне!
+  if (!force && baseState && baseState.key === key) {
+    if (now - baseState.dsLoadedAt >= 10 * 60000 && !inflight.has(key)) {
+      setImmediate(() => {
+        refreshDatasetStateInBackground(p, key).catch(() => {});
+      });
+    }
+    const result = await tickLiveForecastState(p, now);
     return withNews(result, p);
   }
 
@@ -418,14 +458,23 @@ export async function forecastNow(input, { force = false, onProgress } = {}) {
     if (saved?.result && saved.key === key && now - (saved.result.at || 0) < 4 * 3600000) {
       if (!inflight.has(key)) {
         setImmediate(() => {
-          forecastNow(p, { force: true }).catch(() => {});
+          refreshDatasetStateInBackground(p, key, { force: true }).catch(() => {});
         });
       }
       return withNews(saved.result, p);
     }
   }
 
-  if (!force && inflight.has(key)) return withNews(await inflight.get(key), p);
+  return withNews(await refreshDatasetStateInBackground(p, key, { force, onProgress }), p);
+}
+
+// Фоновая догрузка свежих 10-минутных свечей и пересборка контекста u (не блокирует живой тик котировок)
+function refreshDatasetStateInBackground(p, key, { force = false, onProgress } = {}) {
+  if (!force && inflight.has(key)) return inflight.get(key);
+  const autoAdapt = p.modelAutoAdapt !== false;
+  const effHorizon = autoAdapt ? 2.5 : p.modelHorizon;
+  const effMinEdge = autoAdapt ? 2.5 : p.modelMinEdge;
+  const now = Date.now();
   const task = (async () => {
     hub.emit({ type: 'trading:pulse', kind: 'train', ts: now, text: 'Обновление котировок и расчёт прогноза…' });
     const trainedToday = !force && isModelTrainedToday(p, now);
@@ -440,17 +489,18 @@ export async function forecastNow(input, { force = false, onProgress } = {}) {
     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 finishNow = Date.now();
+    const liveTs = liveSnap?.ts || finishNow;
     const barTs = ds.timeline[last];
     const result = {
-      at: now,
-      trainedAt: r.trainedAt || now,
+      at: finishNow,
+      trainedAt: r.trainedAt || finishNow,
       liveTs,
       barTs,
       bar: fmtLiveBarLabel(barTs, liveSnap ? liveTs : null),
       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),
+      buyThresholdPct: round(Math.max((r.needL ?? r.threshold) * 100, 0.30), 3),
+      shortThresholdPct: round(Math.max((r.needS ?? r.threshold) * 100, 0.31), 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 },
@@ -458,8 +508,8 @@ export async function forecastNow(input, { force = false, onProgress } = {}) {
     };
     baseState = {
       key,
-      trainedAt: r.trainedAt || now,
-      dsLoadedAt: now,
+      trainedAt: r.trainedAt || finishNow,
+      dsLoadedAt: finishNow,
       ds,
       last,
       f: r.f,
@@ -470,12 +520,12 @@ export async function forecastNow(input, { force = false, onProgress } = {}) {
       prevExpMap: stateObj.prevExpMap,
       prevRankMap: stateObj.prevRankMap,
       lastTickResult: result,
-      lastTickAt: now,
+      lastTickAt: finishNow,
     };
     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 });
+    hub.emit({ type: 'trading:pulse', kind: 'radar', ts: finishNow, bar: result.bar, signals: sortedRows.filter((x) => x.signal || x.shortSignal).length });
     return result;
   })().finally(() => inflight.delete(key));
   inflight.set(key, task);
-  return withNews(await task, p);
+  return task;
 }

package/server/model/live.js

@@ -120,7 +120,7 @@ class LiveEngine {
   }
 
   status(uid = currentUserId()) {
-    const list = [...this.accounts.values()].filter((s) => (s.userId || 1) === (uid || 1)).sort((a, b) => b.runId - a.runId).map((s) => this.#accountStatus(s));
+    const list = [...this.accounts.values()].filter((s) => (s.userId || 1) === (uid ?? 1)).sort((a, b) => b.runId - a.runId).map((s) => this.#accountStatus(s));
     const primary = list.find((a) => a.running) || list[0] || null;
     if (!primary) return { running: false, accounts: [] };
     return {

package/server/model/models.js

@@ -462,7 +462,8 @@ export function fitAttention(f) {
     }
   }, p, 1e-2);
   const macroHeads = ML.flatMap((m, mi) => SCALES.map((sc, si) => ({ label: `${m.label}, ${sc.label}`, coef: coef[Hn + 3 + mi * 3 + si] })));
-  return { name: 'attention', coef, As, F, macroHeads };
+  const inertiaCoef = fitInertia(f).coef;
+  return { name: 'attention', coef, inertiaCoef, As, F, macroHeads };
 }
 function predictAttention(m, f, u) {
   const ML = f.macro ? f.macro.list : [];
@@ -478,6 +479,13 @@ function predictAttention(m, f, u) {
       for (let q = 0; q < 3; q++) zz += m.coef[HEADS.length + 3 + mi * 3 + q] * zs[q * f.W + u];
       s += ML[mi].b[i] * zz;
     }
+    // Ансамбль с базовой моделью своей инерции (при наличии весов inertiaCoef):
+    // сглаживает ошибки внимания к соседям на тонких бумагах и усиливает самые чистые сигналы возврата/импульса
+    if (m.inertiaCoef) {
+      let sIn = 0;
+      for (let q = 0; q < 3; q++) sIn += m.inertiaCoef[q] * f.X[0][q][k];
+      s = 0.45 * s + 0.55 * sIn;
+    }
     out[i] = s;
   }
   return out;
@@ -496,13 +504,14 @@ export const modelNames = () => Object.keys(MODELS);
 export function explainAttention(m, f, u, j, top = 3) {
   const N = f.N;
   const contrib = new Float64Array(N);
+  const wAtt = m.inertiaCoef ? 0.45 : 1, wIn = m.inertiaCoef ? 0.55 : 0;
   HEADS.forEach((h, hi) => {
     const A = m.As[BETAS.findIndex((b) => b.v === h.beta)];
     const X = f.X[h.kind === 'price' ? 0 : 1][h.scale];
-    for (let i = 0; i < N; i++) contrib[i] += m.coef[hi] * A[j * N + i] * X[u * N + i];
+    for (let i = 0; i < N; i++) contrib[i] += wAtt * m.coef[hi] * A[j * N + i] * X[u * N + i];
   });
   let self = 0;
-  for (let q = 0; q < 3; q++) self += m.coef[HEADS.length + q] * f.X[0][q][u * N + j];
+  for (let q = 0; q < 3; q++) self += (wAtt * m.coef[HEADS.length + q] + wIn * (m.inertiaCoef?.[q] || 0)) * f.X[0][q][u * N + j];
   const idx = [...contrib.keys()].filter((i) => i !== j).sort((a, b) => Math.abs(contrib[b]) - Math.abs(contrib[a])).slice(0, top);
   return { neighbors: idx.map((i) => ({ i, contrib: contrib[i] })), self };
 }