pump-anomaly 0.1.0

package/build/index.mjs

@@ -0,0 +1,2680 @@
+/**
+ * Контракты pump-matrix.
+ *
+ * ParserItem — совместим со схемой parser-items из backtest-ollama-crontab
+ * (поля direction/entry/targets/stoploss присутствуют в источнике, но детектору
+ *  нужны только channel/symbol/direction/ts — остальное игнорируется).
+ */
+const DEFAULT_CONFIG = {
+    windowK: 3,
+    minClusters: 2,
+    jaccardThreshold: 0.3,
+    lagPeakThreshold: 0.5,
+    maxBurstWindowMs: 60 * 60 * 1000,
+    mode: "auto",
+    stationarityWindowMs: Infinity,
+};
+
+const keyOf = (e) => `${e.symbol}|${e.direction}`;
+const splitKey = (k) => k.split("|");
+/** Нормализует сырой поток событий в индексированную таблицу. */
+function buildTable(raw) {
+    const events = [...raw].sort((a, b) => a.ts - b.ts);
+    const byKey = new Map();
+    const byChannelKey = new Map();
+    const channelSet = new Set();
+    for (const e of events) {
+        const k = keyOf(e);
+        let g = byKey.get(k);
+        if (!g)
+            byKey.set(k, (g = []));
+        g.push(e);
+        const ck = `${e.channel}|${k}`;
+        let c = byChannelKey.get(ck);
+        if (!c)
+            byChannelKey.set(ck, (c = []));
+        c.push(e.ts);
+        channelSet.add(e.channel);
+    }
+    return { events, byKey, byChannelKey, channels: [...channelSet] };
+}
+/**
+ * Окно стационарности. Статистики (τ, author-матрица, Jaccard) на длинном горизонте
+ * корраптятся: они агрегируются по ВСЕЙ истории, а за 5 месяцев режим дрейфует —
+ * каналы появляются/замолкают, «братские» пары распадаются, τ плывёт. Один глобальный
+ * набор усредняет несопоставимые периоды.
+ *
+ * Решение без новой математики: считать статистики только по локальному окну,
+ * заканчивающемуся в момент anchorTs. windowMs=Infinity → вся история (старое
+ * поведение, для коротких данных). Размер окна перебирается grid'ом в train.
+ */
+function windowEvents(events, anchorTs, windowMs) {
+    if (!Number.isFinite(windowMs))
+        return events;
+    const lo = anchorTs - windowMs;
+    // events отсортированы по ts → берём срез (lo, anchorTs]
+    return events.filter((e) => e.ts > lo && e.ts <= anchorTs);
+}
+/** Таблица, построенная по окну стационарности до anchorTs. */
+function buildWindowedTable(events, anchorTs, windowMs) {
+    return buildTable(windowEvents(events, anchorTs, windowMs));
+}
+
+const MIN = 60_000;
+/**
+ * Слой 1 — самооценка характерного лага τ.
+ *
+ * Строит гистограмму всех попарных положительных задержек между РАЗНЫМИ каналами
+ * по совпадающим (symbol,direction). У случайных пар распределение ≈ плоское,
+ * у «братских» каналов — острый пик у малого лага. Модальный лог-бин даёт τ.
+ *
+ * Возвращает τ в мс, зажатый в [30с, 60мин]. Если данных мало — дефолт 15 мин.
+ */
+function selfTuneLag(tbl) {
+    const deltas = [];
+    const HORIZON = 6 * 60 * MIN; // парные задержки в пределах 6ч
+    for (const evs of tbl.byKey.values()) {
+        for (let i = 0; i < evs.length; i++) {
+            for (let j = i + 1; j < evs.length; j++) {
+                const d = evs[j].ts - evs[i].ts;
+                if (d <= 0)
+                    continue;
+                if (d > HORIZON)
+                    break; // массив сортирован — дальше только больше
+                if (evs[i].channel !== evs[j].channel)
+                    deltas.push(d);
+            }
+        }
+    }
+    if (deltas.length < 8)
+        return 15 * MIN;
+    deltas.sort((a, b) => a - b);
+    const minD = Math.max(deltas[0], 1000);
+    const maxD = deltas[deltas.length - 1];
+    const BINS = 24;
+    const logMin = Math.log(minD);
+    const logMax = Math.log(maxD);
+    const span = logMax - logMin || 1;
+    const hist = new Array(BINS).fill(0);
+    for (const d of deltas) {
+        let b = Math.floor(((Math.log(d) - logMin) / span) * BINS);
+        if (b >= BINS)
+            b = BINS - 1;
+        if (b < 0)
+            b = 0;
+        hist[b]++;
+    }
+    let peak = 0;
+    for (let b = 1; b < BINS; b++)
+        if (hist[b] > hist[peak])
+            peak = b;
+    const binCenterLog = logMin + ((peak + 0.5) / BINS) * span;
+    const tau = Math.exp(binCenterLog);
+    return Math.min(Math.max(tau, 30 * 1000), 60 * MIN);
+}
+
+/**
+ * Близость двух каналов по скользящему окну (сырой ts, без бакетизации).
+ * Доля событий по общим (symbol,direction), у которых нашёлся партнёр у другого
+ * канала в пределах |Δ| ≤ window. Симметризованный Jaccard.
+ */
+function jaccardPair(tbl, a, b, window) {
+    let matched = 0;
+    let total = 0;
+    for (const k of tbl.byKey.keys()) {
+        const ta = tbl.byChannelKey.get(`${a}|${k}`);
+        const tb = tbl.byChannelKey.get(`${b}|${k}`);
+        if (!ta && !tb)
+            continue;
+        total += (ta?.length ?? 0) + (tb?.length ?? 0);
+        if (!ta || !tb)
+            continue;
+        // two-pointer: ближайшие пары в пределах окна
+        let i = 0;
+        let j = 0;
+        let m = 0;
+        while (i < ta.length && j < tb.length) {
+            const d = ta[i] - tb[j];
+            if (Math.abs(d) <= window) {
+                m++;
+                i++;
+                j++;
+            }
+            else if (d < 0) {
+                i++;
+            }
+            else {
+                j++;
+            }
+        }
+        matched += 2 * m;
+    }
+    return total === 0 ? 0 : matched / total;
+}
+/** Слой 2 — грубое сито: все пары каналов с Jaccard ≥ threshold. */
+function jaccardScreen(tbl, window, threshold) {
+    const ch = tbl.channels;
+    const edges = [];
+    for (let i = 0; i < ch.length; i++) {
+        for (let j = i + 1; j < ch.length; j++) {
+            const jac = jaccardPair(tbl, ch[i], ch[j], window);
+            if (jac >= threshold)
+                edges.push({ a: ch[i], b: ch[j], jaccard: jac });
+        }
+    }
+    return edges;
+}
+
+const HORIZON = 6 * 60 * 60 * 1000;
+/**
+ * Слой 3 — лаговая кросс-корреляция точечных процессов.
+ *
+ * Для каждой пары-кандидата собирает знаковые задержки Δ = t_b − t_a между
+ * ближайшими событиями по общим (symbol,direction). Узкий смещённый пик ⇒
+ * братские каналы одного автора; размазанный фон ⇒ совпадение, ребро отбрасывается.
+ *
+ * Острота пика меряется по peakWindow (= windowK·τ, окно сита), НЕ по голому τ:
+ * иначе брат с лагом чуть больше τ ложно выпадает и пара рвётся.
+ */
+function lagXCorr(tbl, edges, peakThreshold, peakWindow) {
+    const out = [];
+    for (const e of edges) {
+        const deltas = [];
+        for (const k of tbl.byKey.keys()) {
+            const ta = tbl.byChannelKey.get(`${e.a}|${k}`);
+            const tb = tbl.byChannelKey.get(`${e.b}|${k}`);
+            if (!ta || !tb)
+                continue;
+            for (const t of ta) {
+                let best = Infinity;
+                for (const s of tb) {
+                    const d = s - t; // >0: b позже a ⇒ a лидер
+                    if (Math.abs(d) < Math.abs(best))
+                        best = d;
+                }
+                if (Number.isFinite(best) && Math.abs(best) <= HORIZON)
+                    deltas.push(best);
+            }
+        }
+        if (deltas.length === 0)
+            continue;
+        const within = deltas.filter((d) => Math.abs(d) <= peakWindow);
+        const peakShare = within.length / deltas.length;
+        if (peakShare < peakThreshold)
+            continue;
+        const sorted = [...deltas].sort((x, y) => x - y);
+        const med = sorted[Math.floor(sorted.length / 2)];
+        const aLeads = med >= 0;
+        out.push({
+            ...e,
+            lag: Math.abs(med),
+            peakShare,
+            leader: aLeads ? e.a : e.b,
+            follower: aLeads ? e.b : e.a,
+        });
+    }
+    return out;
+}
+
+/**
+ * Слой 4 — кластеризация каналов в авторов (union-find / connected components).
+ * Каждое направленное ребро «братства» сливает два канала в один кластер.
+ * Возвращает карту channel → целочисленный id кластера.
+ */
+function clusterAuthors(channels, edges) {
+    const parent = new Map();
+    channels.forEach((c) => parent.set(c, c));
+    const find = (x) => {
+        let r = x;
+        while (parent.get(r) !== r)
+            r = parent.get(r);
+        // path compression
+        while (parent.get(x) !== r) {
+            const n = parent.get(x);
+            parent.set(x, r);
+            x = n;
+        }
+        return r;
+    };
+    const union = (a, b) => parent.set(find(a), find(b));
+    for (const e of edges)
+        union(e.a, e.b);
+    const rootId = new Map();
+    const result = new Map();
+    let next = 0;
+    for (const c of channels) {
+        const r = find(c);
+        if (!rootId.has(r))
+            rootId.set(r, next++);
+        result.set(c, rootId.get(r));
+    }
+    return result;
+}
+
+/**
+ * Слой 5 — early-warning по НЕЗАВИСИМЫМ кластерам-авторам.
+ *
+ * Для каждого (symbol,direction) скользящим окном считает плотность не каналов,
+ * а РАЗНЫХ кластеров. Всплеск из N каналов одного автора → 1 кластер → skip.
+ * Всплеск из ≥ minClusters независимых кластеров → open.
+ *
+ * confidence = dedup × fill, где
+ *   dedup = clusters/channels (1 = все источники независимы, <1 = есть дубли автора)
+ *   fill  = насыщенность окна относительно minClusters·2 (растёт с числом источников)
+ */
+function earlyWarning(tbl, clusterOf, cfg, tau) {
+    const window = Math.min(cfg.windowK * tau, cfg.maxBurstWindowMs);
+    const verdicts = [];
+    for (const [k, evs] of tbl.byKey) {
+        const [symbol, direction] = splitKey(k);
+        let lo = 0;
+        let best = null;
+        for (let hi = 0; hi < evs.length; hi++) {
+            while (evs[hi].ts - evs[lo].ts > window)
+                lo++;
+            const slice = evs.slice(lo, hi + 1);
+            const clusters = new Set(slice.map((e) => clusterOf.get(e.channel)));
+            const channels = new Set(slice.map((e) => e.channel));
+            if (clusters.size >= cfg.minClusters) {
+                const dedup = clusters.size / channels.size;
+                const fill = Math.min(slice.length / (cfg.minClusters * 2), 1);
+                const confidence = +(dedup * fill).toFixed(6);
+                const cand = {
+                    symbol,
+                    direction,
+                    action: "open",
+                    ts: evs[hi].ts,
+                    independentClusters: clusters.size,
+                    totalChannels: channels.size,
+                    confidence,
+                    reason: `${clusters.size} независимых кластеров по ${symbol} ${direction} ` +
+                        `в окне ${(window / 60000).toFixed(0)}м (каналов: ${channels.size})`,
+                    source: "matrix",
+                    channel: null,
+                };
+                if (!best || cand.confidence > best.confidence)
+                    best = cand;
+            }
+        }
+        verdicts.push(best ?? {
+            symbol,
+            direction,
+            action: "skip",
+            ts: evs[evs.length - 1]?.ts ?? 0,
+            independentClusters: 0,
+            totalChannels: new Set(evs.map((e) => e.channel)).size,
+            confidence: 0,
+            reason: `нет синхронного всплеска независимых авторов по ${symbol} ${direction}`,
+            source: "matrix",
+            channel: null,
+        });
+    }
+    return verdicts.sort((a, b) => b.confidence - a.confidence);
+}
+
+/**
+ * Single-channel fallback. Когда корреляция недоступна (один канал / mode="single"),
+ * матрица авторства пуста и earlyWarning молчит. Но даже один пост двигает рынок:
+ * аудитория входит, возникает краткосрочный импульс. Поэтому здесь КАЖДЫЙ пост =
+ * сигнал к входу, а вся ответственность за результат — на обученном exit
+ * (trailing take / hard stop / staleness / импакт-горизонт), который уже доказал,
+ * что отделяет памп от stop hunt.
+ *
+ * Дедупликация: несколько постов по одному (symbol,direction) в пределах окна
+ * схлопываются в один вход (повторный пост в активную позицию — не новый вход).
+ */
+function singleChannelSignals(tbl, cfg, tau) {
+    const window = Math.min(cfg.windowK * tau, cfg.maxBurstWindowMs);
+    const verdicts = [];
+    const toId = (e) => {
+        const r = e.id;
+        return typeof r === "string" ? r : (typeof r === "number" ? String(r) : undefined);
+    };
+    for (const [k, evs] of tbl.byKey) {
+        const [symbol, direction] = splitKey(k);
+        // схлопываем близкие посты в один вход
+        let lastTs = -Infinity;
+        let current = null;
+        for (const e of evs) {
+            const id = toId(e);
+            if (e.ts - lastTs <= window) {
+                // схлопнутый пост — его id НЕ теряем (иначе несопоставим с парсингом)
+                if (current && id != null)
+                    current.ids.push(id);
+                continue;
+            }
+            lastTs = e.ts;
+            current = {
+                symbol,
+                direction,
+                action: "open",
+                ts: e.ts,
+                independentClusters: 1,
+                totalChannels: 1,
+                confidence: 0.5, // нейтральная уверенность: вход есть, фильтра качества нет
+                reason: `single-channel fallback: пост по ${symbol} ${direction} (exit решает исход)`,
+                source: "single",
+                channel: e.channel,
+                id,
+                ids: id != null ? [id] : [],
+            };
+            verdicts.push(current);
+        }
+    }
+    return verdicts.sort((a, b) => b.ts - a.ts);
+}
+
+/**
+ * Жизнеспособность матрицы авторства. Отвечает на вопрос «достаточно ли в данных
+ * структуры, чтобы доверять корреляции», а НЕ «выдала ли матрица хоть что-то».
+ *
+ * Без этого auto оставался бы в matrix даже на двух каналах со ШУМОВЫМ совпадением
+ * (Jaccard случайно перевалил порог на 1-2 событиях) и выдавал бы ложный сигнал.
+ * Строгий критерий: матрица годна только при ЯВНЫХ кластерах И достаточном
+ * событийном перекрытии; иначе — откат в single.
+ */
+const DEFAULT_VIABILITY = {
+    minSharedEvents: 3,
+    minPeakShare: 0.6,
+    minStrongEdges: 1,
+    minStructure: 2,
+};
+/** Считает макс. событийное перекрытие среди всех пар каналов по общим ключам. */
+function maxSharedEvents(tbl) {
+    const ch = tbl.channels;
+    let max = 0;
+    for (let i = 0; i < ch.length; i++)
+        for (let j = i + 1; j < ch.length; j++) {
+            let shared = 0;
+            for (const k of tbl.byKey.keys()) {
+                const a = tbl.byChannelKey.get(`${ch[i]}|${k}`);
+                const b = tbl.byChannelKey.get(`${ch[j]}|${k}`);
+                if (a && b)
+                    shared += Math.min(a.length, b.length);
+            }
+            if (shared > max)
+                max = shared;
+        }
+    return max;
+}
+function assessViability(tbl, directed, authors, cfg = DEFAULT_VIABILITY) {
+    const channels = tbl.channels.length;
+    const maxShared = maxSharedEvents(tbl);
+    const strongEdges = directed.filter((e) => e.peakShare >= cfg.minPeakShare).length;
+    // структура графа: размеры кластеров
+    const sizeById = new Map();
+    for (const id of authors.values())
+        sizeById.set(id, (sizeById.get(id) ?? 0) + 1);
+    const multiChannelClusters = [...sizeById.values()].filter((s) => s > 1).length;
+    const clusterCount = sizeById.size;
+    // СТРОГИЙ критерий: все условия одновременно
+    const enoughChannels = channels >= 2;
+    const enoughOverlap = maxShared >= cfg.minSharedEvents;
+    const enoughEdges = strongEdges >= cfg.minStrongEdges;
+    // нетривиальность: либо найдены братья (кластер >1), либо ≥minStructure независимых кластеров
+    const nontrivial = multiChannelClusters >= 1 || clusterCount >= cfg.minStructure;
+    const viable = enoughChannels && enoughOverlap && enoughEdges && nontrivial;
+    let reason;
+    if (!enoughChannels)
+        reason = `один канал — корреляция невозможна`;
+    else if (!enoughOverlap)
+        reason = `мало общих событий (макс ${maxShared} < ${cfg.minSharedEvents}) — перекрытие шумовое`;
+    else if (!enoughEdges)
+        reason = `нет связей с острым пиком (${strongEdges} < ${cfg.minStrongEdges}) — корреляция случайна`;
+    else if (!nontrivial)
+        reason = `граф тривиален (кластеров >1: ${multiChannelClusters}, всего: ${clusterCount})`;
+    else
+        reason = `матрица жизнеспособна: ${strongEdges} острых связей, перекрытие ${maxShared}, кластеров >1: ${multiChannelClusters}`;
+    return {
+        viable, channels, maxSharedEvents: maxShared, strongEdges,
+        multiChannelClusters, clusterCount, reason,
+    };
+}
+
+/**
+ * Контракт источника свечей. Совместим с getCandles из backtest-kit.
+ * Тренировка идёт в прошлом (не realtime), поэтому look-ahead-ограничения сняты:
+ * свечи можно брать по обе стороны от события.
+ */
+/** Длительность одного шага интервала в мс. */
+const STEP_MS = {
+    "1m": 60_000,
+    "3m": 3 * 60_000,
+    "5m": 5 * 60_000,
+    "15m": 15 * 60_000,
+    "30m": 30 * 60_000,
+    "1h": 60 * 60_000,
+    "2h": 2 * 60 * 60_000,
+    "4h": 4 * 60 * 60_000,
+    "6h": 6 * 60 * 60_000,
+    "8h": 8 * 60 * 60_000,
+    "1d": 24 * 60 * 60_000,
+};
+/** Выравнивание timestamp вниз к границе свечи интервала. */
+const alignTs = (t, interval) => {
+    const step = STEP_MS[interval];
+    return Math.floor(t / step) * step;
+};
+/**
+ * Первая ПОЛНОСТЬЮ сформированная свеча, торгуемая БЕЗ look-ahead: если сигнал
+ * пришёл внутри минуты (ts > границы), свеча, СОДЕРЖАЩАЯ сигнал, ещё формируется —
+ * её close/high/low станут известны только в КОНЦЕ минуты, ПОСЛЕ сигнала. Входить
+ * в неё = заглядывать вперёд. Поэтому старт входа = следующая граница. Если сигнал
+ * ровно на границе (ts === aligned) — эта свеча открывается одновременно с сигналом
+ * и торгуема честно, не пропускаем.
+ */
+const entryStartTs = (t, interval) => {
+    const step = STEP_MS[interval];
+    const aligned = Math.floor(t / step) * step;
+    return aligned === t ? aligned : aligned + step;
+};
+
+/**
+ * Иерархический резолвер. Возвращает exit + уровень, с которого он разрешён,
+ * чтобы прод видел, обучен ли он персонально под (канал,символ,направление,режим)
+ * или это fallback.
+ */
+function resolveExit(tensor, mode, channel, symbol, direction, volRegime) {
+    const cell = tensor.cells[mode]?.[channel]?.[symbol]?.[direction]?.[volRegime];
+    if (cell)
+        return { exit: cell, source: "cell" };
+    const sd = tensor.bySymbolDir[mode]?.[symbol]?.[direction];
+    if (sd)
+        return { exit: sd, source: "symbol-dir" };
+    const modeLevel = tensor.byMode[mode];
+    if (modeLevel)
+        return { exit: modeLevel, source: "mode" };
+    return { exit: tensor.global, source: "global" };
+}
+/**
+ * Резолв БЕЗ volRegime (свечей нет): пропускаем cell-уровень (требует режима),
+ * начинаем с symbol-dir → mode → global.
+ */
+function resolveExitNoRegime(tensor, mode, symbol, direction) {
+    const sd = tensor.bySymbolDir[mode]?.[symbol]?.[direction];
+    if (sd)
+        return { exit: sd, source: "symbol-dir" };
+    const modeLevel = tensor.byMode[mode];
+    if (modeLevel)
+        return { exit: modeLevel, source: "mode" };
+    return { exit: tensor.global, source: "global" };
+}
+
+/**
+ * Перечисляет ВСЕ всплески при заданных (windowK, jaccardThreshold, lagPeakThreshold),
+ * НЕ отсекая по minClusters — это делает grid дёшево поверх готового списка.
+ * Кластеризация зависит от jaccard/lag/windowK, поэтому пересчитывается на эти оси grid;
+ * а minClusters — пост-фильтр, его перебор бесплатный.
+ */
+function enumerateBursts(items, windowK, jaccardThreshold, lagPeakThreshold, maxBurstWindowMs, stationarityWindowMs = Infinity) {
+    const events = items;
+    const fullTbl = buildTable(events);
+    // ── ДВА РАЗНЫХ ОКНА (их легко перепутать) ──
+    // 1) stationarityWindowMs — окно ИСТОРИИ для построения author-матрицы: как далеко
+    //    назад смотреть, чтобы понять КАКИЕ каналы — братский кластер. Infinity =
+    //    вся история (кластеры стабильны). НЕ длительность пампа и НЕ время удержания.
+    // 2) burst window = min(windowK·τ, maxBurstWindowMs) (ниже) — окно СИНХРОННОСТИ
+    //    самого пампа: события в этом окне на одном тикере = один всплеск. Ограничено
+    //    maxBurstWindowMs (обычно 1ч), поэтому ПАМП ВСЕГДА КОРОТКИЙ — растянутые на
+    //    часы/дни события НЕ собираются в один памп. Время удержания позиции — отдельно
+    //    (staleMinutes в replay), тоже конечное.
+    const buildAuthorCtx = (anchorTs) => {
+        const tbl = Number.isFinite(stationarityWindowMs)
+            ? buildWindowedTable(events, anchorTs, stationarityWindowMs)
+            : fullTbl;
+        const tau = selfTuneLag(tbl);
+        const window = Math.min(windowK * tau, maxBurstWindowMs); // окно СИНХРОННОСТИ пампа
+        const screened = jaccardScreen(tbl, window, jaccardThreshold);
+        const directed = lagXCorr(tbl, screened, lagPeakThreshold, window);
+        const clusterOf = clusterAuthors(tbl.channels, directed);
+        return { window, clusterOf };
+    };
+    // глобальный контекст для бесконечного окна (один раз)
+    const globalCtx = Number.isFinite(stationarityWindowMs) ? null : buildAuthorCtx(0);
+    const bursts = [];
+    for (const [k, evs] of fullTbl.byKey) {
+        const [symbol, direction] = splitKey(k);
+        // Раньше брался ОДИН best-per-symbol по всей истории — это ТЕРЯЛО разнесённые во
+        // времени всплески (второй памп на том же тикере молча отбрасывался вместе с его
+        // id). Теперь перечисляем все НЕПЕРЕСЕКАЮЩИЕСЯ по времени всплески: внутри каждого
+        // временно́го кластера берём лучший по clusters/confidence, но кластеры не сливаем.
+        let i = 0;
+        while (i < evs.length) {
+            // временно́й кластер: события, попадающие в окно синхронности от evs[i]
+            const ctxStart = globalCtx ?? buildAuthorCtx(evs[i].ts);
+            let j = i;
+            while (j + 1 < evs.length && evs[j + 1].ts - evs[i].ts <= ctxStart.window)
+                j++;
+            // лучший анкер внутри кластера [i..j]
+            let best = null;
+            for (let hi = i; hi <= j; hi++) {
+                const ctx = globalCtx ?? buildAuthorCtx(evs[hi].ts);
+                let lo = hi;
+                while (lo > i && evs[hi].ts - evs[lo - 1].ts <= ctx.window)
+                    lo--;
+                const slice = evs.slice(lo, hi + 1);
+                const clusters = new Set(slice.map((e) => ctx.clusterOf.get(e.channel)));
+                const channels = new Set(slice.map((e) => e.channel));
+                const dedup = clusters.size / channels.size;
+                const fill = Math.min(slice.length / 4, 1);
+                const rawAnchorId = evs[hi].id;
+                const anchorId = typeof rawAnchorId === "string" ? rawAnchorId : (typeof rawAnchorId === "number" ? String(rawAnchorId) : undefined);
+                const cand = {
+                    symbol, direction, ts: evs[hi].ts,
+                    independentClusters: clusters.size,
+                    totalChannels: channels.size,
+                    confidence: +(dedup * fill).toFixed(6),
+                    id: anchorId,
+                    // ids ВСЕГО временно́го кластера [i..j], чтобы ни один parser-item не пропал
+                    ids: evs.slice(i, j + 1).map((e) => {
+                        const r = e.id;
+                        return typeof r === "string" ? r : (typeof r === "number" ? String(r) : undefined);
+                    }).filter((x) => x != null),
+                };
+                if (!best || cand.independentClusters > best.independentClusters ||
+                    (cand.independentClusters === best.independentClusters && cand.confidence > best.confidence))
+                    best = cand;
+            }
+            if (best && best.independentClusters >= 1)
+                bursts.push(best);
+            i = j + 1; // следующий непересекающийся кластер
+        }
+    }
+    return bursts.sort((a, b) => a.ts - b.ts);
+}
+/**
+ * Перечисляет КАЖДЫЙ пост как кандидата (single-channel fallback), схлопывая
+ * близкие посты по одному (symbol,direction) в пределах окна в один вход.
+ * independentClusters=1 всегда — фильтра качества нет, исход решает exit.
+ */
+function enumeratePosts(items, windowK, maxBurstWindowMs) {
+    const tbl = buildTable(items);
+    const tau = selfTuneLag(tbl);
+    const window = Math.min(windowK * tau, maxBurstWindowMs);
+    const toId = (e) => {
+        const r = e.id;
+        return typeof r === "string" ? r : (typeof r === "number" ? String(r) : undefined);
+    };
+    const out = [];
+    for (const [k, evs] of tbl.byKey) {
+        const [symbol, direction] = splitKey(k);
+        let lastTs = -Infinity;
+        let current = null;
+        for (const e of evs) {
+            const id = toId(e);
+            if (e.ts - lastTs <= window) {
+                // пост схлопывается в текущий всплеск — но его id НЕ теряем: добавляем в ids,
+                // иначе исходный parser-item стал бы несопоставимым с результатом.
+                if (current && id != null)
+                    current.ids.push(id);
+                continue;
+            }
+            lastTs = e.ts;
+            current = {
+                symbol, direction, ts: e.ts,
+                independentClusters: 1, totalChannels: 1, confidence: 0.5,
+                id,
+                ids: id != null ? [id] : [],
+            };
+            out.push(current);
+        }
+    }
+    return out.sort((a, b) => a.ts - b.ts);
+}
+
+/** Максимум свечей в одном чанке (как CC_MAX_CANDLES_PER_REQUEST в проде). */
+const MAX_CANDLES_PER_CHUNK = 500;
+/**
+ * Chunked-загрузчик свечей. Дублирует логику пагинации из prod-адаптера: если
+ * запрошено больше MAX_CANDLES_PER_CHUNK, бьёт на чанки, двигая since вперёд на
+ * chunkLimit·step, и склеивает с дедупликацией по timestamp.
+ *
+ * Зачем внутри либы: labelBurst под длинный импакт-горизонт (staleMinutes до 1440)
+ * просит staleMinutes·2+5 ≈ 2885 свечей. Если адаптер пагинацию НЕ делает сам и
+ * упирается в лимит биржи, либа должна разрулить это сама, а не зависеть от того,
+ * как реализован чужой getCandles.
+ *
+ * Семантика — forward от since (case sDate+limit): возвращает ровно столько свечей,
+ * сколько доступно, начиная с align(since). Если адаптер на каком-то чанке вернул
+ * пусто (край истории / дыра) — останавливаемся и отдаём, что собрали.
+ */
+async function fetchCandlesChunked(getCandles, symbol, interval, limit, since, chunkSize = MAX_CANDLES_PER_CHUNK) {
+    const step = STEP_MS[interval];
+    const start = alignTs(since, interval);
+    // короткий путь: укладывается в один чанк → прямой вызов
+    if (limit <= chunkSize) {
+        return getCandles(symbol, interval, limit, start);
+    }
+    const all = [];
+    let remaining = limit;
+    let currentSince = start;
+    while (remaining > 0) {
+        const chunkLimit = Math.min(remaining, chunkSize);
+        const chunk = await getCandles(symbol, interval, chunkLimit, currentSince);
+        if (!chunk || chunk.length === 0)
+            break; // край истории / дыра — отдаём собранное
+        all.push(...chunk);
+        remaining -= chunkLimit;
+        if (remaining > 0)
+            currentSince = currentSince + chunkLimit * step;
+    }
+    // дедуп по timestamp (на стыках чанков адаптер может вернуть пограничную свечу
+    // дважды). Оставляем ПЕРВОЕ вхождение: при forward-пагинации первая свеча с данным
+    // ts пришла из более раннего/авторитетного чанка. Last-write мог бы подменить её
+    // повторной/битой копией из следующего чанка.
+    const seen = new Map();
+    for (const c of all) {
+        if (!seen.has(c.timestamp))
+            seen.set(c.timestamp, c);
+    }
+    const unique = Array.from(seen.values()).sort((a, b) => a.timestamp - b.timestamp);
+    return unique;
+}
+
+/**
+ * volZ: насколько объём входной свечи аномален против скользящего окна ДО входа.
+ * Высокий volZ = синхронный заход толпы в плечо (та самая «синяя свеча» из 1028592).
+ * baselineWindow — сколько свечей до входа берём за норму.
+ */
+function volumeZScore(candles, entryIdx, baselineWindow) {
+    const lo = Math.max(0, entryIdx - baselineWindow);
+    const base = candles.slice(lo, entryIdx);
+    if (base.length < 2)
+        return 0;
+    // битый/короткий массив: entryIdx может быть >= длины → candles[entryIdx] undefined.
+    const entry = candles[entryIdx];
+    if (!entry)
+        return 0;
+    const vols = base.map((c) => c.volume);
+    const mean = vols.reduce((s, v) => s + v, 0) / vols.length;
+    const variance = vols.reduce((s, v) => s + (v - mean) ** 2, 0) / (vols.length - 1);
+    const std = Math.sqrt(variance);
+    if (std === 0)
+        return 0;
+    return (entry.volume - mean) / std;
+}
+/**
+ * squeezePressure: доля объёма в окне после входа, пришедшегося на свечи, где цена
+ * двигалась ПРОТИВ позиции. Симметрично: для long «против» = свеча закрылась ниже
+ * открытия (давление вниз, каскад sell); для short «против» = выше (каскад buy).
+ *
+ * Высокое значение → движение питается ликвидациями толпы, а не честным потоком →
+ * это ловушка (stop hunt / squeeze), входить опасно либо выходить раньше.
+ */
+function squeezePressure(candles, entryIdx, dir, horizon) {
+    const end = Math.min(candles.length, entryIdx + horizon + 1);
+    let againstVol = 0;
+    let totalVol = 0;
+    for (let i = entryIdx + 1; i < end; i++) {
+        const c = candles[i];
+        const delta = c.close - c.open; // знак внутрисвечного движения
+        // «против позиции»: long не любит падение (delta<0), short не любит рост (delta>0)
+        const against = dir === "long" ? delta < 0 : delta > 0;
+        totalVol += c.volume;
+        if (against)
+            againstVol += c.volume;
+    }
+    if (totalVol === 0)
+        return 0;
+    return againstVol / totalVol;
+}
+/**
+ * LIVE-вариант squeezePressure: считает давление каскада по свечам СТРОГО ДО входа
+ * (никакого look-ahead). В live свечей ПОСЛЕ сигнала ещё нет — поэтому ловушку
+ * оцениваем по уже произошедшим свечам перед сигналом: высокая доля объёма на
+ * движениях против позиции в недавнем прошлом = рынок уже под давлением каскада.
+ *
+ * entryIdx — индекс входной свечи; окно [entryIdx-horizon, entryIdx) (НЕ включая
+ * саму входную, чтобы не зависеть от её формирования). Симметрия по dir та же.
+ */
+function squeezePressureBefore(candles, entryIdx, dir, horizon) {
+    const start = Math.max(0, entryIdx - horizon);
+    // КЛАМП верхней границы: при битом/коротком массиве свечей (флэки-адаптер биржи)
+    // entryIdx может оказаться > длины — без клампа цикл прочитает undefined и упадёт.
+    const end = Math.min(entryIdx, candles.length);
+    let againstVol = 0;
+    let totalVol = 0;
+    for (let i = start; i < end; i++) {
+        const c = candles[i];
+        const delta = c.close - c.open;
+        const against = dir === "long" ? delta < 0 : delta > 0;
+        totalVol += c.volume;
+        if (against)
+            againstVol += c.volume;
+    }
+    if (totalVol === 0)
+        return 0;
+    return againstVol / totalVol;
+}
+/** Считает оба признака разом для входа на entryIdx. */
+function volumeFeatures(candles, entryIdx, dir, baselineWindow, horizon) {
+    return {
+        volZ: volumeZScore(candles, entryIdx, baselineWindow),
+        squeezePressure: squeezePressure(candles, entryIdx, dir, horizon),
+    };
+}
+const volRegimeOf = (volZ, threshold) => volZ >= threshold ? "anomalous" : "calm";
+
+const signed = (entry, price, dir) => dir === "long" ? (price - entry) / entry : (entry - price) / entry;
+/** Обратная к signed: цена выхода по entry, реализованному pnl и направлению. */
+const exitPriceOf = (entry, pnl, dir) => dir === "long" ? entry * (1 + pnl) : entry * (1 - pnl);
+/**
+ * Прогоняет 1m-свечи через prod-выход. candles должны быть отсортированы по ts
+ * и покрывать окно от события вперёд (минимум до staleMinutes).
+ *
+ * entryFrom/entryTo — зона входа: вход на первой свече, чей хвост пересекает зону.
+ * entryPrice = close, если он попал в зону, иначе clamp midpoint к [low,high].
+ * Цена входа = кламп середины зоны в диапазон свечи (консервативно — фактическое касание).
+ */
+function replayExit(candles, dir, entryFrom, entryTo, p) {
+    const lo = Math.min(entryFrom, entryTo);
+    const hi = Math.max(entryFrom, entryTo);
+    // ── поиск входа: первая свеча, пересёкшая зону хвостом ──
+    let entryIdx = -1;
+    let entryPrice = 0;
+    for (let i = 0; i < candles.length; i++) {
+        const c = candles[i];
+        if (c.low <= hi && c.high >= lo) {
+            // зона задета хвостом. Уточняем цену входа: если close свечи попал В ЗОНУ,
+            // берём его (реальное закрытие в зоне — точнее фитиля). Иначе — точка зоны,
+            // ближайшая к диапазону свечи (clamp midpoint к [low,high], консервативно).
+            if (c.close >= lo && c.close <= hi) {
+                entryPrice = c.close;
+            }
+            else {
+                const mid = (lo + hi) / 2;
+                entryPrice = Math.min(Math.max(mid, c.low), c.high);
+            }
+            entryIdx = i;
+            break;
+        }
+    }
+    if (entryIdx < 0 || !(entryPrice > 0)) {
+        return {
+            pnl: 0, reason: "no-entry", peak: 0, heldMinutes: 0, entered: false,
+            entryPrice: 0, exitPrice: 0,
+            volZ: 0, squeezePressure: 0, volRegime: "calm", inverted: false, truncated: false,
+        };
+    }
+    // ── объёмные признаки на входе (симметрично для long/short) ──
+    const baseWin = p.volBaselineWindow ?? 20;
+    const volZThr = p.volZThreshold ?? 2.0;
+    // окно детекции каскада — СВОЁ, не life-cap. Сквиз быстрый: мерить его на всём
+    // горизонте удержания неверно (длинное окно размывает резкий разворот).
+    const sqHorizon = p.cascadeWindowMinutes ?? p.staleMinutes;
+    const volZ = volumeZScore(candles, entryIdx, baseWin);
+    const sqPressure = squeezePressure(candles, entryIdx, dir, sqHorizon);
+    const volRegime = volRegimeOf(volZ, volZThr);
+    // VETO: высокий squeezePressure при политике veto → не входим вовсе.
+    // Симметрично режет и long-каскад, и short-сквиз.
+    const sqThr = p.squeezeThreshold ?? 0.6;
+    if (p.squeezePolicy === "veto" && sqPressure >= sqThr) {
+        return {
+            pnl: 0, reason: "cascade-veto", peak: 0, heldMinutes: 0, entered: false,
+            entryPrice, exitPrice: 0,
+            volZ, squeezePressure: sqPressure, volRegime, inverted: false, truncated: false,
+        };
+    }
+    // INVERT: каскад уверенно сносит толпу в обратную сторону (stop hunt из 1028592).
+    // Вместо защиты — заходим ПРОТИВ поста и снимаем сам сквиз. Метку ставит replay
+    // противоположного направления из той же точки; exit берётся из инверс-ячейки тензора.
+    if (p.squeezePolicy === "invert" && sqPressure >= sqThr) {
+        const opposite = dir === "long" ? "short" : "long";
+        // прогон без повторной инверсии (policy=none), чтобы не зациклиться
+        const inv = replayExit(candles, opposite, entryFrom, entryTo, {
+            ...p, squeezePolicy: "none",
+        });
+        return {
+            ...inv,
+            // reason СОХРАНЯЕТ настоящий механизм выхода инвертированной позиции
+            // (hard-stop/trailing-take/life-cap), а факт инверсии несёт флаг inverted.
+            // Раньше reason затирался на "invert", что скрывало, КАК закрылась инверсия.
+            inverted: inv.entered,
+            // объёмные признаки оставляем от исходного входа (они про сам каскад)
+            volZ, squeezePressure: sqPressure, volRegime,
+        };
+    }
+    // TIGHTEN: при каскаде ужимаем trailing, чтобы выскочить до разворота.
+    const tighten = p.squeezePolicy === "tighten" && sqPressure >= sqThr
+        ? (p.tightenFactor ?? 0.5) : 1;
+    const hardStopFrac = p.hardStop / 100;
+    const trailFrac = (p.trailingTake * tighten) / 100;
+    const stalenessProfitFrac = p.stalenessSinceProfit / 100;
+    let peak = 0; // пиковый PnL за жизнь (доли)
+    let peakMinute = 0; // минута достижения пика
+    const forwardAvail = candles.length - entryIdx - 1;
+    const lifeCap = Math.min(p.staleMinutes, forwardAvail);
+    // Боковик/край данных: если после входа осталось МЕНЬШЕ свечей, чем требует
+    // life-cap, замер горизонта неполный. Помечаем — labelBurst отбросит такую метку,
+    // чтобы не сравнивать 24ч-горизонт по обрезанному до пары часов пути.
+    // Допуск 5% — мелкая нехватка в конце не критична.
+    const truncated = forwardAvail < p.staleMinutes * 0.95;
+    for (let k = 0; k <= lifeCap; k++) {
+        const c = candles[entryIdx + k];
+        const minute = k; // 1m свечи → k минут от входа
+        // внутрисвечные экстремумы PnL: для long худшее = low, лучшее = high; для short наоборот
+        const pnlAtLow = signed(entryPrice, c.low, dir);
+        const pnlAtHigh = signed(entryPrice, c.high, dir);
+        const worst = Math.min(pnlAtLow, pnlAtHigh);
+        const best = Math.max(pnlAtLow, pnlAtHigh);
+        // 1) HARD STOP — внутрисвечной прокол против позиции на hardStop% от входа.
+        //    Приоритет стопа над тейком в той же свече (консервативно, как в проде стоп жёсткий).
+        if (worst <= -hardStopFrac) {
+            // ЧЕСТНЫЙ реализованный PnL: стоп исполняется на уровне -hardStop%, это и есть
+            // результат сделки. Раньше возвращался lastPositivePeak (≥0), из-за чего стоп
+            // НИКОГДА не показывал убыток — это завышало pnl и отравляло RR/CV-объектив
+            // (оптимизатор не видел риск стопов). peak сохраняется отдельно для диагностики.
+            return {
+                pnl: -hardStopFrac,
+                reason: "hard-stop",
+                peak,
+                heldMinutes: minute,
+                entered: true,
+                entryPrice, exitPrice: exitPriceOf(entryPrice, -hardStopFrac, dir),
+                volZ, squeezePressure: sqPressure, volRegime, inverted: false, truncated,
+            };
+        }
+        // обновляем пик по лучшему внутрисвечному PnL
+        if (best > peak) {
+            peak = best;
+            peakMinute = minute;
+        }
+        // 2) TRAILING TAKE — позиция в плюсе и откат от пика ≥ trailingTake%.
+        //    Откат меряем по close свечи (как listenActivePing на закрытии свечи).
+        const closePnl = signed(entryPrice, c.close, dir);
+        if (closePnl >= 0 && peak - closePnl >= trailFrac && peak > 0) {
+            return {
+                pnl: peak, // фиксируем по достигнутому пику (последний плюсовой trailingTake)
+                reason: "trailing-take",
+                peak,
+                heldMinutes: minute,
+                entered: true,
+                entryPrice, exitPrice: exitPriceOf(entryPrice, peak, dir),
+                volZ, squeezePressure: sqPressure, volRegime, inverted: false, truncated,
+            };
+        }
+        // 3) PEAK STALENESS — пик достиг порога прибыли и протух по времени.
+        if (peak >= stalenessProfitFrac && minute - peakMinute >= p.stalenessSinceMinutes) {
+            return {
+                pnl: peak,
+                reason: "peak-staleness",
+                peak,
+                heldMinutes: minute,
+                entered: true,
+                entryPrice, exitPrice: exitPriceOf(entryPrice, peak, dir),
+                volZ, squeezePressure: sqPressure, volRegime, inverted: false, truncated,
+            };
+        }
+    }
+    // 4) LIFE CAP — потолок жизни позиции. Выход по close последней свечи окна.
+    //    Честный реализованный PnL (может быть отрицательным, если позиция в минусе).
+    const lastIdx = entryIdx + lifeCap;
+    const finalPnl = signed(entryPrice, candles[lastIdx].close, dir);
+    return {
+        pnl: finalPnl,
+        reason: "life-cap",
+        peak,
+        heldMinutes: lifeCap,
+        entered: true,
+        entryPrice, exitPrice: exitPriceOf(entryPrice, finalPnl, dir),
+        volZ, squeezePressure: sqPressure, volRegime, inverted: false, truncated,
+    };
+}
+
+/** Стабильный строковый ключ exit-набора для кэша/grid. */
+const exitKey = (p) => `tt${p.trailingTake}|hs${p.hardStop}|sp${p.stalenessSinceProfit}|sm${p.stalenessSinceMinutes}|life${p.staleMinutes}` +
+    `|vz${p.volZThreshold ?? "_"}|pol${p.squeezePolicy ?? "none"}|sqt${p.squeezeThreshold ?? "_"}|bw${p.volBaselineWindow ?? "_"}|cw${p.cascadeWindowMinutes ?? "_"}`;
+/**
+ * Достаёт 1m-свечи от события вперёд на покрытие максимального life-cap и
+ * прогоняет каждый exit-набор через replay. Зона входа берётся из события;
+ * если не задана — точка entryFrom=entryTo=open первой свечи.
+ */
+async function labelBurst(getCandles, symbol, direction, ts, exitSets, entryFromPrice, entryToPrice) {
+    const maxLife = Math.max(...exitSets.map((e) => e.staleMinutes));
+    // старт = первая полностью сформированная свеча ПОСЛЕ сигнала (без look-ahead):
+    // свеча, содержащая сигнал, ещё формируется — её OHLC известны только в конце минуты.
+    const since = entryStartTs(ts, "1m");
+    const limit = maxLife * 2 + 5; // запас на поиск входа в зону
+    // getCandles может бросить (look-ahead guard на хвосте истории, дыры в данных
+    // символа — частое у меме-коинов с делистингом/паузами торгов, строгий count-match
+    // адаптера). Тогда этот кандидат НЕ размечается и пропускается — но обучение в целом
+    // не падает. Один битый символ не должен ронять весь fit.
+    let candles;
+    try {
+        candles = await fetchCandlesChunked(getCandles, symbol, "1m", limit, since);
+    }
+    catch {
+        return null;
+    }
+    if (!candles || candles.length === 0)
+        return null;
+    const from = entryFromPrice ?? candles[0].open;
+    const to = entryToPrice ?? candles[0].open;
+    const byExit = new Map();
+    for (const ex of exitSets) {
+        const r = replayExit(candles, direction, from, to, ex);
+        // отбрасываем метку с НЕПОЛНЫМ горизонтом: в боковике вход случился поздно,
+        // и после него не хватило свечей на полный life-cap. Иначе 24ч-горизонт
+        // сравнивался бы с 1ч-горизонтом по обрезанному до пары часов пути — это
+        // прямо корраптит impactHorizonMinutes (главный исследовательский выход).
+        // no-entry (entered=false без truncated) сохраняем — это валидная метка «не вошли».
+        if (r.truncated && r.entered)
+            continue;
+        byExit.set(exitKey(ex), r);
+    }
+    const anyEntered = [...byExit.values()].some((r) => r.entered);
+    if (byExit.size === 0 || !anyEntered)
+        return null;
+    return { symbol, direction, ts, byExit };
+}
+
+/**
+ * Objective для подбора порогов: shrinkage-expectancy.
+ *
+ *   score = mean(returns) · N/(N+k)
+ *
+ * Средний forward-return отобранных всплесков, усаженный к нулю при малой выборке.
+ * Без усадки grid выбрал бы вырожденный порог, ловящий 1 жирный всплеск и
+ * рапортующий «идеальный эдж» — ровно ловушка winrate-68%-с-чёрным-лебедем.
+ * k — сила усадки (по умолчанию 5): при N=k вклад режется вдвое.
+ */
+function shrinkageExpectancy(returns, k = 5) {
+    const n = returns.length;
+    if (n === 0)
+        return 0;
+    const mean = returns.reduce((s, r) => s + r, 0) / n;
+    return mean * (n / (n + k));
+}
+/** Доля положительных (winrate) — для отчёта, не для оптимизации. */
+function winrate(returns) {
+    if (returns.length === 0)
+        return 0;
+    return returns.filter((r) => r > 0).length / returns.length;
+}
+/**
+ * Стандартная ошибка среднего по фолдам: SE = std(foldScores) / sqrt(n).
+ * std — выборочное (делитель n-1). При n<2 SE=0 (разброс не оценить).
+ */
+function standardError(foldScores) {
+    const n = foldScores.length;
+    if (n < 2)
+        return 0;
+    const mean = foldScores.reduce((s, x) => s + x, 0) / n;
+    const variance = foldScores.reduce((s, x) => s + (x - mean) ** 2, 0) / (n - 1);
+    return Math.sqrt(variance) / Math.sqrt(n);
+}
+/**
+ * One-standard-error rule (Breiman 1984) — против winner's curse при grid-search.
+ *
+ * Проблема: argmax по CV-score из N конфигураций систематически завышен — максимум
+ * шумных оценок смещён вверх на ~sigma·sqrt(2·ln N) даже при истинном edge=0. Чем
+ * больше grid, тем сильнее переобучение на шум выборки.
+ *
+ * Правило: берём НЕ максимум, а самую КОНСЕРВАТИВНУЮ конфигурацию среди тех, чей
+ * score в пределах 1 SE от максимума. Разница внутри 1 SE статистически незначима
+ * (внутри шума), поэтому вместо счастливого выброса выбираем робастную конфигурацию.
+ *
+ * @param entries    кандидаты
+ * @param scoreOf    извлечь CV-score кандидата
+ * @param foldsOf    извлечь fold-scores кандидата (для SE максимума)
+ * @param isSimpler  компаратор «a консервативнее b» (true → предпочесть a)
+ */
+function oneStandardErrorSelect(entries, scoreOf, foldsOf, isSimpler, seMultiplier = 1) {
+    if (entries.length === 0)
+        return null;
+    let best = entries[0];
+    for (const e of entries)
+        if (scoreOf(e) > scoreOf(best))
+            best = e;
+    // SE по фолдам ПОБЕДИТЕЛЯ — разброс его собственной оценки. seMultiplier
+    // расширяет/сужает коридор (1 = классический Breiman).
+    const se = standardError(foldsOf(best)) * seMultiplier;
+    const threshold = scoreOf(best) - se;
+    let chosen = best;
+    for (const e of entries) {
+        if (scoreOf(e) < threshold)
+            continue; // вне коридора SE
+        if (isSimpler(e, chosen))
+            chosen = e; // консервативнее → берём
+    }
+    return chosen;
+}
+/**
+ * Перцентиль p (0..1) по выборке методом линейной интерполяции (type-7, как в numpy).
+ * percentile([...], 0.95) = P95. Пустая выборка → 0.
+ */
+function percentile(xs, p) {
+    // отбрасываем NaN/Infinity: одна битая свеча не должна молча отравить перцентиль
+    const clean = xs.filter((x) => Number.isFinite(x));
+    if (clean.length === 0)
+        return 0;
+    if (clean.length === 1)
+        return clean[0];
+    const sorted = [...clean].sort((a, b) => a - b);
+    const idx = p * (sorted.length - 1);
+    const lo = Math.floor(idx);
+    const hi = Math.ceil(idx);
+    if (lo === hi)
+        return sorted[lo];
+    const frac = idx - lo;
+    return sorted[lo] * (1 - frac) + sorted[hi] * frac;
+}
+/**
+ * RR на сделку = pnl / hardStop (реализованный в единицах риска — сколько R сняли).
+ * Считает mean / P95 / P99 по парам (pnl, hardStop). Сделки с hardStop ≤ 0
+ * пропускаются (деление на ноль). Главный исследовательский выход бэктеста.
+ */
+function riskRewardStats(trades) {
+    const rr = [];
+    for (const t of trades) {
+        // только конечные значения: битый pnl/hardStop не должен отравить RR
+        if (t.hardStop > 0 && Number.isFinite(t.pnl))
+            rr.push(t.pnl / (t.hardStop / 100));
+    }
+    if (rr.length === 0)
+        return { mean: 0, p95: 0, p99: 0, n: 0 };
+    const mean = rr.reduce((s, x) => s + x, 0) / rr.length;
+    return {
+        mean: +mean.toFixed(6),
+        p95: +percentile(rr, 0.95).toFixed(6),
+        p99: +percentile(rr, 0.99).toFixed(6),
+        n: rr.length,
+    };
+}
+function pnlStats(pnls) {
+    const clean = pnls.filter((x) => Number.isFinite(x));
+    if (clean.length === 0)
+        return { mean: 0, median: 0, p5: 0, p95: 0, p99: 0, n: 0 };
+    const mean = clean.reduce((s, x) => s + x, 0) / clean.length;
+    return {
+        mean: +mean.toFixed(6),
+        median: +percentile(clean, 0.5).toFixed(6),
+        p5: +percentile(clean, 0.05).toFixed(6),
+        p95: +percentile(clean, 0.95).toFixed(6),
+        p99: +percentile(clean, 0.99).toFixed(6),
+        n: clean.length,
+    };
+}
+
+/**
+ * Достоверность обучения. Отвечает на вопрос «можно ли доверять подобранным
+ * порогам», а НЕ «велик ли эдж». На малой выборке confidence низкий и
+ * reliable=false (либа работает, но честно предупреждает); по мере роста
+ * данных все три оси растут → confidence→1, reliable переключается сам.
+ *
+ *   confidence = support × stability × significance   (каждое в [0,1])
+ *
+ * Менять код при росте выборки не нужно — формула пересчитывает доверие.
+ */
+const DEFAULT_RELIABILITY = {
+    supportK: 30,
+    confidenceThreshold: 0.6,
+    minN: 40,
+};
+function mean$1(a) {
+    return a.length ? a.reduce((s, x) => s + x, 0) / a.length : 0;
+}
+function std(a) {
+    if (a.length < 2)
+        return 0;
+    const m = mean$1(a);
+    const v = a.reduce((s, x) => s + (x - m) ** 2, 0) / (a.length - 1);
+    return Math.sqrt(v);
+}
+/**
+ * support: насыщающаяся функция объёма N/(N+k). Растёт от 0 к 1 с числом сделок.
+ */
+function supportScore(totalN, k) {
+    return totalN / (totalN + k);
+}
+/**
+ * stability: эдж должен быть положителен в КАЖДОМ фолде, а не в одном жирном.
+ * Берём долю фолдов с положительным средним × (1 − нормированный разброс знаков).
+ * Один фолд → стабильность недоказуема → 0.5 (нейтрально, не штрафуем и не верим).
+ */
+function stabilityScore(foldMeans) {
+    if (foldMeans.length === 0)
+        return 0;
+    if (foldMeans.length === 1)
+        return 0.5;
+    const posShare = foldMeans.filter((m) => m > 0).length / foldMeans.length;
+    const m = mean$1(foldMeans);
+    const s = std(foldMeans);
+    // коэффициент вариации знака: малый разброс относительно среднего → стабильно
+    const cv = m !== 0 ? Math.min(s / Math.abs(m), 1) : 1;
+    return posShare * (1 - cv);
+}
+/**
+ * significance: на сколько стандартных ошибок среднее отстоит от нуля.
+ * t = mean / (std/√N). Прогоняем через сглаживающую сигмоиду в [0,1]:
+ * t≈0 → 0, t≈2 (≈95%) → ~0.76, t≥3 → ~0.9+.
+ */
+function significanceScore(returns) {
+    const n = returns.length;
+    if (n < 2)
+        return 0;
+    const m = mean$1(returns);
+    const s = std(returns);
+    if (m <= 0)
+        return 0; // неположительный эдж — нулевая значимость «полезности»
+    // НУЛЕВАЯ или околонулевая дисперсия (std пренебрежимо мал относительно |mean|):
+    // все ретёрны фактически идентичны. Это НЕ бесконечная значимость, а вырожденные
+    // данные (один исход N раз = артефакт). Порог относительный — std([0.001]×N) даёт
+    // не ровно 0, а ~1e-19 из-за floating point, что без проверки даёт t≈1e16 → sig≈1.
+    if (s <= Math.abs(m) * 1e-9) {
+        return 1 - Math.exp(-n / 200); // N=40→0.18, N=140→0.5, N=600→0.95
+    }
+    const t = (m / (s / Math.sqrt(n)));
+    if (t <= 0)
+        return 0;
+    return 1 - Math.exp(-t / 2); // насыщающаяся: t=2→0.63, t=4→0.86, t=6→0.95
+}
+function computeReliability(input, cfg = DEFAULT_RELIABILITY) {
+    const totalN = input.foldSizes.reduce((s, x) => s + x, 0);
+    const support = supportScore(totalN, cfg.supportK);
+    const stability = stabilityScore(input.foldMeans);
+    const significance = significanceScore(input.allReturns);
+    const confidence = +(support * stability * significance).toFixed(6);
+    const reliable = confidence >= cfg.confidenceThreshold && totalN >= cfg.minN;
+    return {
+        confidence,
+        reliable,
+        support: +support.toFixed(6),
+        stability: +stability.toFixed(6),
+        significance: +significance.toFixed(6),
+        totalN,
+    };
+}
+
+/**
+ * Прогрессбар обучения. Train делает вложенные циклы: фаза разметки (медленная,
+ * каждый кандидат = await getCandles по 1m-свечам) и фаза grid-скоринга (быстрая,
+ * чистый CPU по кэшу). Бар отражает РЕАЛЬНУЮ работу — тики разметки, где идёт IO.
+ *
+ * Передаётся в train как опция onProgress; по умолчанию пишет в stdout в стиле,
+ * заданном пользователем. В тестах подменяется на no-op или сборщик, чтобы не
+ * засорять вывод.
+ */
+const BAR_LENGTH = 30;
+const BAR_FILLED_CHAR = "\u2588";
+const BAR_EMPTY_CHAR = "\u2591";
+/** Дефолтный stdout-бар в стиле пользователя. */
+const stdoutProgress = (e) => {
+    if (e.total <= 0)
+        return;
+    const ratio = Math.min(e.done / e.total, 1);
+    const percent = Math.round(ratio * 100);
+    const filled = Math.round(ratio * BAR_LENGTH);
+    const empty = BAR_LENGTH - filled;
+    const bar = BAR_FILLED_CHAR.repeat(filled) + BAR_EMPTY_CHAR.repeat(empty);
+    process.stdout.write(`\r[${bar}] ${percent}% (${e.done}/${e.total}) ${e.phase} ${e.label}`);
+    if (e.done >= e.total)
+        process.stdout.write("\n");
+};
+/** No-op для тестов/тихого режима. */
+const silentProgress = () => { };
+
+const DEFAULT_POLICY = {
+    allow: ["enter", "invert", "tighten"],
+};
+/**
+ * Пересечение политик: эффективный allow = trained ∩ requested.
+ * Реализует readonly-инвариант — запрос не может разрешить то, чего нет в обученной.
+ * RR-фильтр (minRiskReward/rrMetric) — чисто рантаймовый: запрос может его ужесточить,
+ * обученная политика дефолта не несёт (RR-статистика отдельно в params.riskReward).
+ */
+function intersectPolicy(trained, requested) {
+    const allow = !requested?.allow
+        ? [...trained.allow]
+        : [...new Set(requested.allow.filter((a) => new Set(trained.allow).has(a)))]; // ∩ + дедуп
+    // minRiskReward: запрос может только УЖЕСТОЧИТЬ (поднять порог), не ослабить.
+    // Берём максимум из обученного и запрошенного — иначе рантайм-запрос мог бы
+    // снизить вшитый защитный порог риска, что нарушает инвариант «только сужение».
+    let minRiskReward;
+    if (trained.minRiskReward !== undefined && requested?.minRiskReward !== undefined) {
+        minRiskReward = Math.max(trained.minRiskReward, requested.minRiskReward);
+    }
+    else {
+        minRiskReward = requested?.minRiskReward ?? trained.minRiskReward;
+    }
+    return {
+        allow,
+        minRiskReward,
+        rrMetric: requested?.rrMetric ?? trained.rrMetric ?? "mean",
+    };
+}
+
+/**
+ * Математический аппарат для отличия РЕАЛЬНОГО эджа от ВЫБРОСА/оверфита.
+ *
+ * Брутфорс-grid (argmax по CV из N конфигов) систематически выдаёт ложный эдж:
+ * максимум N шумных оценок смещён вверх на ≈ σ·√(2·ln N) даже при истинном эдже 0.
+ * Эти функции дают СТАТИСТИЧЕСКИЙ СЕРТИФИКАТ, а не «score повыше».
+ *
+ * Ссылки: López de Prado (Deflated Sharpe 2014, PBO 2015, minTRL),
+ * White (Reality Check 2000), Hansen (SPA 2005), Politis-Romano (stationary
+ * bootstrap 1994), Breiman (1-SE 1984).
+ *
+ * Все функции — чистые над массивами ретёрнов сделок. Без внешних зависимостей.
+ */
+// ── базовая статистика моментов ──
+function mean(a) {
+    return a.length ? a.reduce((s, x) => s + x, 0) / a.length : 0;
+}
+function variance(a) {
+    if (a.length < 2)
+        return 0;
+    if (!a.every(Number.isFinite))
+        return NaN; // NaN/Inf → честный NaN, не мусор
+    // Welford (online): численно устойчивее наивной суммы квадратов при mean >> spread
+    // (catastrophic cancellation). Один проход, без хранения (x-m) больших величин.
+    let m = 0, m2 = 0, n = 0;
+    for (const x of a) {
+        n++;
+        const d = x - m;
+        m += d / n;
+        m2 += d * (x - m);
+    }
+    return m2 / (a.length - 1);
+}
+function stdev(a) {
+    return Math.sqrt(variance(a));
+}
+/** Выборочный коэффициент асимметрии (Fisher-Pearson). */
+function skewness(a) {
+    const n = a.length;
+    if (n < 3 || !a.every(Number.isFinite))
+        return 0;
+    const m = mean(a);
+    const s = stdev(a);
+    if (s === 0)
+        return 0;
+    const m3 = a.reduce((acc, x) => acc + ((x - m) / s) ** 3, 0) / n;
+    return m3;
+}
+/** Выборочный куртозис (НЕ excess: нормаль = 3). */
+function kurtosis(a) {
+    const n = a.length;
+    if (n < 4 || !a.every(Number.isFinite))
+        return 3;
+    const m = mean(a);
+    const s = stdev(a);
+    if (s === 0)
+        return 3;
+    return a.reduce((acc, x) => acc + ((x - m) / s) ** 4, 0) / n;
+}
+/** Sharpe ratio по ряду ретёрнов (без аннуализации; per-trade). */
+function sharpe(returns) {
+    if (returns.length === 0 || !returns.every(Number.isFinite))
+        return 0; // NaN/Inf → 0, не распространяем
+    const s = stdev(returns);
+    const m = mean(returns);
+    // DUST-порог: std — пыль, ТОЛЬКО если на уровне floating-point шума САМИХ значений
+    // (масштаб данных × machine epsilon), а НЕ относительно mean. Прошлый порог
+    // |mean|·1e-9 ошибочно убивал ВЫСОКИЙ Sharpe (малый std при большом mean — это и
+    // есть высокий Sharpe, не пыль). Масштаб = max|x|.
+    const scale = Math.max(...returns.map((x) => Math.abs(x)), Math.abs(m));
+    const dustFloor = scale * 1e-13; // ~500× machine epsilon (2.2e-16) от масштаба данных
+    if (s <= dustFloor)
+        return 0;
+    return m / s;
+}
+// ── нормальное распределение ──
+/** CDF стандартной нормали через erf-приближение Abramowitz-Stegun 7.1.26. */
+function normalCdf(z) {
+    const t = 1 / (1 + 0.2316419 * Math.abs(z));
+    const d = 0.3989422804014327 * Math.exp(-z * z / 2);
+    const p = d * t * (0.319381530 + t * (-0.356563782 + t * (1.781477937 + t * (-1.821255978 + t * 1.330274429))));
+    return z >= 0 ? 1 - p : p;
+}
+/** Обратная нормаль (quantile) — Acklam 2003. Точность ~1e-9 в [1e-15, 1-1e-15]. */
+function normalInv(p) {
+    if (p <= 0)
+        return -Infinity;
+    if (p >= 1)
+        return Infinity;
+    const a = [-39.69683028665376, 2.209460984245205e2, -275.9285104469687, 1.383577518672690e2, -30.66479806614716, 2.506628277459239];
+    const b = [-54.47609879822406, 1.615858368580409e2, -155.6989798598866, 6.680131188771972e1, -13.28068155288572];
+    const c = [-0.007784894002430293, -0.3223964580411365, -2.400758277161838, -2.549732539343734, 4.374664141464968, 2.938163982698783];
+    const d = [7.784695709041462e-3, 3.224671290700398e-1, 2.445134137142996, 3.754408661907416];
+    const pl = 0.02425, ph = 1 - pl;
+    let q, r;
+    if (p < pl) {
+        q = Math.sqrt(-2 * Math.log(p));
+        return (((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5]) / ((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1);
+    }
+    else if (p <= ph) {
+        q = p - 0.5;
+        r = q * q;
+        return (((((a[0] * r + a[1]) * r + a[2]) * r + a[3]) * r + a[4]) * r + a[5]) * q / (((((b[0] * r + b[1]) * r + b[2]) * r + b[3]) * r + b[4]) * r + 1);
+    }
+    else {
+        q = Math.sqrt(-2 * Math.log(1 - p));
+        return -(((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5]) / ((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1);
+    }
+}
+const EULER_MASCHERONI = 0.5772156649015329;
+/**
+ * Ожидаемый МАКСИМАЛЬНЫЙ Sharpe при истинном эдже 0, если перебрано N независимых
+ * конфигураций с дисперсией SR-оценок varSR. Это «планка случайности»: насколько
+ * высокий Sharpe выскочит из чистого шума просто потому, что мы выбрали лучший из N.
+ *
+ * E[max] ≈ √varSR · [(1−γ)·Z(1−1/N) + γ·Z(1−1/(N·e))]   (López de Prado 2014)
+ */
+function expectedMaxSharpe(varSR, nTrials) {
+    if (nTrials < 1)
+        return 0;
+    const sd = Math.sqrt(Math.max(varSR, 0));
+    if (nTrials === 1)
+        return 0;
+    const z1 = normalInv(1 - 1 / nTrials);
+    const z2 = normalInv(1 - 1 / (nTrials * Math.E));
+    return sd * ((1 - EULER_MASCHERONI) * z1 + EULER_MASCHERONI * z2);
+}
+/**
+ * Deflated Sharpe Ratio: вероятность, что ИСТИННЫЙ Sharpe > порога случайности,
+ * с поправкой на (а) число испытаний N, (б) асимметрию/куртозис ряда, (в) длину T.
+ *
+ * DSR = Φ( (SR − SR0)·√(T−1) / √(1 − skew·SR + (kurt−1)/4·SR²) )
+ *
+ * SR — наблюдаемый Sharpe лучшей стратегии; SR0 — expectedMaxSharpe(varSR, N).
+ * Возвращает p ∈ [0,1]. p ≥ 0.95 → эдж РЕАЛЕН с учётом перебора. На малой выборке
+ * или огромном N → p ≈ 0 (честный отказ вместо ложного «reliable»).
+ */
+function deflatedSharpe(returns, nTrials, varSRAcrossTrials) {
+    const T = returns.length;
+    if (T < 2)
+        return 0;
+    const sr = sharpe(returns);
+    const sr0 = expectedMaxSharpe(varSRAcrossTrials, nTrials);
+    const sk = skewness(returns);
+    const ku = kurtosis(returns);
+    const denom = Math.sqrt(Math.max(1 - sk * sr + ((ku - 1) / 4) * sr * sr, 1e-12));
+    const z = ((sr - sr0) * Math.sqrt(T - 1)) / denom;
+    const result = normalCdf(z);
+    return Number.isFinite(result) ? result : 0; // не-finite → 0 (fail-closed, не ложный высокий DSR)
+}
+/**
+ * Минимальная длина ряда (число сделок), при которой наблюдаемый Sharpe значим на
+ * уровне α (по умолчанию 0.05). Если фактическое N < minTRL — выборки физически НЕ
+ * хватает, любой вывод преждевременен. Это «сколько сделок до доверия».
+ *
+ * minTRL = 1 + [1 − skew·SR + (kurt−1)/4·SR²]·(Z_α / SR)²   (López de Prado)
+ */
+function minTrackRecordLength(returns, alpha = 0.05) {
+    const sr = sharpe(returns);
+    // SR ≤ 0: стратегия не прибыльна → значимость положительного эджа недостижима
+    // НИКОГДА. Возвращаем Infinity, а не маленькое число (формула (z/SR)² теряет знак
+    // при возведении в квадрат и дала бы абсурдно малый minTRL для убыточной стратегии).
+    if (sr <= 0)
+        return Infinity;
+    const sk = skewness(returns);
+    const ku = kurtosis(returns);
+    const z = normalInv(1 - alpha);
+    return 1 + (1 - sk * sr + ((ku - 1) / 4) * sr * sr) * (z / sr) ** 2;
+}
+/**
+ * Probability of Backtest Overfitting через Combinatorially-Symmetric CV (CSCV).
+ *
+ * Матрица M[config][fold] (perf каждого конфига на каждом фолде). Делим S фолдов
+ * на все C(S, S/2) комбинаций IS/OOS. На каждой: выбираем лучший конфиг по IS,
+ * смотрим его РАНГ на OOS. Если IS-лучший систематически плох на OOS — это оверфит.
+ *
+ * PBO = доля разбиений, где IS-лучший попал в нижнюю половину OOS (logit < 0).
+ * PBO → 0.5 = чистый оверфит; PBO → 0 = эдж переносится OOS.
+ *
+ * @param perf perf[c][f] — метрика конфига c на фолде f (больше = лучше)
+ */
+function probabilityOfBacktestOverfitting(perf) {
+    const nConfigs = perf.length;
+    if (nConfigs === 0)
+        return NaN; // нечего оценивать → НЕ выдаём ложный 0.5
+    const S = perf[0].length;
+    if (S < 2 || S % 2 !== 0) {
+        // CSCV требует чётное число фолдов ≥ 2. Возвращаем NaN (не 0.5!), иначе
+        // реальный эдж с нечётным числом фолдов читался бы как «оверфит». Вызывающий
+        // обязан проверить Number.isNaN и не пускать модель, а не получить ложный сигнал.
+        return NaN;
+    }
+    const half = S / 2;
+    const folds = Array.from({ length: S }, (_, i) => i);
+    const combos = chooseCombinations(folds, half);
+    let overfit = 0;
+    let total = 0;
+    for (const isSet of combos) {
+        const isIn = new Set(isSet);
+        const oosSet = folds.filter((f) => !isIn.has(f));
+        const isPerf = perf.map((row) => mean(isSet.map((f) => row[f])));
+        const oosPerf = perf.map((row) => mean(oosSet.map((f) => row[f])));
+        let bestC = 0;
+        for (let c = 1; c < nConfigs; c++)
+            if (isPerf[c] > isPerf[bestC])
+                bestC = c;
+        const oosVal = oosPerf[bestC];
+        // MIDRANK для корректной обработки ничьих: строго меньшие + половина равных
+        // (минус сам конфиг). Без этого все-равные значения занижают ранг → ложный оверфит.
+        const less = oosPerf.filter((v) => v < oosVal).length;
+        const eq = oosPerf.filter((v) => v === oosVal).length;
+        const rank = less + (eq - 1) / 2;
+        const omega = (rank + 0.5) / nConfigs;
+        const logit = Math.log(omega / (1 - omega + 1e-12));
+        // СТРОГО < 0: ровно медиана (omega=0.5, нет ни эджа ни оверфита) не считается оверфитом
+        if (logit < 0)
+            overfit++;
+        total++;
+    }
+    return total ? overfit / total : NaN;
+}
+/** Все сочетания по k из массива (для CSCV; k=S/2, S обычно ≤ 12). */
+function chooseCombinations(arr, k) {
+    const res = [];
+    const combo = [];
+    const rec = (start) => {
+        if (combo.length === k) {
+            res.push([...combo]);
+            return;
+        }
+        for (let i = start; i < arr.length; i++) {
+            combo.push(arr[i]);
+            rec(i + 1);
+            combo.pop();
+        }
+    };
+    rec(0);
+    return res;
+}
+/**
+ * Stationary bootstrap (Politis-Romano 1994): ресэмпл ряда блоками случайной
+ * геометрической длины (средняя 1/p), сохраняя автокорреляцию. Для зависимых рядов
+ * сделок обычный i.i.d. бутстрэп даёт оптимистичный результат — блочность чинит это.
+ */
+function stationaryBootstrapResample(returns, pBlock, rng) {
+    const n = returns.length;
+    if (n === 0)
+        return [];
+    const out = [];
+    let idx = Math.floor(rng() * n);
+    for (let i = 0; i < n; i++) {
+        out.push(returns[idx]);
+        if (rng() < pBlock)
+            idx = Math.floor(rng() * n); // новый блок
+        else
+            idx = (idx + 1) % n; // продолжаем блок
+    }
+    return out;
+}
+/** Детерминированный ГПСЧ (mulberry32) — воспроизводимые бутстрэп-прогоны в тестах. */
+function mulberry32(seed) {
+    let a = seed >>> 0;
+    return () => {
+        a |= 0;
+        a = (a + 0x6D2B79F5) | 0;
+        let t = Math.imul(a ^ (a >>> 15), 1 | a);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+/**
+ * White's Reality Check / Hansen SPA через stationary bootstrap.
+ * H0: лучшая из N стратегий НЕ лучше бенчмарка 0 (весь эдж — data-snooping).
+ *
+ * Статистика V = max_k √T · mean(returns_k). Бутстрэпим центрированные ряды,
+ * считаем распределение макс-статистики при H0, p-value = доля бутстрэп-V,
+ * превысивших наблюдаемый V. p ≤ 0.05 → отвергаем H0 (эдж не объясним перебором).
+ *
+ * @param strategiesReturns массив рядов (по одному на конфиг-кандидат)
+ */
+function realityCheckPValue(strategiesReturns, opts = {}) {
+    const B = opts.bootstraps ?? 1000;
+    const pBlock = opts.pBlock ?? 0.1; // средняя длина блока 10
+    const rng = mulberry32(opts.seed ?? 12345);
+    const K = strategiesReturns.length;
+    if (K === 0)
+        return 1;
+    // наблюдаемая макс-статистика
+    const stat = (rs, baseMean) => Math.sqrt(rs.length) * (mean(rs) - baseMean);
+    let observedV = -Infinity;
+    for (const rs of strategiesReturns)
+        observedV = Math.max(observedV, stat(rs, 0));
+    // бутстрэп под H0: центрируем каждую стратегию на её среднем
+    let exceed = 0;
+    for (let b = 0; b < B; b++) {
+        let vb = -Infinity;
+        for (const rs of strategiesReturns) {
+            const m = mean(rs);
+            const resampled = stationaryBootstrapResample(rs, pBlock, rng);
+            // центрированная статистика: √T·(mean(resample) − mean(original))
+            vb = Math.max(vb, stat(resampled, m));
+        }
+        if (vb >= observedV)
+            exceed++;
+    }
+    return (exceed + 1) / (B + 1); // +1 — несмещённая бутстрэп p-value (Davison-Hinkley)
+}
+function certifyStrategy(inp, thresholds = {}) {
+    const dsrThr = thresholds.dsr ?? 0.95;
+    const pboThr = thresholds.pbo ?? 0.10;
+    const spaThr = thresholds.spa ?? 0.05;
+    const dsr = deflatedSharpe(inp.selectedReturns, inp.nTrials, inp.varSRAcrossTrials);
+    const pbo = probabilityOfBacktestOverfitting(inp.perfMatrix);
+    const spaPValue = realityCheckPValue(inp.candidateReturns);
+    const minTRL = minTrackRecordLength(inp.selectedReturns);
+    const actualN = inp.selectedReturns.length;
+    const reasons = [];
+    if (dsr < dsrThr)
+        reasons.push(`DSR ${dsr.toFixed(3)} < ${dsrThr} — эдж не переживает поправку на ${inp.nTrials} испытаний`);
+    if (Number.isNaN(pbo))
+        reasons.push(`PBO не оценить (нужно чётное число фолдов ≥ 2 и ≥1 конфиг) — нельзя сертифицировать вслепую`);
+    else if (pbo > pboThr)
+        reasons.push(`PBO ${pbo.toFixed(3)} > ${pboThr} — конфиг оверфитнут (CSCV)`);
+    if (spaPValue > spaThr)
+        reasons.push(`SPA p-value ${spaPValue.toFixed(3)} > ${spaThr} — эдж объясним data-snooping`);
+    if (actualN < minTRL)
+        reasons.push(`N=${actualN} < minTRL=${minTRL.toFixed(0)} — выборки недостаточно`);
+    if (inp.nestedScore !== null && inp.nestedScore <= 0)
+        reasons.push(`nested OOS-score ${inp.nestedScore.toFixed(4)} ≤ 0 — несмещённый прогноз не положителен`);
+    return {
+        certified: reasons.length === 0,
+        dsr, pbo, spaPValue, minTRL, actualN,
+        nestedScore: inp.nestedScore, reasons,
+    };
+}
+
+/**
+ * Мета-учёт переобучений — против МЕТА-winner's-curse.
+ *
+ * Проблема (Tripolsky): DSR штрафует N конфигов ВНУТРИ одного fit, но если гонять
+ * fit 720 раз за месяц (ежечасно) и торговать только когда выпал certified=true —
+ * это повторный перебор УЖЕ ПО ВРЕМЕНИ. Каждый «сертифицированный» прогон может быть
+ * тем самым выбросом среди 720 попыток. Сертификат на отдельном fit слеп к цепочке.
+ *
+ * Лечение (двухчастное):
+ *  1) CADENCE GUARD: запрет частого переобучения. fit разрешён не чаще minRefitMs
+ *     (дни/недели, не часы). Частые refit = размножение испытаний.
+ *  2) FAMILY-WISE коррекция: эффективное число испытаний = N_внутри × число_fit_попыток.
+ *     ВСЕ попытки логируются (не только certified), иначе знаменатель занижен и
+ *     поправка лжёт. DSR на эффективном N нейтрализует мета-curse (доказано тестом:
+ *     720 fit на шуме → наивно 2 ложных, мета 0).
+ */
+const DEFAULT_META_POLICY = {
+    minRefitMs: 7 * 24 * 3600_000, // неделя
+};
+/** Пустой реестр. */
+function emptyLedger() {
+    return { attempts: [] };
+}
+/**
+ * Разрешён ли новый fit сейчас по cadence-политике. Возвращает {allowed, reason,
+ * nextAllowedTs}. Частое переобучение размножает испытания → запрещаем.
+ */
+function canRefit(ledger, now, policy = DEFAULT_META_POLICY) {
+    if (ledger.attempts.length === 0) {
+        return { allowed: true, reason: "первый fit", nextAllowedTs: now };
+    }
+    const last = ledger.attempts[ledger.attempts.length - 1].ts;
+    const nextAllowedTs = last + policy.minRefitMs;
+    if (now >= nextAllowedTs) {
+        return { allowed: true, reason: "интервал выдержан", nextAllowedTs };
+    }
+    const hoursLeft = (nextAllowedTs - now) / 3600_000;
+    return {
+        allowed: false,
+        reason: `слишком частый refit: до следующего разрешённого ${hoursLeft.toFixed(1)}ч. ` +
+            `Частое переобучение размножает испытания (мета-winner's-curse).`,
+        nextAllowedTs,
+    };
+}
+/** Регистрирует попытку fit (ЛЮБУЮ — и certified, и нет). Возвращает новый реестр. */
+function recordAttempt(ledger, attempt) {
+    return { attempts: [...ledger.attempts, attempt] };
+}
+/**
+ * Эффективное число испытаний для family-wise коррекции DSR: суммарно по ВСЕМ
+ * fit-попыткам, не только текущей. Если за месяц было M fit-ов с N конфигов каждый —
+ * эффективно перебрано до Σ Nᵢ гипотез. Это и есть честный знаменатель для DSR.
+ *
+ * Используется как nTrials в deflatedSharpe вместо одного board.length. Так
+ * сертификат учитывает, что ты гонял fit многократно и выбираешь успешные.
+ */
+function effectiveTrials(ledger, currentInnerTrials) {
+    const past = ledger.attempts.reduce((s, a) => s + a.innerTrials, 0);
+    return Math.max(past + currentInnerTrials, currentInnerTrials, 1);
+}
+/**
+ * Сколько РАЗ был запущен fit (длина цепочки попыток + текущая). Для отчёта и для
+ * грубой Bonferroni-поправки порога значимости при желании.
+ */
+function fitAttemptCount(ledger) {
+    return ledger.attempts.length;
+}
+
+const DEFAULT_SELECTION = {
+    seMultiplier: 1,
+    nestedOuterFolds: 4,
+};
+/**
+ * Порядок агрессии реакции на каскад: чем выше, тем агрессивнее вмешательство.
+ * ignore (вход вопреки каскаду) ≈ none (просто вход) < tighten (ужать) <
+ * veto (не входить) < invert (развернуться).
+ * Используется как ось консервативности: при near-tie выбираем менее агрессивную.
+ * ignore намеренно НЕ реагирует на каскад → наименее консервативная реакция (0).
+ */
+const CASCADE_AGGRESSION = {
+    ignore: 0,
+    none: 0,
+    tighten: 1,
+    veto: 2,
+    invert: 3,
+};
+const cascadeAggressionOf = (policy) => CASCADE_AGGRESSION[policy ?? "none"] ?? CASCADE_AGGRESSION.none;
+/**
+ * Ключ консервативности exit-конфигурации для one-standard-error tie-break.
+ * Лексикографический порядок (меньше = консервативнее):
+ *   1) hardStop          — меньший риск на сделку
+ *   2) staleMinutes      — короче экспозиция
+ *   3) cascade aggression— мягче вмешательство в каскад
+ *   4) -cvScore          — при полном равенстве выше score (детерминизм)
+ *
+ * `score` передаётся отдельно, т.к. ExitParams его не содержит.
+ */
+function conservatismKey(exit, cvScore) {
+    return [
+        exit.hardStop,
+        exit.staleMinutes,
+        cascadeAggressionOf(exit.squeezePolicy),
+        -cvScore,
+    ];
+}
+/** Сравнение «a консервативнее b» по лексикографическому ключу (true → предпочесть a). */
+function isMoreConservative(a, b) {
+    const ka = conservatismKey(a.exit, a.cvScore);
+    const kb = conservatismKey(b.exit, b.cvScore);
+    for (let i = 0; i < ka.length; i++) {
+        if (ka[i] < kb[i])
+            return true;
+        if (ka[i] > kb[i])
+            return false;
+    }
+    return false;
+}
+
+const DEFAULT_GRID = {
+    windowK: [2, 3, 5],
+    minClusters: [2, 3],
+    jaccardThreshold: [0.3, 0.4], // 0.2 почти никогда не выбирался — убран ради размера грида
+    lagPeakThreshold: [0.4, 0.5], // 0.6 редко лучше — убран ради размера грида
+    trailingTake: [0.5, 1.0, 2.0],
+    hardStop: [1.0, 2.0, 3.0],
+    stalenessSinceProfit: [0.5, 1.0, 2.0], // порог прибыли (%) для вооружения staleness-выхода
+    stalenessSinceMinutes: [60, 120, 240], // минут застоя от пика до выхода (число staleness-минут)
+    staleMinutes: [60, 240, 720], // 1ч / 4ч / 12ч (24ч редко оптимален для коротких пампов)
+    volZThreshold: [1.5, 2.5], // когда считать объём аномальным (накопление топлива)
+    squeezePolicy: ["none", "tighten", "veto", "invert"], // train выберет реакцию по CV
+    squeezeThreshold: [0.55, 0.7], // доля объёма против позиции для срабатывания
+    volBaselineWindow: [20],
+    cascadeWindowMinutes: [15, 30, 60], // окно детекции каскада: 15м / 30м / 1ч (быстрое событие)
+    // вся история + конечные окна (4 / 8 недель); train выберет по CV
+    stationarityWindowMs: [7 * 24 * 3600_000, 14 * 24 * 3600_000, 28 * 24 * 3600_000, 56 * 24 * 3600_000],
+};
+// ─────────────────────────── time-series K-fold ──────────────────────────────
+function timeSeriesFolds(n, folds) {
+    const out = [];
+    const seg = Math.max(1, Math.floor(n / (folds + 1)));
+    for (let f = 1; f <= folds; f++) {
+        const valLo = f * seg;
+        const valHi = f === folds ? n : (f + 1) * seg;
+        if (valLo < valHi)
+            out.push({ valLo, valHi });
+    }
+    return out;
+}
+// ──────────────────────────────── train ──────────────────────────────────────
+/**
+ * Обучает пороги детектора И параметры prod-выхода на исторических данных.
+ * Метку ставит симуляция твоего trailing/hard-stop по 1m-свечам (replay),
+ * поэтому stop hunting размечается как убыток. Объектив — shrinkage-expectancy
+ * под time-series K-fold. Эмпирически выбирает импакт-горизонт (staleMinutes).
+ */
+async function train(items, getCandles, opts = {}) {
+    const grid = { ...DEFAULT_GRID, ...opts.grid };
+    const folds = opts.folds ?? 4;
+    const shrinkageK = opts.shrinkageK ?? 5;
+    const selection = { ...DEFAULT_SELECTION, ...opts.selection };
+    const maxBurstWindowMs = opts.maxBurstWindowMs ?? DEFAULT_CONFIG.maxBurstWindowMs;
+    // разрешаем эффективный режим обучения — тем же строгим критерием, что и predict
+    const reqMode = opts.mode ?? "auto";
+    let effMode;
+    let modeReason;
+    if (reqMode === "matrix") {
+        effMode = "matrix";
+        modeReason = "matrix задан явно (opts.mode)";
+    }
+    else if (reqMode === "single") {
+        effMode = "single";
+        modeReason = "single задан явно (opts.mode)";
+    }
+    else {
+        // auto: пробный прогон матрицы на средних порогах + оценка жизнеспособности
+        const probeTbl = buildTable(items.map((i) => ({
+            channel: i.channel, symbol: i.symbol, direction: i.direction, ts: i.ts,
+            entryFromPrice: i.entryFromPrice, entryToPrice: i.entryToPrice,
+        })));
+        const probeTau = selfTuneLag(probeTbl);
+        const probeWin = Math.min(3 * probeTau, maxBurstWindowMs);
+        const probeScreened = jaccardScreen(probeTbl, probeWin, 0.3);
+        const probeDirected = lagXCorr(probeTbl, probeScreened, 0.5, probeWin);
+        const probeAuthors = clusterAuthors(probeTbl.channels, probeDirected);
+        const v = assessViability(probeTbl, probeDirected, probeAuthors, {
+            ...DEFAULT_VIABILITY, ...opts.viability,
+        });
+        effMode = v.viable ? "matrix" : "single";
+        // честная авто-диагностика: ПОЧЕМУ выбран режим (видно в meta.modeReason)
+        modeReason = `auto → ${effMode}: ${v.reason}`;
+    }
+    // индекс зоны входа по (symbol|direction|ts) — убирает O(n²) find
+    const entryIndex = new Map();
+    for (const it of items)
+        entryIndex.set(`${it.symbol}|${it.direction}|${it.ts}`, it);
+    // полный список exit-наборов (декартово произведение exit+volume осей)
+    const exitSets = [];
+    for (const tt of grid.trailingTake)
+        for (const hs of grid.hardStop)
+            for (const sp of grid.stalenessSinceProfit)
+                for (const sm of grid.stalenessSinceMinutes)
+                    for (const life of grid.staleMinutes)
+                        for (const vz of grid.volZThreshold)
+                            for (const pol of grid.squeezePolicy)
+                                for (const sqt of grid.squeezeThreshold)
+                                    for (const bw of grid.volBaselineWindow)
+                                        for (const cw of grid.cascadeWindowMinutes)
+                                            exitSets.push({
+                                                trailingTake: tt, hardStop: hs,
+                                                stalenessSinceProfit: sp, stalenessSinceMinutes: sm, staleMinutes: life,
+                                                volZThreshold: vz, squeezePolicy: pol,
+                                                squeezeThreshold: sqt, volBaselineWindow: bw,
+                                                cascadeWindowMinutes: cw,
+                                            });
+    const labeledCache = new Map();
+    const seenCluster = new Set();
+    const labelCandidates = async (cands, onTick) => {
+        const labeled = [];
+        for (const b of cands) {
+            const src = entryIndex.get(`${b.symbol}|${b.direction}|${b.ts}`);
+            const lb = await labelBurst(getCandles, b.symbol, b.direction, b.ts, exitSets, src?.entryFromPrice, src?.entryToPrice);
+            onTick?.(b.symbol);
+            if (!lb)
+                continue;
+            const byExit = new Map();
+            // veto-вход (entered=false, reason=cascade-veto) тоже несёт сигнал: его pnl=0,
+            // и он ДОЛЖЕН учитываться как «не вошли и не потеряли», иначе policy=veto нечестно
+            // сравнивать с policy=none. Поэтому храним и не-entered, помечая флагом.
+            for (const [k, r] of lb.byExit) {
+                byExit.set(k, {
+                    pnl: r.pnl, volRegime: r.volRegime, entered: r.entered,
+                    entryPrice: r.entryPrice, exitPrice: r.exitPrice, reason: r.reason,
+                    heldMinutes: r.heldMinutes, peak: r.peak, inverted: r.inverted,
+                });
+            }
+            if (byExit.size === 0)
+                continue;
+            labeled.push({
+                channel: src?.channel ?? "_unknown",
+                symbol: b.symbol, direction: b.direction, ts: b.ts,
+                independentClusters: b.independentClusters,
+                id: b.id, ids: b.ids,
+                byExit,
+            });
+        }
+        return labeled;
+    };
+    // ── фаза разметки с прогрессом ──
+    // предварительно перечисляем кандидатов по каждому ключу кластеризации (дёшево,
+    // pure CPU без IO), чтобы знать ГЛОБАЛЬНЫЙ total медленных labelBurst-вызовов.
+    const progress = opts.onProgress ?? stdoutProgress;
+    const passes = [];
+    // окно стационарности влияет ТОЛЬКО на matrix (author-матрица); в single посты
+    // не используют матрицу, поэтому там окно не перебираем (одно значение).
+    const swAxis = effMode === "single" ? [Infinity] : grid.stationarityWindowMs;
+    for (const wK of grid.windowK)
+        for (const jac of grid.jaccardThreshold)
+            for (const lag of grid.lagPeakThreshold)
+                for (const sw of swAxis) {
+                    const ckey = `${wK}|${jac}|${lag}|${sw}`;
+                    if (seenCluster.has(ckey))
+                        continue;
+                    seenCluster.add(ckey);
+                    if (effMode === "single") {
+                        const skey = `single|${wK}`;
+                        if (labeledCache.has(`__enum_${skey}`)) {
+                            passes.push({ ckey, skey, cands: [] });
+                            continue;
+                        }
+                        labeledCache.set(`__enum_${skey}`, []); // маркер «уже перечислили»
+                        passes.push({ ckey, skey, cands: enumeratePosts(items, wK, maxBurstWindowMs) });
+                    }
+                    else {
+                        passes.push({ ckey, cands: enumerateBursts(items, wK, jac, lag, maxBurstWindowMs, sw) });
+                    }
+                }
+    labeledCache.clear();
+    seenCluster.clear();
+    const totalTicks = passes.reduce((s, p) => s + p.cands.length, 0);
+    let doneTicks = 0;
+    const tick = (symbol) => {
+        doneTicks++;
+        progress({ done: doneTicks, total: totalTicks, phase: "label", label: symbol });
+    };
+    for (const p of passes) {
+        let labeled;
+        if (p.skey) {
+            if (!labeledCache.has(p.skey)) {
+                labeledCache.set(p.skey, await labelCandidates(p.cands, tick));
+            }
+            labeled = labeledCache.get(p.skey);
+        }
+        else {
+            labeled = await labelCandidates(p.cands, tick);
+        }
+        labeledCache.set(p.ckey, labeled);
+    }
+    if (totalTicks > 0)
+        progress({ done: totalTicks, total: totalTicks, phase: "label", label: "done" });
+    // grid: детектор × exit, CV-score под K-fold
+    // в single-режиме minClusters не применяется (всегда 1) — кандидаты уже все посты
+    const minClusterAxis = effMode === "single" ? [1] : grid.minClusters;
+    const board = [];
+    // total для фазы score = число (wK×jac×lag×sw) комбинаций (тик на каждую)
+    const scoreTotal = grid.windowK.length * grid.jaccardThreshold.length
+        * grid.lagPeakThreshold.length * swAxis.length;
+    // буримая функция скоринга: строит board по всем конфигам, учитывая только те
+    // размеченные всплески, что проходят keep(ts). keep=()=>true → весь board.
+    // onTick(label) вызывается после каждой (wK×jac×lag×sw)-комбинации (для прогресса).
+    const buildBoard = (keep, onTick) => {
+        const out = [];
+        for (const wK of grid.windowK)
+            for (const jac of grid.jaccardThreshold)
+                for (const lag of grid.lagPeakThreshold)
+                    for (const sw of swAxis) {
+                        const labeled = (effMode === "single"
+                            ? labeledCache.get(`single|${wK}`)
+                            : labeledCache.get(`${wK}|${jac}|${lag}|${sw}`)).filter((b) => keep(b.ts));
+                        for (const minC of minClusterAxis)
+                            for (const ex of exitSets) {
+                                const ekey = exitKey(ex);
+                                const selected = labeled
+                                    .filter((b) => b.independentClusters >= minC && b.byExit.has(ekey))
+                                    .sort((a, b) => a.ts - b.ts);
+                                const cfg = cfgOf(wK, minC, jac, lag, maxBurstWindowMs, effMode, sw);
+                                if (selected.length === 0) {
+                                    out.push({ config: cfg, exit: ex, cvScore: 0, cvWinrate: 0, cvSupport: 0,
+                                        _foldMeans: [], _foldSizes: [], _returns: [], _foldScores: [] });
+                                    continue;
+                                }
+                                const foldSpecs = timeSeriesFolds(selected.length, folds);
+                                const foldScores = [], foldMeans = [], foldWins = [], foldSupp = [], allRet = [];
+                                for (const { valLo, valHi } of foldSpecs) {
+                                    const valRet = selected.slice(valLo, valHi).map((b) => b.byExit.get(ekey).pnl);
+                                    foldScores.push(shrinkageExpectancy(valRet, shrinkageK));
+                                    foldMeans.push(valRet.length ? valRet.reduce((s, x) => s + x, 0) / valRet.length : 0);
+                                    foldWins.push(winrate(valRet));
+                                    foldSupp.push(valRet.length);
+                                    allRet.push(...valRet);
+                                }
+                                const avg = (a) => (a.length ? a.reduce((s, x) => s + x, 0) / a.length : 0);
+                                out.push({
+                                    config: cfg, exit: ex,
+                                    cvScore: +avg(foldScores).toFixed(6),
+                                    cvWinrate: +avg(foldWins).toFixed(6),
+                                    cvSupport: +avg(foldSupp).toFixed(2),
+                                    _foldMeans: foldMeans, _foldSizes: foldSupp, _returns: allRet, _foldScores: foldScores,
+                                });
+                            }
+                        onTick?.(`${wK}|${jac}|${lag}|${sw === Infinity ? "all" : sw}`);
+                    }
+        return out;
+    };
+    // основной board — по всем данным, с прогрессом фазы score
+    let scoreDone = 0;
+    board.push(...buildBoard(() => true, (label) => {
+        scoreDone++;
+        progress({ done: scoreDone, total: scoreTotal, phase: "score", label });
+    }));
+    // ── выбор победителя: one-standard-error rule (против winner's curse) ──
+    // вместо argmax по cvScore берём самую КОНСЕРВАТИВНУЮ конфигурацию среди тех,
+    // чей score в пределах SE от максимума. Это убирает переобучение на шум grid:
+    // разница внутри SE статистически незначима, поэтому robustness > удача.
+    // Порядок консервативности и пороги — в selection.ts, без магических литералов.
+    const top = oneStandardErrorSelect(board, (e) => e.cvScore, (e) => e._foldScores, (a, b) => isMoreConservative(a, b), selection.seMultiplier);
+    // board всё равно сортируем по score — для отчёта/аудита (gridSize, диагностика)
+    board.sort((a, b) => b.cvScore - a.cvScore);
+    // ── nested CV: несмещённая оценка прод-эджа (не меняет ВЫБОР, только оценку) ──
+    // Внешние фолды по времени: на каждом train-срезе заново выбираем конфиг (1-SE),
+    // оцениваем на held-out test-срезе. Среднее out-of-sample = честная оценка того,
+    // что ждёт на проде, без winner's curse. ВЫБОР модели остаётся за полным 1-SE выше.
+    // Прогресс тикает на КАЖДЫЙ внешний фолд → терминал не молчит дольше одного фолда.
+    let nestedScore = null;
+    if (selection.nestedOuterFolds >= 2) {
+        // временные границы: все ts размеченных всплесков из основного кэша
+        const allBurstTs = [];
+        for (const [k, labeled] of labeledCache) {
+            if (k.startsWith("__enum_"))
+                continue;
+            for (const b of labeled)
+                allBurstTs.push(b.ts);
+        }
+        allBurstTs.sort((a, b) => a - b);
+        const uniqTs = [...new Set(allBurstTs)];
+        if (uniqTs.length >= selection.nestedOuterFolds) {
+            const oosScores = [];
+            const K = selection.nestedOuterFolds;
+            const foldSize = Math.floor(uniqTs.length / K);
+            for (let f = 0; f < K; f++) {
+                // outer-test = f-й временной блок; outer-train = всё остальное
+                const testLo = uniqTs[f * foldSize];
+                const testHi = f === K - 1 ? Infinity : uniqTs[(f + 1) * foldSize];
+                const inTest = (ts) => ts >= testLo && (testHi === Infinity ? true : ts < testHi);
+                const inTrain = (ts) => !inTest(ts);
+                // на train-срезе выбираем конфиг тем же 1-SE
+                const trainBoard = buildBoard(inTrain);
+                const trainTop = oneStandardErrorSelect(trainBoard, (e) => e.cvScore, (e) => e._foldScores, (a, b) => isMoreConservative(a, b), selection.seMultiplier);
+                // оцениваем выбранный конфиг на held-out test-срезе
+                if (trainTop) {
+                    const testBoard = buildBoard(inTest);
+                    const match = testBoard.find((e) => exitKey(e.exit) === exitKey(trainTop.exit) &&
+                        e.config.windowK === trainTop.config.windowK &&
+                        e.config.minClusters === trainTop.config.minClusters &&
+                        e.config.jaccardThreshold === trainTop.config.jaccardThreshold &&
+                        e.config.lagPeakThreshold === trainTop.config.lagPeakThreshold &&
+                        e.config.stationarityWindowMs === trainTop.config.stationarityWindowMs);
+                    if (match)
+                        oosScores.push(match.cvScore);
+                }
+                progress({ done: f + 1, total: K, phase: "nested", label: `fold ${f + 1}/${K}` });
+            }
+            nestedScore = oosScores.length
+                ? +(oosScores.reduce((s, x) => s + x, 0) / oosScores.length).toFixed(6)
+                : null;
+        }
+    }
+    const reliability = computeReliability({ foldMeans: top._foldMeans, foldSizes: top._foldSizes, allReturns: top._returns }, { ...DEFAULT_RELIABILITY, ...opts.reliability });
+    // ── СЕРТИФИКАТ: математически доказуемый эдж, а не argmax по шуму ──
+    // DSR (поправка на N испытаний) + PBO (CSCV-оверфит) + SPA (data-snooping) +
+    // minTRL (достаточность выборки) + nested OOS. certified=true только если эдж
+    // переживает ВСЕ барьеры. Это и отличает реальный эдж от выброса.
+    const candPool = board
+        .filter((e) => e._returns.length > 0)
+        .slice(0, 50)
+        .map((e) => e._returns);
+    // perf-матрица для PBO: топ-конфиги × их fold-scores (нужно чётное число фолдов)
+    const perfRows = board
+        .filter((e) => e._foldScores.length >= 2)
+        .slice(0, 30)
+        .map((e) => e._foldScores.slice(0, e._foldScores.length - (e._foldScores.length % 2)));
+    const evenFolds = perfRows.length && perfRows.every((r) => r.length === perfRows[0].length && r.length >= 2);
+    // дисперсия Sharpe ПО испытаниям (планка случайности для DSR)
+    const trialSharpes = board
+        .filter((e) => e._returns.length >= 2)
+        .map((e) => sharpe(e._returns));
+    const varSR = variance(trialSharpes);
+    // эффективное число испытаний: family-wise по ВСЕМ fit-попыткам (мета-curse),
+    // а не только текущему гриду. Без metaLedger — наивный board.length (одиночный fit).
+    const innerTrials = Math.max(board.length, 1);
+    const nTrialsEff = opts.metaLedger
+        ? effectiveTrials(opts.metaLedger, innerTrials)
+        : innerTrials;
+    const certification = certifyStrategy({
+        selectedReturns: top._returns,
+        nTrials: nTrialsEff,
+        varSRAcrossTrials: varSR,
+        perfMatrix: evenFolds ? perfRows : [],
+        candidateReturns: candPool.length ? candPool : [top._returns],
+        nestedScore,
+    });
+    // ── exit tensor: лучший exit на каждую ячейку [channel][symbol][direction][volRegime] ──
+    // detector-конфиг выбран глобально; exit считаем per-cell, НЕ смешивая математику
+    // источников. Каскад ликвидаций симметричен: long-trap и short-trap — РАЗНЫЕ ячейки.
+    const winLabeled = effMode === "single"
+        ? labeledCache.get(`single|${top.config.windowK}`)
+        : labeledCache.get(`${top.config.windowK}|${top.config.jaccardThreshold}|${top.config.lagPeakThreshold}|${top.config.stationarityWindowMs}`);
+    const winSelected = winLabeled
+        .filter((b) => b.independentClusters >= top.config.minClusters)
+        .sort((a, b) => a.ts - b.ts);
+    // выбор лучшего exit по подвыборке + опц. фильтру volRegime.
+    // Если regime задан — учитываем только результаты, чей volRegime под данным exit совпал.
+    const pickExit = (subset, regime) => {
+        if (subset.length === 0)
+            return null;
+        let best = null;
+        for (const ex of exitSets) {
+            const ekey = exitKey(ex);
+            const rows = subset
+                .map((b) => b.byExit.get(ekey))
+                .filter((r) => !!r && (regime === undefined || r.volRegime === regime));
+            if (rows.length === 0)
+                continue;
+            const foldSpecs = timeSeriesFolds(rows.length, folds);
+            const scores = [];
+            for (const { valLo, valHi } of foldSpecs) {
+                scores.push(shrinkageExpectancy(rows.slice(valLo, valHi).map((r) => r.pnl), shrinkageK));
+            }
+            const avg = scores.length ? scores.reduce((s, x) => s + x, 0) / scores.length : 0;
+            if (!best || avg > best.score)
+                best = { ex, score: avg };
+        }
+        return best?.ex ?? null;
+    };
+    const globalExit = pickExit(winSelected) ?? top.exit;
+    const modeExit = pickExit(winSelected) ?? globalExit;
+    // bySymbolDir: схлопнут volRegime
+    const bySymbolDir = {};
+    const cells = {};
+    // ключ канала для ячейки: в matrix-режиме всплеск МЕЖКАНАЛЬНЫЙ (нет одного
+    // владельца), поэтому ячейки кладём под канонический "_matrix" — ровно тот ключ,
+    // которым их потом ищет buildPlan для matrix-вердиктов (у них channel=null).
+    // В single-режиме канал реальный — exit персонален каналу.
+    const cellChannel = (realChannel) => effMode === "matrix" ? "_matrix" : realChannel;
+    // группировка
+    const group = new Map(); // key = channel|symbol|direction
+    const groupSD = new Map(); // key = symbol|direction
+    for (const b of winSelected) {
+        const gk = `${cellChannel(b.channel)}\u0001${b.symbol}\u0001${b.direction}`;
+        (group.get(gk) ?? group.set(gk, []).get(gk)).push(b);
+        const sk = `${b.symbol}\u0001${b.direction}`;
+        (groupSD.get(sk) ?? groupSD.set(sk, []).get(sk)).push(b);
+    }
+    // symbol-dir уровень (fallback при пустом volRegime)
+    for (const [sk, subset] of groupSD) {
+        const [symbol, direction] = sk.split("\u0001");
+        const ex = pickExit(subset);
+        if (ex)
+            (bySymbolDir[symbol] ??= {})[direction] = ex;
+    }
+    // cell уровень: отдельный exit на каждый volRegime (calm/anomalous)
+    for (const [gk, subset] of group) {
+        const [channel, symbol, direction] = gk.split("\u0001");
+        for (const regime of ["calm", "anomalous"]) {
+            const ex = pickExit(subset, regime);
+            if (!ex)
+                continue;
+            (((cells[channel] ??= {})[symbol] ??= {})[direction] ??= {})[regime] = ex;
+        }
+    }
+    const emptyCh = {};
+    const emptySD = {};
+    const tensor = {
+        cells: {
+            matrix: effMode === "matrix" ? cells : emptyCh,
+            single: effMode === "single" ? cells : emptyCh,
+        },
+        bySymbolDir: {
+            matrix: effMode === "matrix" ? bySymbolDir : emptySD,
+            single: effMode === "single" ? bySymbolDir : emptySD,
+        },
+        byMode: { matrix: modeExit, single: modeExit },
+        global: globalExit,
+    };
+    // ── risk-reward: исследовательский выход бэктеста ──
+    // RR = pnl / hardStop по сделкам с ВЫБРАННЫМ для символа exit. Считаем per-symbol
+    // (для runtime-фильтра по символам) и global (для отчёта). Сделки берём из winSelected
+    // под exit, реально назначенный символу (symbol-dir уровень), чтобы RR соответствовал
+    // тому, что прод исполнит.
+    const rrTradesBySymbol = new Map();
+    const rrTradesGlobal = [];
+    const pnlsBySymbol = new Map();
+    const pnlsGlobal = [];
+    // история сигналов выбранной конфигурации (для dump → внешней аналитики).
+    // Берём exit, выбранный для каждого (symbol,direction) — то, что исполнит прод.
+    const history = [];
+    for (const [sk, subset] of groupSD) {
+        const [symbol, direction] = sk.split("\u0001");
+        const ex = bySymbolDir[symbol]?.[direction];
+        if (!ex)
+            continue;
+        const ekey = exitKey(ex);
+        for (const b of subset) {
+            const r = b.byExit.get(ekey);
+            if (!r)
+                continue;
+            // запись истории — для ВСЕХ сигналов (вошли/не вошли), чтобы аналитика
+            // могла считать и пропуски (veto/no-entry), и реализованные сделки
+            history.push({
+                id: b.id, ids: b.ids,
+                symbol, direction, channel: b.channel, ts: b.ts,
+                entered: r.entered, entryPrice: r.entryPrice, exitPrice: r.exitPrice,
+                pnl: r.pnl, peak: r.peak, reason: r.reason, heldMinutes: r.heldMinutes,
+                inverted: r.inverted, volRegime: r.volRegime,
+                independentClusters: b.independentClusters,
+            });
+            if (!r.entered)
+                continue;
+            const trade = { pnl: r.pnl, hardStop: ex.hardStop };
+            (rrTradesBySymbol.get(symbol) ?? rrTradesBySymbol.set(symbol, []).get(symbol)).push(trade);
+            rrTradesGlobal.push(trade);
+            (pnlsBySymbol.get(symbol) ?? pnlsBySymbol.set(symbol, []).get(symbol)).push(r.pnl);
+            pnlsGlobal.push(r.pnl);
+        }
+    }
+    history.sort((a, b) => a.ts - b.ts);
+    const riskRewardBySymbol = {};
+    for (const [symbol, trades] of rrTradesBySymbol) {
+        riskRewardBySymbol[symbol] = riskRewardStats(trades);
+    }
+    const riskRewardGlobal = riskRewardStats(rrTradesGlobal);
+    // устойчивая к выбросам статистика PnL: median + перцентили, чтобы одна плохая
+    // (или одна жирная) сделка не определяла оценку выигрыша системы.
+    const pnlBySymbol = {};
+    for (const [symbol, pnls] of pnlsBySymbol) {
+        pnlBySymbol[symbol] = pnlStats(pnls);
+    }
+    const pnlGlobal = pnlStats(pnlsGlobal);
+    const params = {
+        version: 3,
+        config: top.config,
+        exit: tensor,
+        policy: opts.policy ?? DEFAULT_POLICY,
+        riskReward: { bySymbol: riskRewardBySymbol, global: riskRewardGlobal },
+        pnl: { bySymbol: pnlBySymbol, global: pnlGlobal },
+        history,
+        meta: {
+            trainedAt: Date.now(), folds, shrinkageK,
+            cvScore: top.cvScore, nestedScore, cvWinrate: top.cvWinrate, cvSupport: top.cvSupport,
+            gridSize: board.length,
+            mode: effMode,
+            modeReason,
+            impactHorizonMinutes: globalExit.staleMinutes,
+            confidence: reliability.confidence, reliable: reliability.reliable,
+            support: reliability.support, stability: reliability.stability,
+            significance: reliability.significance, totalSamples: reliability.totalN,
+            certification,
+            effectiveTrials: nTrialsEff,
+            innerTrials,
+            fitAttempts: opts.metaLedger ? fitAttemptCount(opts.metaLedger) + 1 : 1,
+        },
+    };
+    const leaderboard = board.slice(0, 20).map(({ config, exit, cvScore, cvWinrate, cvSupport }) => ({ config, exit, cvScore, cvWinrate, cvSupport }));
+    return { predict: loadPredict(params), params, reliability, leaderboard };
+}
+function cfgOf(windowK, minClusters, jaccardThreshold, lagPeakThreshold, maxBurstWindowMs, mode, stationarityWindowMs) {
+    return { windowK, minClusters, jaccardThreshold, lagPeakThreshold, maxBurstWindowMs, mode, stationarityWindowMs };
+}
+// ─────────────────── десериализация: params → predict ─────────────────────────
+function loadPredict(params) {
+    if (params.version !== 3)
+        throw new Error(`unsupported params version: ${params.version}`);
+    const cfg = params.config;
+    return (items) => predict(items, cfg);
+}
+
+/**
+ * Casual-фасад с ЕДИНЫМ стабильным контрактом ввода-вывода.
+ *
+ *   const model = await PumpMatrix.fit(history, getCandles); // обучить
+ *   const json  = model.save();                              // сохранить (string)
+ *   const model = PumpMatrix.load(json);                     // в проде, без обучения
+ *
+ *   for (const s of model.signals(liveItems))                // УЖЕ отфильтровано
+ *     openPosition(s.symbol, s.direction, s.exit);           // прод не думает
+ *
+ * signals() возвращает ТОЛЬКО исполняемое: veto (каскад ликвидаций) не попадает в
+ * выдачу вообще — фильтр внутри. Разрешённые исходы задаются вторым аргументом
+ * (allow-список), но не шире, чем зашито в обученную модель (readonly-инвариант).
+ */
+class PumpMatrix {
+    constructor(params, _predict) {
+        this.params = params;
+        this._predict = _predict;
+    }
+    /** Обучить модель на истории сигналов. */
+    static async fit(history, getCandles, opts) {
+        const res = await train(history, getCandles, opts);
+        return new PumpMatrix(res.params, res.predict);
+    }
+    /** Восстановить модель из сохранённого JSON (в проде, без обучения). */
+    static load(json) {
+        const params = typeof json === "string" ? JSON.parse(json) : json;
+        if (!params.policy)
+            params.policy = DEFAULT_POLICY; // обратная совместимость
+        if (!params.riskReward)
+            params.riskReward = { bySymbol: {}, global: { mean: 0, p95: 0, p99: 0, n: 0 } };
+        if (!params.pnl)
+            params.pnl = { bySymbol: {}, global: { mean: 0, median: 0, p5: 0, p95: 0, p99: 0, n: 0 } };
+        return new PumpMatrix(params, loadPredict(params));
+    }
+    /** Сериализовать модель в JSON-строку (включая policy). */
+    save() {
+        return JSON.stringify(this.params);
+    }
+    dump(asString = false) {
+        const history = this.params.history ?? [];
+        return asString ? JSON.stringify(history) : history.map((h) => ({ ...h }));
+    }
+    /** Число записей в истории сигналов (0 если модель загружена без истории). */
+    get historySize() {
+        return this.params.history?.length ?? 0;
+    }
+    /** Полный exit-tensor (для аудита). */
+    get exit() {
+        return this.params.exit;
+    }
+    /** Политика разрешённых исходов, зашитая в модель (readonly-копия). */
+    get policy() {
+        return { allow: [...this.params.policy.allow] };
+    }
+    /** Надёжна ли модель (хватило ли данных при обучении). */
+    get reliable() {
+        return this.params.meta.reliable;
+    }
+    /** Доверие к модели 0..1. */
+    get confidence() {
+        return this.params.meta.confidence;
+    }
+    /**
+     * Эффективное число испытаний с family-wise поправкой на цепочку fit (мета-curse).
+     * Если fit гнали многократно — это Σ конфигов по всем попыткам, а не текущий грид.
+     */
+    get effectiveTrials() {
+        return this.params.meta.effectiveTrials;
+    }
+    /** Число конфигов в гриде текущего fit (внутренние испытания). */
+    get innerTrials() {
+        return this.params.meta.innerTrials;
+    }
+    /** Сколько раз всего запускался fit (прозрачность мета-перебора). */
+    get fitAttempts() {
+        return this.params.meta.fitAttempts;
+    }
+    /**
+     * Статистический сертификат: прошёл ли эдж пять барьеров (DSR ≥ 0.95, PBO ≤ 0.10,
+     * SPA p ≤ 0.05, N ≥ minTRL, nested OOS > 0). certified=false с reasons, если эдж
+     * не доказан — тогда модель торговать НЕ должна.
+     */
+    get certification() {
+        return this.params.meta.certification;
+    }
+    /** Эмпирический импакт-горизонт поста в минутах (global-уровень). */
+    get impactHorizonMinutes() {
+        return this.params.meta.impactHorizonMinutes;
+    }
+    /**
+     * Сколько минут истории СВЕЧЕЙ ДО сигнала нужно live-вызову plan() для каждого
+     * сигнала: max(volBaselineWindow, cascadeWindowMinutes) + запас 5 свечей. Столько
+     * 1m-свечей plan() запрашивает у getCandles (строго в прошлое, без look-ahead).
+     * В проде держи доступной историю минимум на это окно для каждого свежего сигнала.
+     */
+    get lookbackMinutes() {
+        const baseWin = this.params.exit.global.volBaselineWindow ?? 20;
+        const casWin = this.params.exit.global.cascadeWindowMinutes ?? 30;
+        return Math.max(baseWin, casWin) + 5;
+    }
+    /**
+     * Минимальное число НЕЗАВИСИМЫХ кластеров авторства, которые должны сойтись на
+     * тикере, чтобы matrix-всплеск считался сигналом. Из config (по умолчанию 2).
+     * В single-режиме не применяется (там всегда 1 кластер).
+     */
+    get minClusters() {
+        return this.params.config.minClusters;
+    }
+    /**
+     * Минимальное число ОБЩИХ событий между каналами, при котором author-матрица
+     * считается жизнеспособной (не шумовое совпадение) — порог перекрытия для
+     * auto-режима. Из config.viability (по умолчанию DEFAULT_VIABILITY.minSharedEvents).
+     * Грубо: сколько раз кластеры должны совпасть, чтобы их связь была не случайной.
+     */
+    get minSharedEvents() {
+        return this.params.config.viability?.minSharedEvents ?? DEFAULT_VIABILITY.minSharedEvents;
+    }
+    /** Режим, которым обучена модель: matrix (корреляция) | single (fallback). */
+    get mode() {
+        return this.params.meta.mode;
+    }
+    /** Честная диагностика: ПОЧЕМУ выбран этот режим (auto-критерий или явный выбор). */
+    get modeReason() {
+        return this.params.meta.modeReason ?? "(не записано)";
+    }
+    /**
+     * Risk-reward по бэктесту: per-symbol + global. Главный исследовательский выход.
+     * RR = pnl/hardStop в единицах риска (сколько R снято). bySymbol используется
+     * runtime-фильтром minRiskReward.
+     */
+    get riskReward() {
+        return this.params.riskReward;
+    }
+    /**
+     * Устойчивая к выбросам статистика реализованного PnL: median + перцентили
+     * (p5/p95/p99) per-symbol и global. median/перцентили показывают выигрыш
+     * системы без искажения единичной плохой или жирной сделкой.
+     */
+    get pnl() {
+        return this.params.pnl;
+    }
+    /**
+     * Главный prod-вызов БЕЗ свечей. Возвращает ТОЛЬКО исполняемые сигналы — veto
+     * уже отфильтрован. Без свечей каскад не оценивается → все исходы "enter".
+     * Второй аргумент — allow-список, сужающий разрешённые исходы (не шире обученной).
+     */
+    signals(items, policy) {
+        return this.collect(items, () => null, policy);
+    }
+    plan(items, source, policy) {
+        if (typeof source === "function") {
+            return this.planLiveViaGetCandles(items, source, policy);
+        }
+        const eff = intersectPolicy(this.params.policy, policy);
+        const out = [];
+        for (const v of this._predict(items).signals) {
+            const s = this.buildSignalLive(v, source[v.symbol] ?? null, eff);
+            if (s)
+                out.push(s);
+        }
+        return out;
+    }
+    async planLiveViaGetCandles(items, getCandles, policy) {
+        const eff = intersectPolicy(this.params.policy, policy);
+        // окно ДО сигнала (единый источник — геттер lookbackMinutes): базлайн объёма +
+        // горизонт каскада, всё в прошлом, без forward.
+        const lookback = this.lookbackMinutes;
+        const out = [];
+        for (const v of this._predict(items).signals) {
+            let candles = null;
+            try {
+                // тянем lookback свечей, заканчивающихся НА сигнальной минуте (не позже).
+                // since = entryStartTs - lookback·step: окно строго ДО входа.
+                const step = STEP_MS["1m"];
+                const start = entryStartTs(v.ts, "1m");
+                const since = start - lookback * step;
+                candles = await fetchCandlesChunked(getCandles, v.symbol, "1m", lookback, since);
+                if (!candles.length)
+                    candles = null;
+            }
+            catch {
+                candles = null; // битый символ → сигнал без свечей, не рушим весь вызов
+            }
+            const s = this.buildSignalLive(v, candles, eff);
+            if (s)
+                out.push(s);
+        }
+        return out;
+    }
+    backtest(items, source, policy) {
+        if (typeof source === "function") {
+            return this.backtestViaGetCandles(items, source, policy);
+        }
+        return this.collect(items, (v) => source[v.symbol] ?? null, policy);
+    }
+    async backtestViaGetCandles(items, getCandles, policy) {
+        const eff = intersectPolicy(this.params.policy, policy);
+        const maxLife = this.params.exit.global.staleMinutes;
+        const limit = maxLife * 2 + 5;
+        const out = [];
+        for (const v of this._predict(items).signals) {
+            let candles = null;
+            try {
+                const since = entryStartTs(v.ts, "1m");
+                candles = await fetchCandlesChunked(getCandles, v.symbol, "1m", limit, since);
+                if (!candles.length)
+                    candles = null;
+            }
+            catch {
+                candles = null;
+            }
+            const s = this.buildSignal(v, candles, eff);
+            if (s)
+                out.push(s);
+        }
+        return out;
+    }
+    /** Точечно под ОДНУ позицию в LIVE (вход = последняя свеча, каскад по прошлому). */
+    planFor(symbol, direction, channel, candles, policy) {
+        const entryTs = candles[candles.length - 1]?.timestamp ?? 0;
+        const v = {
+            symbol, direction, action: "open", ts: entryTs,
+            independentClusters: 1, totalChannels: 1, confidence: 0.5,
+            reason: "planFor", source: this.params.meta.mode, channel,
+        };
+        const eff = intersectPolicy(this.params.policy, policy);
+        return this.buildSignalLive(v, candles, eff);
+    }
+    /** Бэктест под ОДНУ позицию с явным entryTs (replay вперёд, каскад по будущему). */
+    planForAt(symbol, direction, channel, candles, entryTs, policy) {
+        const v = {
+            symbol, direction, action: "open", ts: entryTs,
+            independentClusters: 1, totalChannels: 1, confidence: 0.5,
+            reason: "planFor", source: this.params.meta.mode, channel,
+        };
+        const eff = intersectPolicy(this.params.policy, policy);
+        return this.buildSignal(v, candles, eff);
+    }
+    /** Полный отчёт (все вердикты + карта авторства) — для разбора. */
+    explain(items) {
+        return this._predict(items);
+    }
+    // ── общий сборщик: predict → buildSignal → отсев null (veto/не разрешено) ──
+    collect(items, candlesOf, policy) {
+        const eff = intersectPolicy(this.params.policy, policy);
+        const out = [];
+        for (const v of this._predict(items).signals) {
+            const s = this.buildSignal(v, candlesOf(v), eff);
+            if (s)
+                out.push(s); // null = veto или исход не в allow → не отдаём
+        }
+        return out;
+    }
+    flatExit(ex) {
+        return {
+            trailingTake: ex.trailingTake,
+            hardStop: ex.hardStop,
+            impactHorizonMinutes: ex.staleMinutes,
+            stalenessSinceProfit: ex.stalenessSinceProfit,
+            stalenessSinceMinutes: ex.stalenessSinceMinutes,
+        };
+    }
+    /**
+     * BACKTEST-сборка сигнала: каскад по свечам ПОСЛЕ входа (forward squeezePressure),
+     * допустимо только на истории. Делегирует в общее ядро с mode="backtest".
+     */
+    buildSignal(v, candles, policy) {
+        return this.buildSignalCore(v, candles, policy, "backtest");
+    }
+    /**
+     * LIVE-сборка сигнала: каскад по свечам ДО входа (backward squeezePressureBefore),
+     * БЕЗ look-ahead. Делегирует в общее ядро с mode="live".
+     */
+    buildSignalLive(v, candles, policy) {
+        return this.buildSignalCore(v, candles, policy, "live");
+    }
+    /**
+     * Строит ЕДИНЫЙ TradeSignal из вердикта. Возвращает null, если исполнять нечего:
+     * каскад дал veto ИЛИ получившийся action не в allow-списке. Инверсия здесь же
+     * разворачивает direction и тянет exit из инверс-ячейки — наружу уходит готовое
+     * направление, без флагов.
+     *
+     * mode="live": каскад меряется по свечам ДО входа (squeezePressureBefore) — в live
+     *   свечей после входа нет, look-ahead запрещён.
+     * mode="backtest": каскад по свечам ПОСЛЕ входа (squeezePressure) — допустимо на
+     *   завершённой истории.
+     */
+    buildSignalCore(v, candles, policy, mode) {
+        const ch = v.channel ?? "_matrix";
+        const dir = v.direction;
+        const allow = new Set(policy.allow);
+        // ── readonly RR-фильтр: режем символы с backtest-RR ниже порога ──
+        if (policy.minRiskReward !== undefined) {
+            const rr = this.params.riskReward?.bySymbol?.[v.symbol];
+            // rrMetric гарантированно задан intersectPolicy (там ?? "mean"), здесь не дефолтим
+            const metric = policy.rrMetric;
+            // нет статистики по символу → нечем подтвердить RR → режем (консервативно)
+            if (!rr || rr[metric] < policy.minRiskReward)
+                return null;
+        }
+        let volRegime = null;
+        const probe = resolveExit(this.params.exit, v.source, ch, v.symbol, dir, "calm");
+        const volZThr = probe.exit.volZThreshold ?? 2.0;
+        const baseWin = probe.exit.volBaselineWindow ?? 20;
+        const horizon = probe.exit.cascadeWindowMinutes ?? probe.exit.staleMinutes;
+        let sqPressure = null;
+        if (candles && candles.length > 0) {
+            // первая свеча, ОТКРЫВШАЯСЯ не раньше сигнальной минуты (без look-ahead в
+            // формирующуюся свечу сигнала). entryStartTs гарантирует полностью сформированную.
+            const startTs = entryStartTs(v.ts, "1m");
+            let entryIdx = candles.findIndex((c) => c.timestamp >= startTs);
+            if (entryIdx < 0)
+                entryIdx = candles.length - 1;
+            const volZ = volumeZScore(candles, entryIdx, baseWin);
+            // КАСКАД: live — по прошлым свечам (без look-ahead), backtest — по будущим.
+            sqPressure = mode === "live"
+                ? squeezePressureBefore(candles, entryIdx, dir, horizon)
+                : squeezePressure(candles, entryIdx, dir, horizon);
+            volRegime = volRegimeOf(volZ, volZThr);
+        }
+        let resolved = volRegime
+            ? resolveExit(this.params.exit, v.source, ch, v.symbol, dir, volRegime)
+            : resolveExitNoRegime(this.params.exit, v.source, v.symbol, dir);
+        let exit = resolved.exit;
+        // ── решение по каскаду → action + (возможно) разворот direction ──
+        let action = "enter";
+        let finalDir = dir;
+        let invertedFrom = null;
+        const fires = sqPressure !== null && sqPressure >= (exit.squeezeThreshold ?? 0.6);
+        if (fires) {
+            const pol = exit.squeezePolicy;
+            if (pol === "veto") {
+                return null; // каскад — НЕ входить. veto не попадает в выдачу.
+            }
+            if (pol === "invert") {
+                if (!allow.has("invert"))
+                    return null; // инверсия запрещена → защищаемся как veto
+                action = "invert";
+                finalDir = dir === "long" ? "short" : "long";
+                invertedFrom = dir;
+                // fires=true ⇒ были свечи ⇒ volRegime гарантированно посчитан (calm|anomalous),
+                // поэтому здесь всегда cell-резолв по режиму — без noRegime-ветки.
+                resolved = resolveExit(this.params.exit, v.source, ch, v.symbol, finalDir, volRegime);
+                exit = resolved.exit;
+            }
+            else if (pol === "tighten") {
+                if (!allow.has("tighten"))
+                    return null;
+                action = "tighten";
+            }
+            // pol === "ignore": каскад замечен, но НАМЕРЕННО игнорируется — входим в
+            // исходном направлении (action остаётся "enter"). В отличие от veto/invert
+            // сигнал НЕ отсекается; реализуется реальный (обычно плохой) pnl. Это даёт
+            // контрфакт «что если не реагировать на каскад» прямо в выдаче, а не только
+            // в стороннем анализе. pol === "none" ведёт себя так же (вход без реакции).
+        }
+        if (action === "enter" && !allow.has("enter"))
+            return null;
+        const plan = this.flatExit(exit);
+        if (action === "tighten") {
+            plan.trailingTake = +(exit.trailingTake * (exit.tightenFactor ?? 0.5)).toFixed(6);
+        }
+        const origin = {
+            detector: v.source,
+            channel: v.channel,
+            invertedFrom,
+            exitSource: resolved.source,
+            volRegime,
+            confidence: v.confidence,
+            independentClusters: v.independentClusters,
+            modelConfidence: this.params.meta.confidence,
+            modelReliable: this.params.meta.reliable,
+            id: v.id,
+            ids: v.ids,
+        };
+        return { symbol: v.symbol, direction: finalDir, action, ts: v.ts, exit: plan, origin };
+    }
+}
+
+/** Нормализует parser-items в чистые события, отбрасывая лишние поля и мусор. */
+function normalize(items) {
+    const out = [];
+    for (const it of items) {
+        if (!it || typeof it.channel !== "string" || typeof it.symbol !== "string")
+            continue;
+        if (it.direction !== "long" && it.direction !== "short")
+            continue;
+        if (typeof it.ts !== "number" || !Number.isFinite(it.ts))
+            continue;
+        out.push({
+            channel: it.channel,
+            symbol: it.symbol,
+            direction: it.direction,
+            ts: it.ts,
+            entryFromPrice: typeof it.entryFromPrice === "number" ? it.entryFromPrice : undefined,
+            entryToPrice: typeof it.entryToPrice === "number" ? it.entryToPrice : undefined,
+            id: typeof it.id === "string" ? it.id : (typeof it.id === "number" ? String(it.id) : undefined),
+        });
+    }
+    return out;
+}
+/**
+ * Чёрная коробка. Единственная точка входа.
+ *
+ *   predict(parserItems) -> PredictionResult
+ *
+ * Два режима отбора входов (config.mode):
+ *   - "matrix": вход = синхронный всплеск независимых кластеров-авторов.
+ *   - "single": fallback — каждый пост = вход, исход решает обученный exit.
+ *   - "auto":   матрица только если корреляция жизнеспособна, иначе single.
+ *
+ * Exit НЕ единый: подбирается отдельно под каждую ячейку тензора
+ * [mode][channel][symbol][direction][volRegime] — математика разных источников
+ * не смешивается (matrix/single, long/short, calm/anomalous — свои критерии).
+ */
+function predict(parserItems, config = {}) {
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    const events = normalize(parserItems);
+    const fullTbl = buildTable(events);
+    // окно стационарности: статистики авторства считаем по последнему окну,
+    // заканчивающемуся на самом свежем событии (а не по всей истории).
+    const anchorTs = events.length ? events[events.length - 1].ts : 0;
+    const tbl = Number.isFinite(cfg.stationarityWindowMs)
+        ? buildWindowedTable(events, anchorTs, cfg.stationarityWindowMs)
+        : fullTbl;
+    const tau = selfTuneLag(tbl);
+    const window = Math.min(cfg.windowK * tau, cfg.maxBurstWindowMs);
+    const screened = jaccardScreen(tbl, window, cfg.jaccardThreshold);
+    const directed = lagXCorr(tbl, screened, cfg.lagPeakThreshold, window);
+    const authors = clusterAuthors(tbl.channels, directed);
+    const matrixVerdicts = earlyWarning(tbl, authors, cfg, tau);
+    const matrixOpens = matrixVerdicts.filter((v) => v.action === "open");
+    // оценка жизнеспособности матрицы (строгий критерий: явные кластеры + перекрытие)
+    const viability = assessViability(tbl, directed, authors, {
+        ...DEFAULT_VIABILITY,
+        ...cfg.viability,
+    });
+    // ── разрешение режима ──
+    let usedMode;
+    if (cfg.mode === "matrix")
+        usedMode = "matrix";
+    else if (cfg.mode === "single")
+        usedMode = "single";
+    else {
+        // auto: матрица только если корреляция ЖИЗНЕСПОСОБНА И реально дала сигнал.
+        // Плохая корреляция на 2+ каналах (шумовое совпадение) → откат в single.
+        usedMode = viability.viable && matrixOpens.length > 0 ? "matrix" : "single";
+    }
+    let signals;
+    let verdicts;
+    if (usedMode === "matrix") {
+        verdicts = matrixVerdicts;
+        signals = matrixOpens;
+    }
+    else {
+        const fb = singleChannelSignals(tbl, cfg, tau);
+        verdicts = fb;
+        signals = fb; // в fallback все вердикты — это входы
+    }
+    return {
+        signals,
+        verdicts,
+        authors,
+        authorCount: new Set(authors.values()).size,
+        tauMs: tau,
+        windowMs: window,
+        usedMode,
+        viability,
+    };
+}
+
+export { CASCADE_AGGRESSION, DEFAULT_CONFIG, DEFAULT_GRID, DEFAULT_META_POLICY, DEFAULT_POLICY, DEFAULT_RELIABILITY, DEFAULT_SELECTION, DEFAULT_VIABILITY, MAX_CANDLES_PER_CHUNK, PumpMatrix, STEP_MS, alignTs, assessViability, buildTable, buildWindowedTable, canRefit, cascadeAggressionOf, certifyStrategy, clusterAuthors, computeReliability, conservatismKey, deflatedSharpe, earlyWarning, effectiveTrials, emptyLedger, entryStartTs, enumerateBursts, enumeratePosts, exitKey, expectedMaxSharpe, fetchCandlesChunked, fitAttemptCount, intersectPolicy, isMoreConservative, jaccardPair, jaccardScreen, kurtosis, labelBurst, lagXCorr, loadPredict, mean, minTrackRecordLength, mulberry32, normalCdf, normalInv, oneStandardErrorSelect, percentile, pnlStats, predict, probabilityOfBacktestOverfitting, realityCheckPValue, recordAttempt, replayExit, resolveExit, resolveExitNoRegime, riskRewardStats, selfTuneLag, sharpe, shrinkageExpectancy, silentProgress, singleChannelSignals, skewness, squeezePressure, standardError, stationaryBootstrapResample, stdev, stdoutProgress, train, variance, volRegimeOf, volumeFeatures, volumeZScore, windowEvents, winrate };