neuroalpha 0.0.0-stage → 0.2.0

package/server/notify/index.js

@@ -0,0 +1,168 @@
+import { db, kvGet, kvSet } from '../db.js';
+import { encryptSecret, decryptSecret, getUserById, runWithUser } from '../auth/index.js';
+import { round } from '../util.js';
+
+let actionHandlers = { execute: null, reject: null };
+export function registerBrokerHandlers(h) { actionHandlers = h; }
+
+export function getNotifyConfig() {
+  const saved = kvGet('notifyConfig') || {};
+  const tgToken = decryptSecret(saved.tgToken || '') || String(process.env.TELEGRAM_BOT_TOKEN || '').trim();
+  const tgBotName = String(saved.tgBotName || process.env.TELEGRAM_BOT_NAME || '').trim().replace(/^@/, '');
+  const maxToken = decryptSecret(saved.maxToken || '') || String(process.env.MAX_BOT_TOKEN || '').trim();
+  const maxBotName = String(saved.maxBotName || process.env.MAX_BOT_NAME || '').trim().replace(/^@/, '');
+  return { tgToken, tgBotName, maxToken, maxBotName, tgEnabled: Boolean(tgToken), maxEnabled: Boolean(maxToken) };
+}
+
+export function publicNotifyConfig() {
+  const c = getNotifyConfig();
+  return { tgBotName: c.tgBotName, maxBotName: c.maxBotName, hasTgToken: c.tgEnabled, hasMaxToken: c.maxEnabled };
+}
+
+export function saveNotifyConfig(input = {}) {
+  const prev = kvGet('notifyConfig') || {};
+  const next = {
+    tgBotName: String(input.tgBotName ?? prev.tgBotName ?? '').trim().replace(/^@/, ''),
+    tgToken: input.clearTg ? '' : (input.tgToken && String(input.tgToken).trim() ? encryptSecret(input.tgToken) : (prev.tgToken || '')),
+    maxBotName: String(input.maxBotName ?? prev.maxBotName ?? '').trim().replace(/^@/, ''),
+    maxToken: input.clearMax ? '' : (input.maxToken && String(input.maxToken).trim() ? encryptSecret(input.maxToken) : (prev.maxToken || '')),
+  };
+  kvSet('notifyConfig', next);
+  return publicNotifyConfig();
+}
+
+// ---------- отправка сообщений в Telegram и MAX ----------
+export async function sendTelegram(chatId, text, buttons = null) {
+  const { tgToken } = getNotifyConfig();
+  if (!tgToken || !chatId) return false;
+  const body = {
+    chat_id: chatId,
+    text,
+    ...(buttons?.length ? { reply_markup: { inline_keyboard: [buttons.map((b) => ({ text: b.label, callback_data: b.data }))] } } : {}),
+  };
+  const r = await fetch(`https://api.telegram.org/bot${tgToken}/sendMessage`, {
+    method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body), signal: AbortSignal.timeout(12000),
+  }).catch(() => null);
+  return Boolean(r?.ok);
+}
+
+export async function sendMax(chatId, text, buttons = null) {
+  const { maxToken } = getNotifyConfig();
+  if (!maxToken || !chatId) return false;
+  const attachments = buttons?.length ? [{
+    type: 'inline_keyboard',
+    payload: {
+      buttons: [buttons.map((b) => ({ type: 'callback', text: b.label, payload: b.data }))],
+    },
+  }] : undefined;
+  const r = await fetch(`https://botapi.max.ru/messages?access_token=${encodeURIComponent(maxToken)}&chat_id=${encodeURIComponent(chatId)}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ text, ...(attachments ? { attachments } : {}) }),
+    signal: AbortSignal.timeout(12000),
+  }).catch(() => null);
+  return Boolean(r?.ok);
+}
+
+export async function notifyUser(userId, text, buttons = null) {
+  const u = getUserById(userId);
+  if (!u) return { tg: false, max: false };
+  const [tg, max] = await Promise.all([
+    u.tg_chat_id ? sendTelegram(u.tg_chat_id, text, buttons) : false,
+    u.max_chat_id ? sendMax(u.max_chat_id, text, buttons) : false,
+  ]);
+  return { tg, max };
+}
+
+export async function notifyBrokerBatch(userId, acc, batch) {
+  if (!batch?.orders?.length) return;
+  const lines = batch.orders.map((o) => `• ${o.action === 'buy' ? 'Купить' : 'Продать'} ${o.symbol}: ${o.lots} л. (${o.shares} шт.) по ${o.limitPrice} ₽ ≈ ${round(o.amountRub, 0)} ₽`);
+  const text = `НейроАльфа · Счёт «${acc.name}»\nСформирован пакет лимитных заявок (свеча ${batch.bar || '—'}):\n${lines.join('\n')}`;
+  const buttons = acc.mode === 'confirm' ? [
+    { label: `✓ Исполнить (${batch.orders.length})`, data: `exec:${userId}:${acc.id}` },
+    { label: '✕ Отклонить', data: `rej:${userId}:${acc.id}` },
+  ] : null;
+  await notifyUser(userId, text, buttons);
+}
+
+// ---------- обработка команд привязки и кнопок подтверждения в Telegram и MAX ----------
+function tryLinkByCode(text, channel, chatId) {
+  const m = String(text || '').toUpperCase().match(/NA-[A-Z0-9]{6}/);
+  if (!m) return null;
+  const u = db.prepare('SELECT * FROM users WHERE UPPER(notify_code) = ?').get(m[0]);
+  if (!u) return null;
+  const col = channel === 'tg' ? 'tg_chat_id' : 'max_chat_id';
+  db.prepare(`UPDATE users SET ${col} = ? WHERE id = ?`).run(String(chatId), u.id);
+  return u;
+}
+
+async function handleCallbackAction(data, replyFn) {
+  const [act, uidStr, accId] = String(data || '').split(':');
+  const u = getUserById(Number(uidStr));
+  if (!u || !accId) return;
+  try {
+    if (act === 'exec' && actionHandlers.execute) {
+      await runWithUser(u, () => actionHandlers.execute(accId));
+      await replyFn(`✓ Заявки по счёту отправлены брокеру.`);
+    } else if (act === 'rej' && actionHandlers.reject) {
+      await runWithUser(u, () => actionHandlers.reject(accId));
+      await replyFn(`✕ Пакет заявок отклонён.`);
+    }
+  } catch (e) {
+    await replyFn(`Ошибка: ${e.message}`);
+  }
+}
+
+let tgOffset = 0;
+let maxMarker = null;
+
+async function pollTelegram() {
+  const { tgToken } = getNotifyConfig();
+  if (!tgToken) return;
+  try {
+    const r = await fetch(`https://api.telegram.org/bot${tgToken}/getUpdates?offset=${tgOffset}&timeout=1`, { signal: AbortSignal.timeout(8000) });
+    if (!r.ok) return;
+    const j = await r.json();
+    for (const upd of j.result || []) {
+      tgOffset = Math.max(tgOffset, upd.update_id + 1);
+      if (upd.message?.text) {
+        const chatId = upd.message.chat.id;
+        const u = tryLinkByCode(upd.message.text, 'tg', chatId);
+        if (u) await sendTelegram(chatId, `✓ Telegram успешно привязан к аккаунту НейроАльфа (${u.email}). Сюда будут приходить сигналы и кнопки подтверждения брокерских заявок.`);
+      } else if (upd.callback_query?.data) {
+        const chatId = upd.callback_query.message?.chat?.id;
+        await handleCallbackAction(upd.callback_query.data, (msg) => sendTelegram(chatId, msg));
+      }
+    }
+  } catch { /* ignore */ }
+}
+
+async function pollMax() {
+  const { maxToken } = getNotifyConfig();
+  if (!maxToken) return;
+  try {
+    const url = `https://botapi.max.ru/updates?access_token=${encodeURIComponent(maxToken)}&timeout=1${maxMarker ? `&marker=${maxMarker}` : ''}`;
+    const r = await fetch(url, { signal: AbortSignal.timeout(8000) });
+    if (!r.ok) return;
+    const j = await r.json();
+    if (j.marker) maxMarker = j.marker;
+    for (const upd of j.updates || []) {
+      if (upd.message?.body?.text) {
+        const chatId = upd.message.recipient?.chat_id || upd.message.sender?.user_id;
+        const u = tryLinkByCode(upd.message.body.text, 'max', chatId);
+        if (u) await sendMax(chatId, `✓ Мессенджер MAX успешно привязан к аккаунту НейроАльфа (${u.email}). Сюда будут приходить сигналы и кнопки подтверждения заявок.`);
+      } else if (upd.callback?.payload) {
+        const chatId = upd.message?.recipient?.chat_id || upd.callback?.user?.user_id;
+        await handleCallbackAction(upd.callback.payload, (msg) => sendMax(chatId, msg));
+      }
+    }
+  } catch { /* ignore */ }
+}
+
+export function startNotifyPolling() {
+  const timer = setInterval(() => {
+    pollTelegram();
+    pollMax();
+  }, 6000);
+  timer.unref?.();
+}

