pump-anomaly 0.1.0 → 1.0.0

package/README.md

@@ -55,7 +55,8 @@ const trades = model.signals(liveItems);
 const trades = await model.plan(liveItems, getCandles);
 
 for (const s of trades) {
-  openPosition(s.symbol, s.direction, s.exit); // direction is already inverted if needed; exit is ready
+  // direction is already inverted if needed; exit is ready; entry zone for the live order
+  openPosition(s.symbol, s.direction, { from: s.entryFromPrice, to: s.entryToPrice }, s.exit);
 }
 ```
 
@@ -79,7 +80,6 @@ Tuned `TrainGrid`s per asset live in [`config/`](config/) — one `*-grid.mjs` e
 
 | Asset | Pump speed | `staleMinutes` | `hardStop` % | `trailingTake` % | `stalenessSinceProfit` % | Noise | Matrix strictness |
 |---|---|---|---|---|---|---|---|
-| [Fartcoin](https://github.com/tripolskypetr/pump-anomaly/blob/master/config/fartcoin-grid.mjs) | Very fast | 25m – 4h | 0.65–2.0 | 0.5–2.4 | 0.3–1.0 | Very high | Low |
 | [HYPE](https://github.com/tripolskypetr/pump-anomaly/blob/master/config/hype-grid.mjs) | Very fast | 30m – 4h | 0.7–2.0 | 0.5–2.5 | 0.3–1.0 | High | Low |
 | [Solana](https://github.com/tripolskypetr/pump-anomaly/blob/master/config/solana-grid.mjs) | Fast | 45m – 8h | 0.8–2.5 | 0.6–2.2 | 0.4–1.3 | High | Low–Med |
 | [TRX](https://github.com/tripolskypetr/pump-anomaly/blob/master/config/tron-grid.mjs) | Medium | 1.5h – 15h | 1.0–3.0 | 0.7–3.5 | 0.5–1.4 | Medium | Medium |
@@ -87,6 +87,7 @@ Tuned `TrainGrid`s per asset live in [`config/`](config/) — one `*-grid.mjs` e
 | [DOGE](https://github.com/tripolskypetr/pump-anomaly/blob/master/config/doge-grid.mjs) | Medium | 1.5h – 16h | 1.1–3.2 | 0.8–4.0 | 0.5–1.5 | Medium+ | Medium+ |
 | [BNB](https://github.com/tripolskypetr/pump-anomaly/blob/master/config/bnb-grid.mjs) | Medium | 3h – 24h | 1.2–3.5 | 0.9–4.5 | 0.6–1.6 | Medium | Medium+ |
 | [Ethereum](https://github.com/tripolskypetr/pump-anomaly/blob/master/config/ethereum-grid.mjs) | Slow | 2h – 24h | 1.2–3.5 | 0.5–2.5 | 0.3–1.0 | Low | High |
+| [Fartcoin](https://github.com/tripolskypetr/pump-anomaly/blob/master/config/fartcoin-grid.mjs) | Very fast | 25m – 4h | 0.65–2.0 | 0.5–2.4 | 0.3–1.0 | Very high | Low |
 | [Ripple (XRP)](https://github.com/tripolskypetr/pump-anomaly/blob/master/config/ripple-grid.mjs) | Medium-slow | 3h – 24h | 1.3–4.0 | 0.9–5.0 | 0.6–1.7 | Low–Med | High |
 | [Litecoin (LTC)](https://github.com/tripolskypetr/pump-anomaly/blob/master/config/litecoin-grid.mjs) | Medium-slow | 4h – 30h | 1.3–3.8 | 0.9–5.0 | 0.7–1.8 | Low–Med | High |
 | [Zcash (ZEC)](https://github.com/tripolskypetr/pump-anomaly/blob/master/config/zec-grid.mjs) | Medium-slow | 4h – 28h | 1.4–4.2 | 0.9–5.5 | 0.6–1.7 | Low–Med | High |
@@ -400,7 +401,8 @@ The calm/anomalous threshold (`volZThreshold`) and the firing threshold (`squeez
 
 ```ts
 for (const s of model.signals(liveItems)) {
-  openPosition(s.symbol, s.direction, s.exit); // direction is already flipped if inverted
+  // direction is already flipped if inverted; entry zone + exit are ready for the order
+  openPosition(s.symbol, s.direction, { from: s.entryFromPrice, to: s.entryToPrice }, s.exit);
 }
 ```
 