package/server/params-meta.js

@@ -0,0 +1,63 @@
+// Описание всех настроек: для формы в интерфейсе, для ИИ-стратега и для проверки значений.
+// hidden — не показывать в интерфейсе; ai:false — ИИ менять запрещено (честность проверки).
+export const PARAMS = [
+  { key: 'modelAutoAdapt', label: 'Самообучение правил торговли (Авто)', hint: 'Включено: стратегия сама подбирает порог выхода под вашу комиссию, вовремя закрывает угасающие сделки и автоматически ставит на карантин убыточные «акции-убийцы». Ручная настройка порогов не требуется.', type: 'checkbox' },
+  { key: 'modelHorizon', label: 'Горизонт прогноза, часов', hint: 'На сколько часов вперёд стратегия предсказывает движение и примерно столько держит купленные акции. Можно дробно, с точностью до 10 минут (например, 1,5).', min: 0.5, max: 8 },
+  { key: 'modelMinEdge', label: 'Порог выгоды на вход', hint: 'Покупать (или продавать), только если ожидаемое движение больше стоимости покупки и продажи, умноженной на это число. Больше — реже, но выгоднее сделки. 0 — без порога.', min: 0, max: 10 },
+  { key: 'modelExitRatio', label: 'Порог на выход (доля от входа)', hint: 'До какой доли от порога входа может ослабнуть прогноз, прежде чем закрыть позицию (0,5 — закрывать ниже половины порога входа; 0 — держать, пока прогноз остаётся в нашу сторону).', min: 0, max: 1, step: 0.05 },
+  { key: 'modelMinHoldHours', label: 'Минимальное удержание, часов', hint: 'Не закрывать позицию раньше этого времени при обычном ослаблении прогноза (0 — без ограничения). Снижает число сделок и расходы на комиссию.', min: 0, max: 48, step: 0.5 },
+  { key: 'modelTopK', label: 'Сколько акций держать', hint: 'Сколько акций с лучшим прогнозом можно держать одновременно (при продажах — и столько же акций на продажу).', min: 1, max: 20 },
+  { key: 'modelAllocMode', label: 'Распределение суммы между акциями', hint: '«Поровну» — одинаковая сумма на каждую позицию; «Обратно размаху акции» — спокойным бумагам больше, волатильным — меньше (снижает просадку).', type: 'select', options: [['equal', 'Поровну'], ['invvol', 'Обратно размаху акции']] },
+  { key: 'modelDirection', label: 'Направление торговли', hint: 'Продажа без покупки (шорт) — заработок на падении акции относительно рынка. «Нейтрально к рынку» — покупаем сильные акции и продаём слабые на равные суммы: общий рост или падение рынка почти не влияет на результат. При продажах сумма на одну акцию вдвое меньше.', type: 'select', options: [['long', 'Только покупки'], ['longshort', 'Покупки и продажи'], ['neutral', 'Нейтрально к рынку']] },
+  { key: 'modelMarketFilter', label: 'Фильтр падающего рынка', hint: 'Не открывать новые покупки, когда индекс Мосбиржи одновременно ниже уровня 2 часов назад и ниже уровня торгового дня назад.', type: 'select', options: [['off', 'Выключен'], ['ma', 'Не покупать при падении индекса']] },
+  { key: 'modelShortFeePct', label: 'Плата за заём акций, % годовых', hint: 'Сколько брокер берёт за заём акций для продажи без покупки. Начисляется за всё время, пока продажа открыта (например, 20% годовых — около 0,05% за сутки).', min: 0, max: 100 },
+  { key: 'modelTrainDays', label: 'Окно обучения, торговых дней', hint: 'На скольких последних днях стратегия учится перед каждым месяцем прогноза.', min: 30, max: 400 },
+  { key: 'modelHistoryDays', label: 'Период исследования, дней', hint: 'За сколько последних календарных дней проверять стратегию.', min: 120, max: 1100 },
+  { key: 'modelEmbedDim', label: 'Размер эмбеддинга', hint: 'Сколько «скрытых свойств» описывают каждую акцию на карте рынка. Больше — тоньше различия, но больше шума.', min: 2, max: 20 },
+  { key: 'modelUseMacro', label: 'Учитывать нефть, валюту, облигации', hint: 'Стратегия дополнительно смотрит на движение нефти Brent, юаня, доллара, золота и индекса гособлигаций: акции, чувствительные к ним, получают поправку к прогнозу.', type: 'checkbox' },
+  { key: 'modelTextWeight', label: 'Вес описаний компаний на карте', hint: '0 — карта рынка строится только по поведению акций (как они двигались вместе); 1 — только по устойчивым описаниям бизнеса (экспортёр, банк, дивиденды и т.д.); значения между — смесь того и другого. Описания заранее составляет ИИ.', min: 0, max: 1, step: 0.1 },
+  { key: 'modelType', label: 'Какая стратегия торгует', hint: 'Три стратегии всегда сравниваются (трансформер — если включён); эта торгует в результатах и в живой проверке. Если выбран трансформер, он обучается и без галочки ниже.', type: 'select', options: [['attention', 'Внимание через карту'], ['leadlag', 'Кто за кем ходит'], ['inertia', 'Своя инерция'], ['transformer', 'Трансформер']] },
+  { key: 'modelUseTransformer', label: 'Добавить трансформер (медленно)', hint: 'Нейросеть с вниманием между акциями: добавляет в сравнение четвёртую стратегию. Учится заново в каждом окне, поэтому исследование идёт заметно дольше.', type: 'checkbox' },
+  { key: 'transformerEpochs', label: 'Эпох обучения трансформера', hint: 'Сколько раз трансформер проходит по данным окна обучения. Больше — дольше учится и может найти больше закономерностей (обучение само останавливается, если становится хуже).', min: 2, max: 40, step: 1, int: true },
+  { key: 'transformerStride', label: 'Шаг свечей при обучении трансформера', hint: 'В каждый проход берётся каждая N-я свеча (со сдвигом от прохода к проходу).', min: 1, max: 24, step: 1, int: true, hidden: true, fixed: true },
+  { key: 'transformerParallel', label: 'Обучать окна параллельно', hint: 'Месяцы проверки трансформера обучаются одновременно на нескольких ядрах процессора.', type: 'checkbox', hidden: true, fixed: true },
+  { key: 'transformerGpu', label: 'Обучать трансформер на видеокарте', hint: 'Экспериментально. Через встроенный в браузер (Chrome, Edge) движок. Если видеокарта недоступна — обучение пойдёт на процессоре. Результат может чуть отличаться в последних знаках.', type: 'checkbox' },
+  { key: 'modelUseDividends', label: 'Учитывать дивиденды', hint: 'Цены до даты отсечки уменьшаются на размер дивиденда со сверкой по реальному падению цены.', type: 'checkbox', hidden: true, fixed: true },
+  { key: 'capital', label: 'Стартовая сумма, ₽', hint: 'С какой суммой начинает виртуальный счёт.', min: 10000, max: 1e9, hidden: true },
+  { key: 'commissionPct', label: 'Комиссия, % за сделку', hint: 'Сколько берут брокер и биржа за покупку и отдельно за продажу.', min: 0, max: 1, ai: false },
+  { key: 'slippagePct', label: 'Потери при исполнении, %', hint: 'На сколько реальная цена сделки обычно хуже ожидаемой.', min: 0, max: 1, ai: false },
+  { key: 'paperDailyReview', label: 'ИИ разбирает каждый торговый день живой проверки', hint: 'После окончания торгового дня Стратег сам разбирает сделки и пишет короткую сводку в чат.', type: 'checkbox' },
+  { key: 'autopilotBudget', label: 'Лимит исследований автопилота за задание', hint: 'Сколько исследований Стратег может провести подряд за одно задание в режиме «Автопилот».', min: 1, max: 30, step: 1, int: true, ai: false },
+  { key: 'newsEnabled', label: 'Следить за новостями', hint: 'Раз в 10 минут собирает новости и раскрытия компаний.', type: 'checkbox', hidden: true, fixed: true },
+  { key: 'newsFilter', label: 'Учитывать новости в торговле', hint: 'Раз в 10 минут собирает новости компаний (ИИ определяет затронутые акции и тон) и в живой проверке не открывает сделки против важной свежей новости.', type: 'checkbox' },
+  { key: 'oosPct', label: 'Контрольная часть, %', hint: 'Доля периода в конце, не используемая для подбора настроек.', min: 0, max: 60, ai: false, hidden: true },
+  { key: 'paperPollSec', label: 'Проверять биржу раз в, сек', hint: 'Как часто живая проверка смотрит, не закрылась ли новая свеча.', min: 15, max: 3600, hidden: true },
+];
+
+export const PARAM_MAP = Object.fromEntries(PARAMS.map((p) => [p.key, p]));
+
+// Проверка и приведение значения. Возвращает { value } или { error }
+export function validateParam(key, raw) {
+  const m = PARAM_MAP[key];
+  if (!m) return { error: `нет такой настройки «${key}»` };
+  if (m.type === 'checkbox') return { value: raw === true || raw === 'true' || raw === 1 };
+  if (m.type === 'select') {
+    const opt = m.options.find(([v]) => String(v) === String(raw));
+    return opt ? { value: opt[0] } : { error: `${key}: допустимо ${m.options.map(([v]) => v).join(', ')}` };
+  }
+  // число; запятая допустима как десятичный разделитель («2,5» = 2.5)
+  const n = Number(String(raw).trim().replace(',', '.'));
+  if (!Number.isFinite(n)) return { error: `${key}: нужно число` };
+  if (m.min !== undefined && n < m.min) return { error: `${key}: минимум ${m.min}` };
+  if (m.max !== undefined && n > m.max) return { error: `${key}: максимум ${m.max}` };
+  return { value: m.int ? Math.round(n) : n };
+}
+
+// Приводит ключи вида model_horizon к modelHorizon
+export function normalizeKey(k) {
+  if (PARAM_MAP[k]) return k;
+  const camel = String(k).replace(/[_-](\w)/g, (_, c) => c.toUpperCase());
+  if (PARAM_MAP[camel]) return camel;
+  const lower = String(k).toLowerCase().replace(/[_-]/g, '');
+  return PARAMS.find((p) => p.key.toLowerCase() === lower)?.key || k;
+}