@@ -412,6 +414,8 @@ interface TradeSignal {
   direction: "long" | "short";        // FINAL (inversion already applied)
   action: "enter" | "invert" | "tighten";
   ts: number;
+  entryFromPrice?: number;            // entry zone from the parser-item (for opening the live position)
+  entryToPrice?: number;              // undefined → enter at market
   exit: {                              // flat, ready for openPosition
     trailingTake: number;             // tightened if action="tighten"
     hardStop: number;
@@ -446,18 +450,38 @@ await model.plan(items, getCandles, policy?)                 // Promise<TradeSig
 model.plan(items, { SOLUSDT: candles }, policy?)             // TradeSignal[]
 
 // BACKTEST — replay forward over closed history, source = getCandles | map:
-await model.backtest(items, getCandles, policy?)             // Promise<TradeSignal[]>
-model.backtest(items, { SOLUSDT: candles }, policy?)         // TradeSignal[]
+await model.backtest(items, getCandles, policy?)             // Promise<BacktestSignal[]>
+model.backtest(items, { SOLUSDT: candles }, policy?)         // BacktestSignal[]
 
 // single-position helpers:
-model.planFor(symbol, dir, channel, candles, policy?)        // live, null on veto
-model.planForAt(symbol, dir, channel, candles, ts, policy?)  // backtest, null on veto
+model.planFor(symbol, dir, channel, candles, policy?)        // live → TradeSignal, null on veto
+model.planForAt(symbol, dir, channel, candles, ts, policy?)  // backtest → BacktestSignal, null on veto
 
 // full report (all verdicts + author map) for debugging:
 model.explain(items)
 ```
 
-`plan` vs `backtest` differ only in *which* candles they see: `plan` measures the cascade from candles before the entry (live-safe), `backtest` from candles after the entry (forward replay over already-closed history). Use `backtest` for analysis of the completed past, `plan` for a live "should I enter now" decision.
+`plan` and `backtest` differ in two ways. **(1) Which candles they see:** `plan` measures the cascade from candles *before* the entry (live-safe, no look-ahead); `backtest` from candles *after* the entry (forward replay over already-closed history). **(2) What they return:** `plan` returns a `TradeSignal` (a decision — the position isn't closed yet, so there's no pnl); `backtest` returns a **`BacktestSignal`** — the same signal plus a `result` that *replays the exit plan forward* and reports the realized pnl. That replayed `result` is the whole point of `backtest`:
+
+```ts
+interface BacktestResult {     // present ONLY on BacktestSignal (backtest / planForAt)
+  entered: boolean;            // false → entry zone never touched on the candle window
+  pnl: number;                 // realized, fraction (hard-stop = honest -hardStop%)
+  peak: number;                // peak pnl over the position's life
+  reason: string;              // hard-stop | trailing-take | peak-staleness | life-cap | …
+  heldMinutes: number;
+  entryPrice: number;          // 0 if not entered
+  exitPrice: number;           // 0 if not entered
+  truncated: boolean;          // not enough candles after entry for the full life-cap
+}
+interface BacktestSignal extends TradeSignal { result: BacktestResult }
+
+for (const s of model.backtest(items, getCandles)) {
+  console.log(s.symbol, s.direction, s.result.pnl, s.result.reason); // realized, no join with dump()
+}
+```
+
+The replay uses the signal's FINAL direction (inversion already applied) and its resolved exit plan; the entry zone comes from the parser-item (`entryFromPrice`/`entryToPrice`), falling back to the first candle's open. `dump()` still holds the training-time history; `backtest` is the same machinery applied to whatever items/candles you pass now.
 
 ### Permissions — allow-list, serialized at training time, readonly at runtime
 
@@ -482,6 +506,7 @@ model.certification;         // five-barrier edge certificate (DSR/PBO/SPA/minTR
 model.effectiveTrials;       // family-wise meta-trial count (Σ configs over all fit attempts)
 model.innerTrials;           // grid size of this fit
 model.fitAttempts;           // how many times fit has run in the chain
+model.labeling;              // labeling diagnostics — WHY a fit came out empty
 model.impactHorizonMinutes;  // empirical post impact horizon (global level)
 model.mode;                  // "matrix" | "single" — how the model was trained
 model.modeReason;            // honest diagnostics: WHY this mode was chosen
@@ -494,6 +519,26 @@ model.policy;                // the baked-in allow-list (readonly copy)
 
 `lookbackMinutes` = `max(volBaselineWindow, cascadeWindowMinutes) + 5` — the amount of pre-signal 1m history `plan()` pulls per signal (strictly in the past, no look-ahead). In prod, keep at least this much history available for every fresh signal.
 
+### Troubleshoot
+
+A `fit` that produces `totalSamples: 0` is otherwise mute — "no data" and "no entries" look identical. `model.labeling` makes it speak: per **unique** candidate burst, what its labeling outcome was (and the raw `getCandles` exception text, deduped):
+
+```ts
+model.labeling;
+// {
+//   candidates: number;                     // unique bursts seen
+//   outcomes: {                             // only non-zero outcomes present
+//     ok?: number;                          // labeled, has an entry
+//     "adapter-error"?: number;             // getCandles threw (look-ahead guard / gap / symbol)
+//     "no-candles"?: number;                // getCandles returned empty (symbol/range gave nothing)
+//     "no-entry"?: number;                  // candles exist, but no exit-set entered the zone
+//   };
+//   errors: Record<string, number>;         // unique getCandles exception messages → count
+// }
+```
+
+So when a trained model is empty, `labeling.outcomes` tells you whether to fix `getCandles` (`adapter-error`), the symbol/range (`no-candles`), or accept there were no entries — and `labeling.errors` carries the exact thrown message (e.g. `{ "ccxt: symbol not found": 32 }`) instead of swallowing it.
+
 ---
 
 ## Signal history (`dump`) — for external analytics
@@ -610,9 +655,67 @@ All five are computed over the stationarity window. In single mode the matrix is
 
 ---
 
+## Integration with backtest-kit
+
+`PumpMatrix` needs one thing from your data layer: a `getCandles` that serves 1m candles by range. [`backtest-kit`](https://www.npmjs.com/package/backtest-kit) already provides exactly that contract via `Exchange.getRawCandles(symbol, interval, { exchangeName }, limit, sDate, eDate)` — the argument order matches `GetCandles` one-to-one, so the adapter is a thin pass-through. Register an exchange schema once, then wire the three phases (train → live → backtest).
+
+```ts
+import { addExchangeSchema, Exchange, roundTicks } from "backtest-kit";
+import { singleshot } from "functools-kit";
+import * as pump from "pump-anomaly";
+import ccxt from "ccxt";
+
+import signals from "./assets/parser-items.json" with { type: "json" };
+import weights from "./assets/model-weights.json" with { type: "json" };
+
+const getExchange = singleshot(async () => {
+  const exchange = new ccxt.binance({ enableRateLimit: true, options: { defaultType: "spot" } });
+  await exchange.loadMarkets();
+  return exchange;
+});
+
+// Register the exchange once. getCandles here is backtest-kit's OHLCV fetch;
+// formatPrice/formatQuantity/getOrderBook/getAggregatedTrades omitted for brevity.
+addExchangeSchema({
+  exchangeName: "ccxt-exchange",
+  getCandles: async (symbol, interval, since, limit) => {
+    const exchange = await getExchange();
+    const rows = await exchange.fetchOHLCV(symbol, interval, since.getTime(), limit);
+    return rows.map(([timestamp, open, high, low, close, volume]) => ({ timestamp, open, high, low, close, volume }));
+  },
+  // ...formatPrice, formatQuantity, getOrderBook, getAggregatedTrades
+});
+
+// Adapter: backtest-kit's getRawCandles → pump-anomaly's GetCandles (same arg order).
+const getCandles = (symbol, interval, limit, sDate, eDate) =>
+  Exchange.getRawCandles(symbol, interval, { exchangeName: "ccxt-exchange" }, limit, sDate, eDate);
+
+// 1) TRAIN once on history → serialize weights (slow: labels replay 1m candles).
+async function trainWeights() {
+  const model = await pump.PumpMatrix.fit(signals, getCandles);
+  return model.save(); // → write to assets/model-weights.json
+}
+
+// 2) LIVE — load weights (no retraining), get ready-to-execute signals.
+async function planLive() {
+  const model = pump.PumpMatrix.load(weights);
+  return model.plan(signals, getCandles); // TradeSignal[] — direction/entry/exit ready
+}
+
+// 3) BACKTEST — same weights, replay forward, realized pnl in result.
+async function runBacktest() {
+  const model = pump.PumpMatrix.load(weights);
+  return model.backtest(signals, getCandles); // BacktestSignal[] — each has result.pnl
+}
+```
+
+`parser-items.json` is your channel history (`ParserItem[]`), `model-weights.json` is `model.save()` output. The same `getCandles` adapter serves all three phases — `fit` pulls 1m candles forward from each signal to label it, `plan` pulls them strictly before the signal (live, no look-ahead), `backtest` after (forward replay). Other anomaly libraries plug into the same `Exchange` schema independently: [`volume-anomaly`](https://www.npmjs.com/package/volume-anomaly) consumes `Exchange.getAggregatedTrades` for entry timing, [`garch`](https://www.npmjs.com/package/garch) consumes `Exchange.getCandles` for TP/SL sizing — pump-anomaly answers *which post to trade and how to exit it*, and they compose without touching each other.
+
+---
+
 ## Tests
 
-**518 tests** across **50 test files**. All passing.
+**538 tests** across **52 test files**. All passing.
 
 | File | Tests | What is covered |
 |------|-------|-----------------|
@@ -666,6 +769,8 @@ All five are computed over the stationarity window. In single mode the matrix is
 | `meta-ledger.test.ts` | 9 | Meta-overfitting guard: cadence guard blocks too-frequent refits, `effectiveTrials` sums ALL fit attempts (not only certified ones), family-wise DSR drops false certificates from 720 noise refits to 0 while a strong edge survives the correction |
 | `staleness-and-id.test.ts` | 7 | `stalenessSinceProfit`/`stalenessSinceMinutes` are searched in `DEFAULT_GRID` (not pinned); a parser-item `id` threads through to every `dump()` record (numeric→string, matches the source post by `ts`, survives save/load, `undefined` without an id) |
 | `id-threading-attack.test.ts` | 6 | `id` threading is leak-proof: time-separated bursts on one symbol both survive (no best-per-symbol loss), collapsed posts keep their `id` in `ids` (`enumeratePosts` + `singleChannelSignals`), and `id`/`ids` reach the LIVE `plan` signal's `origin` (not only `dump`) |
+| `labeling-diagnostics.test.ts` | 8 | `model.labeling` makes an empty `fit` speak: outcomes per unique burst (ok / adapter-error / no-candles / no-entry), counts not inflated by grid size, sum of outcomes = candidates, and the raw `getCandles` exception text is captured in `errors` (incl. non-`Error` throws) |
+| `backtest-result.test.ts` | 5 | `backtest()` returns `BacktestSignal` with a replayed `result` (realized pnl/reason/prices); no candles → `entered:false` not a crash; `planForAt` carries `result` too; `plan()`/`signals()` do NOT carry `result` |
 
 ```bash
 npm test

package/build/index.cjs

@@ -293,6 +293,8 @@ function earlyWarning(tbl, clusterOf, cfg, tau) {
                         `в окне ${(window / 60000).toFixed(0)}м (каналов: ${channels.size})`,
                     source: "matrix",
                     channel: null,
+                    entryFromPrice: evs[hi].entryFromPrice,
+                    entryToPrice: evs[hi].entryToPrice,
                 };
                 if (!best || cand.confidence > best.confidence)
                     best = cand;
@@ -359,6 +361,8 @@ function singleChannelSignals(tbl, cfg, tau) {
                 channel: e.channel,
                 id,
                 ids: id != null ? [id] : [],
+                entryFromPrice: e.entryFromPrice,
+                entryToPrice: e.entryToPrice,
             };
             verdicts.push(current);
         }
@@ -655,10 +659,19 @@ async function fetchCandlesChunked(getCandles, symbol, interval, limit, since, c
         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;
+        for (const c of chunk)
+            all.push(c); // НЕ спред: при большом limit чанк переполнит стек
+        // ЧАСТИЧНЫЙ чанк (биржа недодала: вернула < chunkLimit, но не пусто) — двигаем
+        // since от ФАКТИЧЕСКИ последней свечи (+step), а remaining уменьшаем на реально
+        // полученное (chunk.length). Иначе since прыгает на полный chunkLimit·step, минуя
+        // недополученный хвост → дыра в склеенном ряду + недосчёт. Свечи могут прийти
+        // неотсортированными — берём max(ts), а не последний элемент.
+        let maxTs = currentSince;
+        for (const c of chunk)
+            if (c.timestamp > maxTs)
+                maxTs = c.timestamp;
+        remaining -= chunk.length;
+        currentSince = maxTs + step;
     }
     // дедуп по timestamp (на стыках чанков адаптер может вернуть пограничную свечу
     // дважды). Оставляем ПЕРВОЕ вхождение: при forward-пагинации первая свеча с данным
@@ -704,10 +717,14 @@ function volumeZScore(candles, entryIdx, baselineWindow) {
  * это ловушка (stop hunt / squeeze), входить опасно либо выходить раньше.
  */
 function squeezePressure(candles, entryIdx, dir, horizon) {
+    // КЛАМП нижней границы (симметрично squeezePressureBefore): при отрицательном
+    // entryIdx (findIndex вернул -1, битый вызов) старт стал бы < 0 и цикл прочитал
+    // candles[-1] = undefined → краш на c.close. max(0, ...) этого не допускает.
+    const start = Math.max(0, entryIdx + 1);
     const end = Math.min(candles.length, entryIdx + horizon + 1);
     let againstVol = 0;
     let totalVol = 0;
-    for (let i = entryIdx + 1; i < end; i++) {
+    for (let i = start; i < end; i++) {
         const c = candles[i];
         const delta = c.close - c.open; // знак внутрисвечного движения
         // «против позиции»: long не любит падение (delta<0), short не любит рост (delta>0)
@@ -932,7 +949,11 @@ const exitKey = (p) => `tt${p.trailingTake}|hs${p.hardStop}|sp${p.stalenessSince
  * если не задана — точка entryFrom=entryTo=open первой свечи.
  */
 async function labelBurst(getCandles, symbol, direction, ts, exitSets, entryFromPrice, entryToPrice) {
-    const maxLife = Math.max(...exitSets.map((e) => e.staleMinutes));
+    // НЕ Math.max(...arr.map()): spread-в-аргументы переполняет стек на большом наборе.
+    let maxLife = 0;
+    for (const e of exitSets)
+        if (e.staleMinutes > maxLife)
+            maxLife = e.staleMinutes;
     // старт = первая полностью сформированная свеча ПОСЛЕ сигнала (без look-ahead):
     // свеча, содержащая сигнал, ещё формируется — её OHLC известны только в конце минуты.
     const since = entryStartTs(ts, "1m");
@@ -945,11 +966,15 @@ async function labelBurst(getCandles, symbol, direction, ts, exitSets, entryFrom
     try {
         candles = await fetchCandlesChunked(getCandles, symbol, "1m", limit, since);
     }
-    catch {
-        return null;
+    catch (e) {
+        // НЕ глотаем текст: 32 одинаковых adapter-error немы без него. Сообщение
+        // (или String(e) для не-Error) уходит в meta.labeling для диагностики.
+        const error = e instanceof Error ? e.message : String(e);
+        return { outcome: "adapter-error", burst: null, error };
+    }
+    if (!candles || candles.length === 0) {
+        return { outcome: "no-candles", burst: null };
     }
-    if (!candles || candles.length === 0)
-        return null;
     const from = entryFromPrice ?? candles[0].open;
     const to = entryToPrice ?? candles[0].open;
     const byExit = new Map();
@@ -965,9 +990,10 @@ async function labelBurst(getCandles, symbol, direction, ts, exitSets, entryFrom
         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 };
+    if (byExit.size === 0 || !anyEntered) {
+        return { outcome: "no-entry", burst: null };
+    }
+    return { outcome: "ok", burst: { symbol, direction, ts, byExit } };
 }
 
 /**
@@ -1200,6 +1226,8 @@ function computeReliability(input, cfg = DEFAULT_RELIABILITY) {
 const BAR_LENGTH = 30;
 const BAR_FILLED_CHAR = "\u2588";
 const BAR_EMPTY_CHAR = "\u2591";
+/** \u0424\u0438\u043a\u0441. \u0448\u0438\u0440\u0438\u043d\u0430 \u0441\u0442\u0440\u043e\u043a\u0438 \u043f\u0440\u043e\u0433\u0440\u0435\u0441\u0441\u0430: \u0431\u0430\u0440(30) + \u043f\u0440\u043e\u0446\u0435\u043d\u0442\u044b/\u0441\u0447\u0451\u0442\u0447\u0438\u043a/\u0444\u0430\u0437\u0430 + \u043c\u0435\u0442\u043a\u0430-\u0442\u0438\u043a\u0435\u0440. */
+const LINE_WIDTH = 80;
 /** Дефолтный stdout-бар в стиле пользователя. */
 const stdoutProgress = (e) => {
     if (e.total <= 0)
@@ -1209,7 +1237,10 @@ const stdoutProgress = (e) => {
     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}`);
+    // фикс. ширина: pad пробелами + slice. Иначе при более короткой новой метке
+    // (SOLUSDT после FARTCOINUSDT) \r не стирает хвост → "BTCUSDTTUSDT".
+    const line = `[${bar}] ${percent}% (${e.done}/${e.total}) ${e.phase} ${e.label}`;
+    process.stdout.write("\r" + line.padEnd(LINE_WIDTH).slice(0, LINE_WIDTH));
     if (e.done >= e.total)
         process.stdout.write("\n");
 };
@@ -1315,7 +1346,13 @@ function sharpe(returns) {
     // (масштаб данных × 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));
+    // НЕ Math.max(...returns): на длинном ряде сделок spread-в-аргументы переполняет стек.
+    let scale = Math.abs(m);
+    for (const x of returns) {
+        const a = Math.abs(x);
+        if (a > scale)
+            scale = a;
+    }
     const dustFloor = scale * 1e-13; // ~500× machine epsilon (2.2e-16) от масштаба данных
     if (s <= dustFloor)
         return 0;
@@ -1798,19 +1835,34 @@ async function train(items, getCandles, opts = {}) {
                                             });
     const labeledCache = new Map();
     const seenCluster = new Set();
+    // диагностика разметки: исход каждого УНИКАЛЬНОГО всплеска. dedup по (symbol|dir|ts):
+    // один всплеск перечисляется в нескольких проходах грида — считаем исход раз, иначе
+    // счётчики раздуты числом конфигов. Пустой fit перестаёт быть немым: тэлли скажет,
+    // adapter-error / no-candles / no-entry это или реально ok.
+    const outcomeTally = new Map();
+    // уникальные тексты adapter-error → сколько раз встретились (32 одинаковых схлопнутся).
+    const errorTally = new Map();
+    const diagSeen = 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);
+            const { outcome, burst, error } = await labelBurst(getCandles, b.symbol, b.direction, b.ts, exitSets, src?.entryFromPrice, src?.entryToPrice);
             onTick?.(b.symbol);
-            if (!lb)
+            const diagKey = `${b.symbol}|${b.direction}|${b.ts}`;
+            if (!diagSeen.has(diagKey)) {
+                diagSeen.add(diagKey);
+                outcomeTally.set(outcome, (outcomeTally.get(outcome) ?? 0) + 1);
+                if (error)
+                    errorTally.set(error, (errorTally.get(error) ?? 0) + 1);
+            }
+            if (!burst)
                 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) {
+            for (const [k, r] of burst.byExit) {
                 byExit.set(k, {
                     pnl: r.pnl, volRegime: r.volRegime, entered: r.entered,
                     entryPrice: r.entryPrice, exitPrice: r.exitPrice, reason: r.reason,
@@ -1920,7 +1972,8 @@ async function train(items, getCandles, opts = {}) {
                                     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);
+                                    for (const r of valRet)
+                                        allRet.push(r);
                                 }
                                 const avg = (a) => (a.length ? a.reduce((s, x) => s + x, 0) / a.length : 0);
                                 out.push({
@@ -1937,10 +1990,14 @@ async function train(items, getCandles, opts = {}) {
     };
     // основной board — по всем данным, с прогрессом фазы score
     let scoreDone = 0;
-    board.push(...buildBoard(() => true, (label) => {
+    // НЕ спред (board.push(...arr)): на полном гриде arr — десятки тысяч элементов,
+    // и spread-в-аргументы переполняет стек вызовов (Maximum call stack size exceeded).
+    const mainBoard = buildBoard(() => true, (label) => {
         scoreDone++;
         progress({ done: scoreDone, total: scoreTotal, phase: "score", label });
-    }));
+    });
+    for (const entry of mainBoard)
+        board.push(entry);
     // ── выбор победителя: one-standard-error rule (против winner's curse) ──
     // вместо argmax по cvScore берём самую КОНСЕРВАТИВНУЮ конфигурацию среди тех,
     // чей score в пределах SE от максимума. Это убирает переобучение на шум grid:
@@ -2191,6 +2248,11 @@ async function train(items, getCandles, opts = {}) {
             effectiveTrials: nTrialsEff,
             innerTrials,
             fitAttempts: opts.metaLedger ? fitAttemptCount(opts.metaLedger) + 1 : 1,
+            labeling: {
+                candidates: diagSeen.size,
+                outcomes: Object.fromEntries(outcomeTally),
+                errors: Object.fromEntries(errorTally),
+            },
         },
     };
     const leaderboard = board.slice(0, 20).map(({ config, exit, cvScore, cvWinrate, cvSupport }) => ({ config, exit, cvScore, cvWinrate, cvSupport }));
@@ -2285,6 +2347,16 @@ class PumpMatrix {
     get fitAttempts() {
         return this.params.meta.fitAttempts;
     }
+    /**
+     * Диагностика фазы разметки: { candidates, outcomes, errors }. Если модель пустая
+     * (totalSamples=0), причина в outcomes по LabelOutcome: "adapter-error" (getCandles
+     * бросает), "no-candles" (вернул пусто — символ/диапазон), "no-entry" (свечи есть,
+     * входов в зону нет), "ok" (размечено). errors — уникальные тексты исключений
+     * getCandles со счётчиком (чтобы adapter-error не был немым).
+     */
+    get labeling() {
+        return this.params.meta.labeling;
+    }
     /**
      * Статистический сертификат: прошёл ли эдж пять барьеров (DSR ≥ 0.95, PBO ≤ 0.10,
      * SPA p ≤ 0.05, N ≥ minTRL, nested OOS > 0). certified=false с reasons, если эдж
@@ -2401,7 +2473,15 @@ class PumpMatrix {
         if (typeof source === "function") {
             return this.backtestViaGetCandles(items, source, policy);
         }
-        return this.collect(items, (v) => source[v.symbol] ?? null, policy);
+        const eff = intersectPolicy(this.params.policy, policy);
+        const out = [];
+        for (const v of this._predict(items).signals) {
+            // зона входа уже в вердикте (протянута из parser-item) → buildSignal её прокинет
+            const s = this.buildSignal(v, source[v.symbol] ?? null, eff);
+            if (s)
+                out.push(s);
+        }
+        return out;
     }
     async backtestViaGetCandles(items, getCandles, policy) {
         const eff = intersectPolicy(this.params.policy, policy);
@@ -2436,7 +2516,11 @@ class PumpMatrix {
         const eff = intersectPolicy(this.params.policy, policy);
         return this.buildSignalLive(v, candles, eff);
     }
-    /** Бэктест под ОДНУ позицию с явным entryTs (replay вперёд, каскад по будущему). */
+    /**
+     * Бэктест под ОДНУ позицию с явным entryTs (replay вперёд, каскад по будущему).
+     * Возвращает BacktestSignal с реализованным result. Зона входа не задаётся —
+     * replay берёт точку = open первой свечи (как при отсутствии зоны в обучении).
+     */
     planForAt(symbol, direction, channel, candles, entryTs, policy) {
         const v = {
             symbol, direction, action: "open", ts: entryTs,
@@ -2451,11 +2535,13 @@ class PumpMatrix {
         return this._predict(items);
     }
     // ── общий сборщик: predict → buildSignal → отсев null (veto/не разрешено) ──
+    // signals() — без свечей. Используем LIVE-сборку: каскад не оценивается (нет свечей),
+    // и result не доклеивается — signals() отдаёт чистый TradeSignal, не BacktestSignal.
     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);
+            const s = this.buildSignalLive(v, candlesOf(v), eff);
             if (s)
                 out.push(s); // null = veto или исход не в allow → не отдаём
         }
@@ -2472,10 +2558,15 @@ class PumpMatrix {
     }
     /**
      * BACKTEST-сборка сигнала: каскад по свечам ПОСЛЕ входа (forward squeezePressure),
-     * допустимо только на истории. Делегирует в общее ядро с mode="backtest".
+     * допустимо только на истории. Возвращает BacktestSignal с реализованным result
+     * (replay exit-плана вперёд) — главное отличие backtest от plan. entryFrom/entryTo
+     * — зона входа для replay (из parser-item); без свечей result.entered=false.
      */
     buildSignal(v, candles, policy) {
-        return this.buildSignalCore(v, candles, policy, "backtest");
+        const sig = this.buildSignalCore(v, candles, policy, "backtest");
+        if (!sig)
+            return null;
+        return { ...sig, result: this.replayResult(sig, candles) };
     }
     /**
      * LIVE-сборка сигнала: каскад по свечам ДО входа (backward squeezePressureBefore),
@@ -2484,6 +2575,31 @@ class PumpMatrix {
     buildSignalLive(v, candles, policy) {
         return this.buildSignalCore(v, candles, policy, "live");
     }
+    /**
+     * Реализованный результат для backtest: replay ИТОГОВОГО (с учётом инверсии)
+     * направления и exit-плана сигнала по свечам после входа. Зона входа из parser-item;
+     * если не задана — точка = open первой свечи (как в обучении). Нет свечей → не вошли.
+     */
+    replayResult(sig, candles) {
+        if (!candles || candles.length === 0) {
+            return { entered: false, pnl: 0, peak: 0, reason: "no-candles", heldMinutes: 0, entryPrice: 0, exitPrice: 0, truncated: false };
+        }
+        // зона входа теперь в самом сигнале (протянута из parser-item); нет → open первой свечи.
+        const from = sig.entryFromPrice ?? candles[0].open;
+        const to = sig.entryToPrice ?? candles[0].open;
+        const r = replayExit(candles, sig.direction, from, to, {
+            trailingTake: sig.exit.trailingTake,
+            hardStop: sig.exit.hardStop,
+            stalenessSinceProfit: sig.exit.stalenessSinceProfit,
+            stalenessSinceMinutes: sig.exit.stalenessSinceMinutes,
+            staleMinutes: sig.exit.impactHorizonMinutes,
+        });
+        return {
+            entered: r.entered, pnl: r.pnl, peak: r.peak, reason: r.reason,
+            heldMinutes: r.heldMinutes, entryPrice: r.entryPrice, exitPrice: r.exitPrice,
+            truncated: r.truncated,
+        };
+    }
     /**
      * Строит ЕДИНЫЙ TradeSignal из вердикта. Возвращает null, если исполнять нечего:
      * каскад дал veto ИЛИ получившийся action не в allow-списке. Инверсия здесь же
@@ -2583,7 +2699,11 @@ class PumpMatrix {
             id: v.id,
             ids: v.ids,
         };
-        return { symbol: v.symbol, direction: finalDir, action, ts: v.ts, exit: plan, origin };
+        return {
+            symbol: v.symbol, direction: finalDir, action, ts: v.ts,
+            entryFromPrice: v.entryFromPrice, entryToPrice: v.entryToPrice,
+            exit: plan, origin,
+        };
     }
 }
 

package/build/index.mjs

@@ -291,6 +291,8 @@ function earlyWarning(tbl, clusterOf, cfg, tau) {
                         `в окне ${(window / 60000).toFixed(0)}м (каналов: ${channels.size})`,
                     source: "matrix",
                     channel: null,
+                    entryFromPrice: evs[hi].entryFromPrice,
+                    entryToPrice: evs[hi].entryToPrice,
                 };
                 if (!best || cand.confidence > best.confidence)
                     best = cand;
@@ -357,6 +359,8 @@ function singleChannelSignals(tbl, cfg, tau) {
                 channel: e.channel,
                 id,
                 ids: id != null ? [id] : [],
+                entryFromPrice: e.entryFromPrice,
+                entryToPrice: e.entryToPrice,
             };
             verdicts.push(current);
         }
@@ -653,10 +657,19 @@ async function fetchCandlesChunked(getCandles, symbol, interval, limit, since, c
         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;
+        for (const c of chunk)
+            all.push(c); // НЕ спред: при большом limit чанк переполнит стек
+        // ЧАСТИЧНЫЙ чанк (биржа недодала: вернула < chunkLimit, но не пусто) — двигаем
+        // since от ФАКТИЧЕСКИ последней свечи (+step), а remaining уменьшаем на реально
+        // полученное (chunk.length). Иначе since прыгает на полный chunkLimit·step, минуя
+        // недополученный хвост → дыра в склеенном ряду + недосчёт. Свечи могут прийти
+        // неотсортированными — берём max(ts), а не последний элемент.
+        let maxTs = currentSince;
+        for (const c of chunk)
+            if (c.timestamp > maxTs)
+                maxTs = c.timestamp;
+        remaining -= chunk.length;
+        currentSince = maxTs + step;
     }
     // дедуп по timestamp (на стыках чанков адаптер может вернуть пограничную свечу
     // дважды). Оставляем ПЕРВОЕ вхождение: при forward-пагинации первая свеча с данным
@@ -702,10 +715,14 @@ function volumeZScore(candles, entryIdx, baselineWindow) {
  * это ловушка (stop hunt / squeeze), входить опасно либо выходить раньше.
  */
 function squeezePressure(candles, entryIdx, dir, horizon) {
+    // КЛАМП нижней границы (симметрично squeezePressureBefore): при отрицательном
+    // entryIdx (findIndex вернул -1, битый вызов) старт стал бы < 0 и цикл прочитал
+    // candles[-1] = undefined → краш на c.close. max(0, ...) этого не допускает.
+    const start = Math.max(0, entryIdx + 1);
     const end = Math.min(candles.length, entryIdx + horizon + 1);
     let againstVol = 0;
     let totalVol = 0;
-    for (let i = entryIdx + 1; i < end; i++) {
+    for (let i = start; i < end; i++) {
         const c = candles[i];
         const delta = c.close - c.open; // знак внутрисвечного движения
         // «против позиции»: long не любит падение (delta<0), short не любит рост (delta>0)
@@ -930,7 +947,11 @@ const exitKey = (p) => `tt${p.trailingTake}|hs${p.hardStop}|sp${p.stalenessSince
  * если не задана — точка entryFrom=entryTo=open первой свечи.
  */
 async function labelBurst(getCandles, symbol, direction, ts, exitSets, entryFromPrice, entryToPrice) {
-    const maxLife = Math.max(...exitSets.map((e) => e.staleMinutes));
+    // НЕ Math.max(...arr.map()): spread-в-аргументы переполняет стек на большом наборе.
+    let maxLife = 0;
+    for (const e of exitSets)
+        if (e.staleMinutes > maxLife)
+            maxLife = e.staleMinutes;
     // старт = первая полностью сформированная свеча ПОСЛЕ сигнала (без look-ahead):
     // свеча, содержащая сигнал, ещё формируется — её OHLC известны только в конце минуты.
     const since = entryStartTs(ts, "1m");
@@ -943,11 +964,15 @@ async function labelBurst(getCandles, symbol, direction, ts, exitSets, entryFrom
     try {
         candles = await fetchCandlesChunked(getCandles, symbol, "1m", limit, since);
     }
-    catch {
-        return null;
+    catch (e) {
+        // НЕ глотаем текст: 32 одинаковых adapter-error немы без него. Сообщение
+        // (или String(e) для не-Error) уходит в meta.labeling для диагностики.
+        const error = e instanceof Error ? e.message : String(e);
+        return { outcome: "adapter-error", burst: null, error };
+    }
+    if (!candles || candles.length === 0) {
+        return { outcome: "no-candles", burst: null };
     }
-    if (!candles || candles.length === 0)
-        return null;
     const from = entryFromPrice ?? candles[0].open;
     const to = entryToPrice ?? candles[0].open;
     const byExit = new Map();
@@ -963,9 +988,10 @@ async function labelBurst(getCandles, symbol, direction, ts, exitSets, entryFrom
         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 };
+    if (byExit.size === 0 || !anyEntered) {
+        return { outcome: "no-entry", burst: null };
+    }
+    return { outcome: "ok", burst: { symbol, direction, ts, byExit } };
 }
 
 /**
@@ -1198,6 +1224,8 @@ function computeReliability(input, cfg = DEFAULT_RELIABILITY) {
 const BAR_LENGTH = 30;
 const BAR_FILLED_CHAR = "\u2588";
 const BAR_EMPTY_CHAR = "\u2591";
+/** \u0424\u0438\u043a\u0441. \u0448\u0438\u0440\u0438\u043d\u0430 \u0441\u0442\u0440\u043e\u043a\u0438 \u043f\u0440\u043e\u0433\u0440\u0435\u0441\u0441\u0430: \u0431\u0430\u0440(30) + \u043f\u0440\u043e\u0446\u0435\u043d\u0442\u044b/\u0441\u0447\u0451\u0442\u0447\u0438\u043a/\u0444\u0430\u0437\u0430 + \u043c\u0435\u0442\u043a\u0430-\u0442\u0438\u043a\u0435\u0440. */
+const LINE_WIDTH = 80;
 /** Дефолтный stdout-бар в стиле пользователя. */
 const stdoutProgress = (e) => {
     if (e.total <= 0)
@@ -1207,7 +1235,10 @@ const stdoutProgress = (e) => {
     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}`);
+    // фикс. ширина: pad пробелами + slice. Иначе при более короткой новой метке
+    // (SOLUSDT после FARTCOINUSDT) \r не стирает хвост → "BTCUSDTTUSDT".
+    const line = `[${bar}] ${percent}% (${e.done}/${e.total}) ${e.phase} ${e.label}`;
+    process.stdout.write("\r" + line.padEnd(LINE_WIDTH).slice(0, LINE_WIDTH));
     if (e.done >= e.total)
         process.stdout.write("\n");
 };
@@ -1313,7 +1344,13 @@ function sharpe(returns) {
     // (масштаб данных × 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));
+    // НЕ Math.max(...returns): на длинном ряде сделок spread-в-аргументы переполняет стек.
+    let scale = Math.abs(m);
+    for (const x of returns) {
+        const a = Math.abs(x);
+        if (a > scale)
+            scale = a;
+    }
     const dustFloor = scale * 1e-13; // ~500× machine epsilon (2.2e-16) от масштаба данных
     if (s <= dustFloor)
         return 0;
@@ -1796,19 +1833,34 @@ async function train(items, getCandles, opts = {}) {
                                             });
     const labeledCache = new Map();
     const seenCluster = new Set();
+    // диагностика разметки: исход каждого УНИКАЛЬНОГО всплеска. dedup по (symbol|dir|ts):
+    // один всплеск перечисляется в нескольких проходах грида — считаем исход раз, иначе
+    // счётчики раздуты числом конфигов. Пустой fit перестаёт быть немым: тэлли скажет,
+    // adapter-error / no-candles / no-entry это или реально ok.
+    const outcomeTally = new Map();
+    // уникальные тексты adapter-error → сколько раз встретились (32 одинаковых схлопнутся).
+    const errorTally = new Map();
+    const diagSeen = 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);
+            const { outcome, burst, error } = await labelBurst(getCandles, b.symbol, b.direction, b.ts, exitSets, src?.entryFromPrice, src?.entryToPrice);
             onTick?.(b.symbol);
-            if (!lb)
+            const diagKey = `${b.symbol}|${b.direction}|${b.ts}`;
+            if (!diagSeen.has(diagKey)) {
+                diagSeen.add(diagKey);
+                outcomeTally.set(outcome, (outcomeTally.get(outcome) ?? 0) + 1);
+                if (error)
+                    errorTally.set(error, (errorTally.get(error) ?? 0) + 1);
+            }
+            if (!burst)
                 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) {
+            for (const [k, r] of burst.byExit) {
                 byExit.set(k, {
                     pnl: r.pnl, volRegime: r.volRegime, entered: r.entered,
                     entryPrice: r.entryPrice, exitPrice: r.exitPrice, reason: r.reason,
@@ -1918,7 +1970,8 @@ async function train(items, getCandles, opts = {}) {
                                     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);
+                                    for (const r of valRet)
+                                        allRet.push(r);
                                 }
                                 const avg = (a) => (a.length ? a.reduce((s, x) => s + x, 0) / a.length : 0);
                                 out.push({
@@ -1935,10 +1988,14 @@ async function train(items, getCandles, opts = {}) {
     };
     // основной board — по всем данным, с прогрессом фазы score
     let scoreDone = 0;
-    board.push(...buildBoard(() => true, (label) => {
+    // НЕ спред (board.push(...arr)): на полном гриде arr — десятки тысяч элементов,
+    // и spread-в-аргументы переполняет стек вызовов (Maximum call stack size exceeded).
+    const mainBoard = buildBoard(() => true, (label) => {
         scoreDone++;
         progress({ done: scoreDone, total: scoreTotal, phase: "score", label });
-    }));
+    });
+    for (const entry of mainBoard)
+        board.push(entry);
     // ── выбор победителя: one-standard-error rule (против winner's curse) ──
     // вместо argmax по cvScore берём самую КОНСЕРВАТИВНУЮ конфигурацию среди тех,
     // чей score в пределах SE от максимума. Это убирает переобучение на шум grid:
@@ -2189,6 +2246,11 @@ async function train(items, getCandles, opts = {}) {
             effectiveTrials: nTrialsEff,
             innerTrials,
             fitAttempts: opts.metaLedger ? fitAttemptCount(opts.metaLedger) + 1 : 1,
+            labeling: {
+                candidates: diagSeen.size,
+                outcomes: Object.fromEntries(outcomeTally),
+                errors: Object.fromEntries(errorTally),
+            },
         },
     };
     const leaderboard = board.slice(0, 20).map(({ config, exit, cvScore, cvWinrate, cvSupport }) => ({ config, exit, cvScore, cvWinrate, cvSupport }));
@@ -2283,6 +2345,16 @@ class PumpMatrix {
     get fitAttempts() {
         return this.params.meta.fitAttempts;
     }
+    /**
+     * Диагностика фазы разметки: { candidates, outcomes, errors }. Если модель пустая
+     * (totalSamples=0), причина в outcomes по LabelOutcome: "adapter-error" (getCandles
+     * бросает), "no-candles" (вернул пусто — символ/диапазон), "no-entry" (свечи есть,
+     * входов в зону нет), "ok" (размечено). errors — уникальные тексты исключений
+     * getCandles со счётчиком (чтобы adapter-error не был немым).
+     */
+    get labeling() {
+        return this.params.meta.labeling;
+    }
     /**
      * Статистический сертификат: прошёл ли эдж пять барьеров (DSR ≥ 0.95, PBO ≤ 0.10,
      * SPA p ≤ 0.05, N ≥ minTRL, nested OOS > 0). certified=false с reasons, если эдж
@@ -2399,7 +2471,15 @@ class PumpMatrix {
         if (typeof source === "function") {
             return this.backtestViaGetCandles(items, source, policy);
         }
-        return this.collect(items, (v) => source[v.symbol] ?? null, policy);
+        const eff = intersectPolicy(this.params.policy, policy);
+        const out = [];
+        for (const v of this._predict(items).signals) {
+            // зона входа уже в вердикте (протянута из parser-item) → buildSignal её прокинет
+            const s = this.buildSignal(v, source[v.symbol] ?? null, eff);
+            if (s)
+                out.push(s);
+        }
+        return out;
     }
     async backtestViaGetCandles(items, getCandles, policy) {
         const eff = intersectPolicy(this.params.policy, policy);
@@ -2434,7 +2514,11 @@ class PumpMatrix {
         const eff = intersectPolicy(this.params.policy, policy);
         return this.buildSignalLive(v, candles, eff);
     }
-    /** Бэктест под ОДНУ позицию с явным entryTs (replay вперёд, каскад по будущему). */
+    /**
+     * Бэктест под ОДНУ позицию с явным entryTs (replay вперёд, каскад по будущему).
+     * Возвращает BacktestSignal с реализованным result. Зона входа не задаётся —
+     * replay берёт точку = open первой свечи (как при отсутствии зоны в обучении).
+     */
     planForAt(symbol, direction, channel, candles, entryTs, policy) {
         const v = {
             symbol, direction, action: "open", ts: entryTs,
@@ -2449,11 +2533,13 @@ class PumpMatrix {
         return this._predict(items);
     }
     // ── общий сборщик: predict → buildSignal → отсев null (veto/не разрешено) ──
+    // signals() — без свечей. Используем LIVE-сборку: каскад не оценивается (нет свечей),
+    // и result не доклеивается — signals() отдаёт чистый TradeSignal, не BacktestSignal.
     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);
+            const s = this.buildSignalLive(v, candlesOf(v), eff);
             if (s)
                 out.push(s); // null = veto или исход не в allow → не отдаём
         }
@@ -2470,10 +2556,15 @@ class PumpMatrix {
     }
     /**
      * BACKTEST-сборка сигнала: каскад по свечам ПОСЛЕ входа (forward squeezePressure),
-     * допустимо только на истории. Делегирует в общее ядро с mode="backtest".
+     * допустимо только на истории. Возвращает BacktestSignal с реализованным result
+     * (replay exit-плана вперёд) — главное отличие backtest от plan. entryFrom/entryTo
+     * — зона входа для replay (из parser-item); без свечей result.entered=false.
      */
     buildSignal(v, candles, policy) {
-        return this.buildSignalCore(v, candles, policy, "backtest");
+        const sig = this.buildSignalCore(v, candles, policy, "backtest");
+        if (!sig)
+            return null;
+        return { ...sig, result: this.replayResult(sig, candles) };
     }
     /**
      * LIVE-сборка сигнала: каскад по свечам ДО входа (backward squeezePressureBefore),
@@ -2482,6 +2573,31 @@ class PumpMatrix {
     buildSignalLive(v, candles, policy) {
         return this.buildSignalCore(v, candles, policy, "live");
     }
+    /**
+     * Реализованный результат для backtest: replay ИТОГОВОГО (с учётом инверсии)
+     * направления и exit-плана сигнала по свечам после входа. Зона входа из parser-item;
+     * если не задана — точка = open первой свечи (как в обучении). Нет свечей → не вошли.
+     */
+    replayResult(sig, candles) {
+        if (!candles || candles.length === 0) {
+            return { entered: false, pnl: 0, peak: 0, reason: "no-candles", heldMinutes: 0, entryPrice: 0, exitPrice: 0, truncated: false };
+        }
+        // зона входа теперь в самом сигнале (протянута из parser-item); нет → open первой свечи.
+        const from = sig.entryFromPrice ?? candles[0].open;
+        const to = sig.entryToPrice ?? candles[0].open;
+        const r = replayExit(candles, sig.direction, from, to, {
+            trailingTake: sig.exit.trailingTake,
+            hardStop: sig.exit.hardStop,
+            stalenessSinceProfit: sig.exit.stalenessSinceProfit,
+            stalenessSinceMinutes: sig.exit.stalenessSinceMinutes,
+            staleMinutes: sig.exit.impactHorizonMinutes,
+        });
+        return {
+            entered: r.entered, pnl: r.pnl, peak: r.peak, reason: r.reason,
+            heldMinutes: r.heldMinutes, entryPrice: r.entryPrice, exitPrice: r.exitPrice,
+            truncated: r.truncated,
+        };
+    }
     /**
      * Строит ЕДИНЫЙ TradeSignal из вердикта. Возвращает null, если исполнять нечего:
      * каскад дал veto ИЛИ получившийся action не в allow-списке. Инверсия здесь же
@@ -2581,7 +2697,11 @@ class PumpMatrix {
             id: v.id,
             ids: v.ids,
         };
-        return { symbol: v.symbol, direction: finalDir, action, ts: v.ts, exit: plan, origin };
+        return {
+            symbol: v.symbol, direction: finalDir, action, ts: v.ts,
+            entryFromPrice: v.entryFromPrice, entryToPrice: v.entryToPrice,
+            exit: plan, origin,
+        };
     }
 }
 

package/package.json

@@ -1,7 +1,18 @@
 {
   "name": "pump-anomaly",
-  "version": "0.1.0",
+  "version": "1.0.0",
   "description": "Detector of synchronized trading pump signals via author-cluster deduplication, with path-aware exit replay and liquidation-cascade detection.",
+    "author": {
+    "name": "Petr Tripolsky",
+    "email": "tripolskypetr@gmail.com",
+    "url": "https://github.com/tripolskypetr"
+  },
+  "funding": {
+    "type": "individual",
+    "url": "http://paypal.me/tripolskypetr"
+  },
+  "license": "MIT",
+  "homepage": "https://backtest-kit.github.io/documents/article_07_ai_news_trading_signals.html",
   "keywords": [
     "trading",
     "pump",
@@ -19,7 +30,6 @@
     "typescript"
   ],
   "type": "module",
-  "license": "MIT",
   "main": "./build/index.cjs",
   "module": "./build/index.mjs",
   "types": "./types.d.ts",

package/types.d.ts

@@ -36,6 +36,8 @@ interface ParserItem {
     entryFromPrice?: number;
     /** верхняя граница зоны входа. */
     entryToPrice?: number;
+    /** идентификатор исходного поста — протягивается до dump() и origin live-сигнала для сопоставления с парсингом. */
+    id?: string | number;
     [extra: string]: unknown;
 }
 /** Нормализованное событие, с которым работают внутренние слои. */
@@ -67,6 +69,9 @@ interface PumpVerdict {
     id?: string;
     /** id всех parser-item, вошедших в сигнал */
     ids?: string[];
+    /** зона входа из parser-item — нужна для открытия live-позиции */
+    entryFromPrice?: number;
+    entryToPrice?: number;
 }
 /** Карта авторства: канал → id кластера-автора. */
 type AuthorMap = Map<string, number>;
@@ -473,6 +478,23 @@ interface LabeledBurst {
     /** ключ exit-набора → результат replay */
     byExit: Map<string, ReplayResult>;
 }
+/**
+ * Исход разметки одного кандидата. Диагностика «немых» пустых fit: пустой результат
+ * выглядит одинаково для «нет данных» и «нет входов», а это РАЗНЫЕ проблемы (битый
+ * getCandles vs реально не было входов в зону).
+ *  - ok           — размечен, есть вход (burst != null);
+ *  - adapter-error — getCandles бросил (look-ahead guard / дыра / count-mismatch);
+ *  - no-candles    — getCandles вернул пусто (символ/диапазон не дали свечей);
+ *  - no-entry      — свечи есть, но ни один exit-набор не вошёл в зону (или все truncated).
+ */
+type LabelOutcome = "ok" | "adapter-error" | "no-candles" | "no-entry";
+/** Результат labelBurst: типизированный исход + сам размеченный всплеск (null кроме ok). */
+interface LabelResult {
+    outcome: LabelOutcome;
+    burst: LabeledBurst | null;
+    /** текст брошенного getCandles исключения (только при outcome="adapter-error"). */
+    error?: string;
+}
 /** Стабильный строковый ключ exit-набора для кэша/grid. */
 declare const exitKey: (p: ExitParams) => string;
 /**
@@ -480,7 +502,7 @@ declare const exitKey: (p: ExitParams) => string;
  * прогоняет каждый exit-набор через replay. Зона входа берётся из события;
  * если не задана — точка entryFrom=entryTo=open первой свечи.
  */
-declare function labelBurst(getCandles: GetCandles, symbol: string, direction: Direction, ts: number, exitSets: ExitParams[], entryFromPrice?: number, entryToPrice?: number): Promise<LabeledBurst | null>;
+declare function labelBurst(getCandles: GetCandles, symbol: string, direction: Direction, ts: number, exitSets: ExitParams[], entryFromPrice?: number, entryToPrice?: number): Promise<LabelResult>;
 
 /** Максимум свечей в одном чанке (как CC_MAX_CANDLES_PER_REQUEST в проде). */
 declare const MAX_CANDLES_PER_CHUNK = 500;
@@ -711,11 +733,46 @@ interface TradeSignal {
     action: SignalAction;
     /** unix-время сигнала, мс */
     ts: number;
+    /** нижняя граница зоны входа из parser-item (для открытия live-позиции; undefined = вход по рынку) */
+    entryFromPrice?: number;
+    /** верхняя граница зоны входа из parser-item */
+    entryToPrice?: number;
     /** готовый exit-план */
     exit: ExitPlan;
     /** происхождение (аудит), не для ветвления */
     origin: SignalOrigin;
 }
+/**
+ * Реализованный результат сделки — РЕПЛЕЙ exit-плана по свечам ПОСЛЕ входа.
+ * Существует только в backtest (forward-replay по закрытой истории); plan/signals
+ * его НЕ дают (там позиция ещё не закрыта). pnl/peak в долях (0.05 = +5%).
+ */
+interface BacktestResult {
+    /** вошли ли в позицию (false → зона входа не задета на окне свечей) */
+    entered: boolean;
+    /** реализованный pnl, доля (при hard-stop = честный -hardStop%) */
+    pnl: number;
+    /** пиковый pnl за жизнь позиции, доля */
+    peak: number;
+    /** причина выхода (hard-stop / trailing-take / peak-staleness / life-cap / …) */
+    reason: string;
+    /** минут от входа до выхода */
+    heldMinutes: number;
+    /** цена входа (0 если не вошли) */
+    entryPrice: number;
+    /** цена выхода (0 если не вошли) */
+    exitPrice: number;
+    /** замер неполный: после входа не хватило свечей на полный life-cap */
+    truncated: boolean;
+}
+/**
+ * Сигнал backtest = TradeSignal + реализованный result. Тип-потомок: главное
+ * отличие backtest от plan — он РЕПЛЕИТ позицию вперёд и возвращает realized pnl.
+ * Сигнатура backtest() возвращает именно его, поэтому pnl виден без джойна с dump().
+ */
+interface BacktestSignal extends TradeSignal {
+    result: BacktestResult;
+}
 /**
  * Политика разрешённых исходов (allow-список).
  *
@@ -1130,6 +1187,19 @@ interface TrainedParams {
         innerTrials: number;
         /** сколько раз всего запускался fit (для прозрачности мета-перебора) */
         fitAttempts: number;
+        /**
+         * Диагностика фазы разметки: сколько УНИКАЛЬНЫХ кандидатов-всплесков и во что они
+         * вылились (outcomes по LabelOutcome — присутствуют только ненулевые исходы).
+         * totalSamples=0 при candidates>0 указывает причину: "adapter-error" — getCandles
+         * бросает (look-ahead/дыра/символ); "no-candles" — пусто (символ/диапазон);
+         * "no-entry" — свечи есть, но входов в зону нет. Без этого пустой fit немой.
+         */
+        labeling: {
+            candidates: number;
+            outcomes: Partial<Record<LabelOutcome, number>>;
+            /** уникальные тексты getCandles-исключений → счётчик (для adapter-error). */
+            errors: Record<string, number>;
+        };
     };
 }
 interface TrainResult {
@@ -1209,6 +1279,18 @@ declare class PumpMatrix {
     get innerTrials(): number;
     /** Сколько раз всего запускался fit (прозрачность мета-перебора). */
     get fitAttempts(): number;
+    /**
+     * Диагностика фазы разметки: { candidates, outcomes, errors }. Если модель пустая
+     * (totalSamples=0), причина в outcomes по LabelOutcome: "adapter-error" (getCandles
+     * бросает), "no-candles" (вернул пусто — символ/диапазон), "no-entry" (свечи есть,
+     * входов в зону нет), "ok" (размечено). errors — уникальные тексты исключений
+     * getCandles со счётчиком (чтобы adapter-error не был немым).
+     */
+    get labeling(): {
+        candidates: number;
+        outcomes: Partial<Record<LabelOutcome, number>>;
+        errors: Record<string, number>;
+    };
     /**
      * Статистический сертификат: прошёл ли эдж пять барьеров (DSR ≥ 0.95, PBO ≤ 0.10,
      * SPA p ≤ 0.05, N ≥ minTRL, nested OOS > 0). certified=false с reasons, если эдж
@@ -1291,20 +1373,26 @@ declare class PumpMatrix {
      *
      * Источник свечей — getCandles (async) или словарь {symbol: candles} (sync).
      */
-    backtest(items: ParserItem[], getCandles: GetCandles, policy?: Partial<SignalPolicy>): Promise<TradeSignal[]>;
-    backtest(items: ParserItem[], candlesBySymbol: Record<string, ICandleData[]>, policy?: Partial<SignalPolicy>): TradeSignal[];
+    backtest(items: ParserItem[], getCandles: GetCandles, policy?: Partial<SignalPolicy>): Promise<BacktestSignal[]>;
+    backtest(items: ParserItem[], candlesBySymbol: Record<string, ICandleData[]>, policy?: Partial<SignalPolicy>): BacktestSignal[];
     private backtestViaGetCandles;
     /** Точечно под ОДНУ позицию в LIVE (вход = последняя свеча, каскад по прошлому). */
     planFor(symbol: string, direction: Direction, channel: string | null, candles: ICandleData[], policy?: Partial<SignalPolicy>): TradeSignal | null;
-    /** Бэктест под ОДНУ позицию с явным entryTs (replay вперёд, каскад по будущему). */
-    planForAt(symbol: string, direction: Direction, channel: string | null, candles: ICandleData[], entryTs: number, policy?: Partial<SignalPolicy>): TradeSignal | null;
+    /**
+     * Бэктест под ОДНУ позицию с явным entryTs (replay вперёд, каскад по будущему).
+     * Возвращает BacktestSignal с реализованным result. Зона входа не задаётся —
+     * replay берёт точку = open первой свечи (как при отсутствии зоны в обучении).
+     */
+    planForAt(symbol: string, direction: Direction, channel: string | null, candles: ICandleData[], entryTs: number, policy?: Partial<SignalPolicy>): BacktestSignal | null;
     /** Полный отчёт (все вердикты + карта авторства) — для разбора. */
     explain(items: ParserItem[]): PredictionResult;
     private collect;
     private flatExit;
     /**
      * BACKTEST-сборка сигнала: каскад по свечам ПОСЛЕ входа (forward squeezePressure),
-     * допустимо только на истории. Делегирует в общее ядро с mode="backtest".
+     * допустимо только на истории. Возвращает BacktestSignal с реализованным result
+     * (replay exit-плана вперёд) — главное отличие backtest от plan. entryFrom/entryTo
+     * — зона входа для replay (из parser-item); без свечей result.entered=false.
      */
     private buildSignal;
     /**
@@ -1312,6 +1400,12 @@ declare class PumpMatrix {
      * БЕЗ look-ahead. Делегирует в общее ядро с mode="live".
      */
     private buildSignalLive;
+    /**
+     * Реализованный результат для backtest: replay ИТОГОВОГО (с учётом инверсии)
+     * направления и exit-плана сигнала по свечам после входа. Зона входа из parser-item;
+     * если не задана — точка = open первой свечи (как в обучении). Нет свечей → не вошли.
+     */
+    private replayResult;
     /**
      * Строит ЕДИНЫЙ TradeSignal из вердикта. Возвращает null, если исполнять нечего:
      * каскад дал veto ИЛИ получившийся action не в allow-списке. Инверсия здесь же
@@ -1343,4 +1437,4 @@ declare class PumpMatrix {
 declare function predict(parserItems: ParserItem[], config?: Partial<DetectorConfig>): PredictionResult;
 
 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 };
-export type { AuthorMap, CandleInterval, Certification, CertificationInput, DetectorConfig, DetectorMode, Direction, ExitParams, ExitPlan, ExitReason, ExitTensor, FitAttempt, GetCandles, ICandleData, LabeledBurst, MetaLedgerState, MetaPolicy, ParserItem, PnlStats, PredictionResult, ProgressEvent, ProgressFn, PumpVerdict, Reliability, ReliabilityConfig, ReliabilityInput, ReplayResult, ResolveSource, ResolvedExit, RiskRewardStats, SelectionConfig, SignalAction, SignalEvent, SignalOrigin, SignalPolicy, SignalRecord, TradeSignal, TrainGrid, TrainOptions, TrainResult, TrainedParams, ViabilityConfig, ViabilityReport, VolRegime, VolumeFeatures };
+export type { AuthorMap, BacktestResult, BacktestSignal, CandleInterval, Certification, CertificationInput, DetectorConfig, DetectorMode, Direction, ExitParams, ExitPlan, ExitReason, ExitTensor, FitAttempt, GetCandles, ICandleData, LabeledBurst, MetaLedgerState, MetaPolicy, ParserItem, PnlStats, PredictionResult, ProgressEvent, ProgressFn, PumpVerdict, Reliability, ReliabilityConfig, ReliabilityInput, ReplayResult, ResolveSource, ResolvedExit, RiskRewardStats, SelectionConfig, SignalAction, SignalEvent, SignalOrigin, SignalPolicy, SignalRecord, TradeSignal, TrainGrid, TrainOptions, TrainResult, TrainedParams, ViabilityConfig, ViabilityReport, VolRegime, VolumeFeatures };