package/server/settings.js

@@ -0,0 +1,79 @@
+import { strategyDefaults } from './config.js';
+import { userKvGet, userKvSet, addSettingsHistory, getSettingsHistory } from './db.js';
+import { validateParam, normalizeKey, PARAM_MAP } from './params-meta.js';
+import { hub } from './hub.js';
+import { fmtBarMsk } from './util.js';
+
+// Приводит произвольный набор значений к полному набору настроек (неизвестные ключи отбрасываются)
+export function normalizeParams(input = {}) {
+  const p = { ...strategyDefaults };
+  for (const [k, v] of Object.entries(input || {})) {
+    if (!(k in strategyDefaults) || v === '' || v === undefined || v === null) continue;
+    const r = validateParam(k, v);
+    if (!r.error) p[k] = r.value;
+  }
+  return p;
+}
+
+// Текущие рабочие настройки — общие для интерфейса и ИИ-стратега
+export function getSettings() {
+  const saved = { ...(userKvGet('settings') || {}) };
+  for (const k of Object.keys(saved)) if (PARAM_MAP[k]?.fixed) delete saved[k];
+  return normalizeParams(saved);
+}
+
+// changes: { key: value }. Возвращает { settings, changed, errors }
+export function updateSettings(changes, { source = 'user', reason = '' } = {}) {
+  const cur = getSettings();
+  const next = { ...cur };
+  const changed = {};
+  const errors = [];
+  for (const [rawKey, raw] of Object.entries(changes || {})) {
+    const key = normalizeKey(rawKey);
+    if (!PARAM_MAP[key]) { errors.push(`нет такой настройки «${rawKey}»`); continue; }
+    const v = validateParam(key, raw);
+    if (v.error) { errors.push(v.error); continue; }
+    if (JSON.stringify(cur[key]) !== JSON.stringify(v.value)) { changed[key] = { было: cur[key], стало: v.value }; next[key] = v.value; }
+  }
+  if (Object.keys(changed).length) {
+    userKvSet('settings', next);
+    addSettingsHistory(source, reason, changed);
+    hub.emit({ type: 'settings:update', settings: next, changed, source, reason });
+  }
+  return { settings: next, changed, errors };
+}
+
+export function resetSettings(source = 'user') {
+  const cur = getSettings();
+  const changed = {};
+  for (const k of Object.keys(strategyDefaults)) {
+    if (JSON.stringify(cur[k]) !== JSON.stringify(strategyDefaults[k])) changed[k] = { было: cur[k], стало: strategyDefaults[k] };
+  }
+  if (Object.keys(changed).length) addSettingsHistory(source, 'сброс по умолчанию', changed);
+  userKvSet('settings', {});
+  hub.emit({ type: 'settings:update', settings: getSettings(), changed, source, reason: 'сброс по умолчанию', reset: true });
+  return getSettings();
+}
+
+// Откат одной записи истории: возвращает значения «было» (сам откат тоже попадает в историю)
+export function revertSettingsChange(id) {
+  const h = getSettingsHistory(Number(id));
+  if (!h) throw new Error('нет такой записи в истории');
+  const back = {};
+  for (const [k, v] of Object.entries(h.changes || {})) back[k] = v.было;
+  return updateSettings(back, { source: 'user', reason: `откат изменения от ${fmtBarMsk(h.ts)}` });
+}
+
+// Проверяет набор изменений без сохранения: { values, errors }
+export function validateChanges(changes) {
+  const values = {};
+  const errors = [];
+  for (const [rawKey, raw] of Object.entries(changes || {})) {
+    const key = normalizeKey(rawKey);
+    if (!PARAM_MAP[key]) { errors.push(`нет такой настройки «${rawKey}»`); continue; }
+    const v = validateParam(key, raw);
+    if (v.error) errors.push(v.error);
+    else values[key] = v.value;
+  }
+  return { values, errors };
+}

package/server/strategist/analytics.js

@@ -0,0 +1,150 @@
+import { strategyDefaults } from '../config.js';
+import { getRun, getTrades, listRuns } from '../db.js';
+import { round, MSK } from '../util.js';
+
+const r2 = (v) => (v === null || v === undefined ? null : round(v, 2));
+const LBL = { inertia: 'своя_инерция', leadlag: 'кто_за_кем_ходит', attention: 'внимание_через_карту', transformer: 'трансформер' };
+
+export function compactMetrics(m) {
+  if (!m) return null;
+  return { сделок: m.trades, итог_проц: m.returnPct, на_1р_убытка: m.profitFactor, удачных_проц: m.winRate, худшее_падение_проц: m.maxDrawdownPct };
+}
+
+export function paramDiff(params, base = strategyDefaults) {
+  const out = {};
+  for (const [k, v] of Object.entries(params || {})) {
+    if (k.startsWith('_')) continue;
+    if (k in base && JSON.stringify(base[k]) !== JSON.stringify(v)) out[k] = v;
+  }
+  return out;
+}
+
+const seg = (c, k, dir = 'long') => c?.[k] && {
+  совпадение_прогноза: c[k].ic, недель_с_плюсом_проц: c[k].weeksPositivePct, итог_проц: c[k].returnPct,
+  без_комиссий_проц: c[k].grossReturnPct, рынок_проц: c[k].marketPct, сделок: c[k].trades, на_1р_убытка: c[k].profitFactor, худшее_падение_проц: c[k].maxDrawdownPct,
+  ...(dir !== 'long' ? { вклад_покупок_проц: c[k].longPct, вклад_продаж_проц: c[k].shortPct } : {}),
+};
+
+export function runSummary(run, { revealOOS = false } = {}) {
+  if (!run) return null;
+  const m = run.metrics || {};
+  const s = {
+    id: run.id,
+    тип: run.mode === 'paper' ? 'живая проверка' : 'исследование модели',
+    кто_запустил: run.params?._source === 'ai' ? 'ИИ' : 'пользователь',
+    заметка: run.params?._note || undefined,
+    статус: run.status,
+    отличия_от_умолчаний: paramDiff(run.params),
+  };
+  if (run.error) s.ошибка = run.error;
+  if (run.mode === 'paper') { s.результат = compactMetrics(m.full); return s; }
+  const cmp = m.model?.comparison;
+  if (cmp) {
+    s.торгует_модель = m.model.chosen;
+    s.горизонт_часов = m.model.horizon;
+    s.акций = m.model.tokens;
+    const dir = run.params?.modelDirection || 'long';
+    if (dir !== 'long') s.направление = dir === 'neutral' ? 'нейтрально к рынку (покупки и продажи парами; сравнивать с нулём, а не с рынком)' : 'покупки и продажи';
+    s.период_настройки = Object.fromEntries(Object.entries(cmp).map(([n, c]) => [LBL[n] || n, seg(c, 'inSample', dir)]));
+    s.контрольный_период = revealOOS
+      ? Object.fromEntries(Object.entries(cmp).map(([n, c]) => [LBL[n] || n, seg(c, 'outOfSample', dir)]))
+      : 'скрыт (используй final_check)';
+  }
+  return s;
+}
+
+function stats(trades) {
+  const n = trades.length;
+  if (!n) return { сделок: 0 };
+  const wins = trades.filter((t) => t.pnl > 0);
+  const gp = wins.reduce((a, t) => a + t.pnl, 0);
+  const gl = -trades.filter((t) => t.pnl <= 0).reduce((a, t) => a + t.pnl, 0);
+  return {
+    сделок: n,
+    удачных_проц: round((wins.length / n) * 100, 0),
+    на_1р_убытка: gl > 0 ? r2(gp / gl) : (gp > 0 ? 'нет убытков' : 0),
+    итог_р: round(gp - gl, 0),
+    средняя_проц: r2(trades.reduce((a, t) => a + t.pnl_pct, 0) / n),
+  };
+}
+
+function groupBy(trades, keyFn, { minN = 1, top = 12 } = {}) {
+  const g = new Map();
+  for (const t of trades) {
+    const k = keyFn(t);
+    if (k === null || k === undefined) continue;
+    if (!g.has(k)) g.set(k, []);
+    g.get(k).push(t);
+  }
+  return [...g.entries()].filter(([, a]) => a.length >= minN).map(([k, a]) => ({ группа: k, ...stats(a) })).sort((a, b) => b.сделок - a.сделок).slice(0, top);
+}
+
+const hourOf = (ts) => new Date(ts + MSK).getUTCHours();
+
+const pair = (m, r) => `модель ${r2(m)}%, рынок ${r2(r)}%`;
+const chain = (xs) => (xs.reduce((a, v) => a * (1 + (v ?? 0) / 100), 1) - 1) * 100;
+
+// Доходность по месяцам и годам; без revealOOS — только месяцы периода настройки (годы считаются по ним же)
+function periodsView(pr, revealOOS) {
+  if (!pr?.months?.length) return {};
+  const months = pr.months.filter((m) => revealOOS || !m.oos);
+  const out = { по_месяцам: Object.fromEntries(months.map((m) => [m.ym, pair(m.model, m.market)])) };
+  if (revealOOS) {
+    out.по_годам = Object.fromEntries(pr.years.map((y) => [`${y.y} г.${y.partial ? ` (${y.months} мес.)` : ''}`, pair(y.model, y.market)]));
+  } else {
+    const ys = new Map();
+    for (const m of months) {
+      const y = m.ym.slice(0, 4);
+      if (!ys.has(y)) ys.set(y, []);
+      ys.get(y).push(m);
+    }
+    out.по_годам = Object.fromEntries([...ys].map(([y, ms]) => [`${y} г. (${ms.length} мес. настройки)`, pair(chain(ms.map((m) => m.model)), chain(ms.map((m) => m.market)))]));
+  }
+  return out;
+}
+
+// Разбор исследования: по умолчанию только период настройки (защита от подгонки)
+export function analyzeRun(runId, { revealOOS = false } = {}) {
+  const run = getRun(runId);
+  if (!run) return { ошибка: `исследования №${runId} нет` };
+  let trades = getTrades(runId);
+  const split = run.metrics?.splitTs;
+  let scope = 'весь период';
+  if (split && !revealOOS && run.mode !== 'paper') { trades = trades.filter((t) => t.entry_ts < split); scope = 'только период настройки'; }
+  const ex = run.extra || {};
+  return {
+    проверка: runSummary(run, { revealOOS }),
+    охват: scope,
+    ...periodsView(ex.periods, revealOOS),
+    сделки_торгующей_модели: stats(trades),
+    по_стороне: groupBy(trades, (t) => (t.side === 'short' ? 'продажа (short)' : 'покупка (long)')),
+    по_акциям: groupBy(trades, (t) => t.symbol, { minN: 3, top: 15 }),
+    по_часу_входа: groupBy(trades, (t) => `${hourOf(t.entry_ts)}:00`, { top: 15 }).sort((a, b) => parseInt(a.группа) - parseInt(b.группа)),
+    // barsHeld хранится в минутах (в старых исследованиях — в часах, поэтому порог 8 отделяет старые данные)
+    по_сроку_удержания: groupBy(trades, (t) => {
+      const m = t.meta?.barsHeld ?? t.barsHeld;
+      if (m === undefined) return null;
+      if (m <= 8) return m <= 3 ? '1–3 часа' : '4–8 часов'; // старые записи в часах
+      if (m <= 60) return 'до 1 часа';
+      if (m <= 180) return '1–3 часа';
+      if (m <= 480) return '3–8 часов';
+      return '8 часов и дольше';
+    }),
+    головы_внимания_последнего_окна: (ex.heads || []).map((h) => ({ голова: h.label, вес: h.coef })),
+    вес_собственного_движения: ex.self,
+    пояснение: 'Положительный вес головы: движение соседей по карте «тянет» акцию в ту же сторону (переток); отрицательный — акция склонна двигаться против соседей (возврат).',
+  };
+}
+
+export function compareRuns(a, b) {
+  const ra = getRun(a), rb = getRun(b);
+  if (!ra || !rb) return { ошибка: 'исследование не найдено' };
+  const changed = {};
+  for (const k of Object.keys(strategyDefaults)) {
+    const va = ra.params?.[k] ?? strategyDefaults[k], vb = rb.params?.[k] ?? strategyDefaults[k];
+    if (JSON.stringify(va) !== JSON.stringify(vb)) changed[k] = { [`№${a}`]: va, [`№${b}`]: vb };
+  }
+  return { различия_настроек: changed, [`№${a}`]: runSummary(ra), [`№${b}`]: runSummary(rb) };
+}
+
+export const recentRuns = (limit = 10) => listRuns().slice(0, limit).map((r) => runSummary(r));