@tradejs/cli 1.0.8 → 1.0.10

package/dist/scripts/signalsSummary.js

@@ -30,16 +30,310 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/scripts/signalsSummary.ts
 var signalsSummary_exports = {};
 __export(signalsSummary_exports, {
+  main: () => main,
   signalsSummary: () => signalsSummary
 });
 module.exports = __toCommonJS(signalsSummary_exports);
 var import_config = require("dotenv/config");
 var import_args = __toESM(require("args"));
-var import_constants = require("@tradejs/core/constants");
 var import_logger = require("@tradejs/infra/logger");
-var import_redis = require("@tradejs/infra/redis");
 var import_connectors = require("@tradejs/node/connectors");
 
+// src/lib/runtimeRedis.ts
+var import_redis = require("@tradejs/infra/redis");
+var import_time = require("@tradejs/core/time");
+var RESERVED_STRATEGY_NAMES = /* @__PURE__ */ new Set(["charts"]);
+var RESERVED_CONFIG_IDS = /* @__PURE__ */ new Set(["results"]);
+var resolveStrategyConfigIdentityByKey = (userName, key) => {
+  const parts = key.split(":");
+  if (parts.length !== 5) return null;
+  const [users, keyUserName, strategiesKey, strategyName, configId] = parts;
+  if (users !== "users" || keyUserName !== userName || strategiesKey !== "strategies" || !strategyName || !configId || RESERVED_STRATEGY_NAMES.has(strategyName) || RESERVED_CONFIG_IDS.has(configId) || !/^[a-zA-Z0-9_-]+$/.test(configId)) {
+    return null;
+  }
+  return { strategyName, configId };
+};
+var isRuntimeTradeRecord = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const record = value;
+  return typeof record.orderId === "string" && typeof record.strategy === "string" && typeof record.symbol === "string" && typeof record.entryTimestamp === "number" && typeof record.entryPrice === "number" && typeof record.qty === "number" && (record.direction === "LONG" || record.direction === "SHORT");
+};
+var resolveStrategyNameByConfigKey = (userName, key) => {
+  return resolveStrategyConfigIdentityByKey(userName, key)?.strategyName ?? null;
+};
+var getRuntimeStrategyConfigKeys = async (userName) => {
+  const keys = await (0, import_redis.getKeys)(`${import_redis.redisKeys.strategies(userName)}:`);
+  return keys.filter((key) => resolveStrategyConfigIdentityByKey(userName, key)).sort((left, right) => left.localeCompare(right));
+};
+var loadRuntimeStrategyNames = async (userName) => [
+  ...new Set(
+    (await getRuntimeStrategyConfigKeys(userName)).map((key) => resolveStrategyNameByConfigKey(userName, key)).filter((value) => Boolean(value))
+  )
+].sort((left, right) => left.localeCompare(right));
+var loadRuntimeTrades = async (userName, {
+  startTime,
+  endTime
+} = {}) => {
+  const hasWindow = Number.isFinite(startTime) && Number.isFinite(endTime) && startTime != null && endTime != null;
+  const filterByWindow = (trade) => !hasWindow || trade.entryTimestamp >= startTime && trade.entryTimestamp <= endTime;
+  if (hasWindow) {
+    const dayKeys = (0, import_time.getRuntimeStorageDayKeys)(startTime, endTime);
+    const bucketTrades = (await Promise.all(
+      dayKeys.map(
+        (dayKey) => (0, import_redis.getHashJsonValues)(
+          import_redis.redisKeys.runtimeTradeBucket(userName, dayKey)
+        )
+      )
+    )).flat();
+    const dedupedBucketTrades = /* @__PURE__ */ new Map();
+    for (const trade of bucketTrades) {
+      if (!isRuntimeTradeRecord(trade)) {
+        continue;
+      }
+      dedupedBucketTrades.set(trade.orderId, trade);
+    }
+    const windowedTrades = [...dedupedBucketTrades.values()].filter(filterByWindow).sort((left, right) => left.entryTimestamp - right.entryTimestamp);
+    if (windowedTrades.length > 0 || dayKeys.length === 0) {
+      return windowedTrades;
+    }
+  }
+  const tradePrefix = import_redis.redisKeys.runtimeTrades(userName);
+  const bucketPrefix = import_redis.redisKeys.runtimeTradeBuckets(userName);
+  const keys = (await (0, import_redis.getKeys)(tradePrefix)).filter(
+    (key) => !key.startsWith(bucketPrefix)
+  );
+  const trades = await Promise.all(keys.map((key) => (0, import_redis.getData)(key, null)));
+  return trades.filter(isRuntimeTradeRecord).filter(filterByWindow).sort((left, right) => left.entryTimestamp - right.entryTimestamp);
+};
+
+// src/lib/runtimeTradeSync.ts
+var import_constants = require("@tradejs/core/constants");
+var import_time2 = require("@tradejs/core/time");
+var import_redis2 = require("@tradejs/infra/redis");
+var CLOSED_PNL_LIMIT = 100;
+var EXCHANGE_HISTORY_MAX_RANGE_MS = 7 * 24 * 60 * 60 * 1e3;
+var splitExchangeHistoryTimeRange = ({
+  startTime,
+  endTime,
+  maxRangeMs = EXCHANGE_HISTORY_MAX_RANGE_MS
+}) => {
+  if (!Number.isFinite(startTime) || !Number.isFinite(endTime) || !Number.isFinite(maxRangeMs) || maxRangeMs <= 0 || endTime <= startTime) {
+    return [{ startTime, endTime }];
+  }
+  const chunks = [];
+  let chunkStart = Math.trunc(startTime);
+  const finalEnd = Math.trunc(endTime);
+  const maxRange = Math.trunc(maxRangeMs);
+  while (chunkStart < finalEnd) {
+    const chunkEnd = Math.min(finalEnd, chunkStart + maxRange);
+    chunks.push({ startTime: chunkStart, endTime: chunkEnd });
+    if (chunkEnd >= finalEnd) {
+      break;
+    }
+    chunkStart = chunkEnd + 1;
+  }
+  return chunks;
+};
+var formatRuntimeTradeSyncError = (error) => {
+  if (!error || typeof error !== "object") {
+    return String(error || "unknown error");
+  }
+  const record = error;
+  const message = typeof record.message === "string" && record.message.trim() ? record.message.trim() : String(error);
+  const code = typeof record.code === "string" && record.code.trim() ? record.code.trim() : null;
+  const isAxiosError = record.isAxiosError === true;
+  const config = record.config && typeof record.config === "object" ? record.config : null;
+  const response = record.response && typeof record.response === "object" ? record.response : null;
+  const method = typeof config?.method === "string" && config.method.trim() ? config.method.toUpperCase() : null;
+  const url = typeof config?.url === "string" && config.url.trim() ? config.url.trim() : null;
+  const timeout = typeof config?.timeout === "number" && Number.isFinite(config.timeout) ? config.timeout : null;
+  const status = typeof response?.status === "number" && Number.isFinite(response.status) ? response.status : null;
+  const details = [
+    isAxiosError ? "axios" : null,
+    code,
+    status == null ? null : `status=${status}`,
+    method && url ? `${method} ${url}` : url,
+    timeout == null ? null : `timeout=${timeout}ms`
+  ].filter(Boolean);
+  return details.length > 0 ? `${message} (${details.join(", ")})` : message;
+};
+var loadClosedPnlRows = async ({
+  connector,
+  startTime,
+  endTime,
+  callbacks
+}) => {
+  if (typeof connector.getClosedPnl !== "function") {
+    callbacks?.onUnsupported?.();
+    return [];
+  }
+  const rows = [];
+  const chunks = splitExchangeHistoryTimeRange({ startTime, endTime });
+  for (const chunk of chunks) {
+    try {
+      const chunkRows = await connector.getClosedPnl({
+        startTime: chunk.startTime,
+        endTime: chunk.endTime,
+        limit: CLOSED_PNL_LIMIT
+      });
+      if (chunkRows.length >= CLOSED_PNL_LIMIT) {
+        callbacks?.onCapped?.(chunkRows.length);
+      }
+      rows.push(...chunkRows);
+    } catch (error) {
+      callbacks?.onError?.(error);
+    }
+  }
+  return rows.sort((left, right) => left.closedAt - right.closedAt);
+};
+var consumeClosedPnlMatch = (buckets, trade) => {
+  const rows = buckets.get(trade.symbol);
+  if (!rows?.length) {
+    return null;
+  }
+  const minimumClosedAt = trade.entryTimestamp - 5 * 6e4;
+  const matchIndex = rows.findIndex(
+    (row2) => Number.isFinite(row2.closedAt) && row2.closedAt >= minimumClosedAt
+  );
+  if (matchIndex < 0) {
+    return null;
+  }
+  const [row] = rows.splice(matchIndex, 1);
+  return row ?? null;
+};
+var syncRuntimeTrades = async ({
+  userName,
+  connector,
+  trades,
+  startTime,
+  endTime,
+  closedPnlCallbacks,
+  openPositionCallbacks
+}) => {
+  let openPositions = [];
+  let openPositionsReliable = true;
+  if (typeof connector.getOpenPositionPnl === "function") {
+    try {
+      openPositions = await connector.getOpenPositionPnl();
+    } catch (error) {
+      openPositionCallbacks?.onError?.(error);
+      openPositionsReliable = false;
+      openPositions = [];
+    }
+  }
+  const openPositionsBySymbol = new Map(
+    openPositions.map((position) => [position.symbol, position])
+  );
+  const activeOrderIdBySymbol = /* @__PURE__ */ new Map();
+  const symbols = [...new Set(trades.map((trade) => trade.symbol))];
+  await Promise.all(
+    symbols.map(async (symbol) => {
+      const activeRef = await (0, import_redis2.getData)(
+        import_redis2.redisKeys.runtimeActiveTrade(userName, symbol),
+        null
+      );
+      activeOrderIdBySymbol.set(
+        symbol,
+        typeof activeRef?.orderId === "string" ? activeRef.orderId : null
+      );
+    })
+  );
+  const closedPnlRows = await loadClosedPnlRows({
+    connector,
+    startTime,
+    endTime,
+    callbacks: closedPnlCallbacks
+  });
+  const closedPnlBuckets = /* @__PURE__ */ new Map();
+  for (const row of closedPnlRows) {
+    const bucket = closedPnlBuckets.get(row.symbol) ?? [];
+    bucket.push(row);
+    closedPnlBuckets.set(row.symbol, bucket);
+  }
+  const syncedTrades = [];
+  for (const trade of trades) {
+    if (trade.status !== "active") {
+      syncedTrades.push(trade);
+      continue;
+    }
+    const openPosition = openPositionsBySymbol.get(trade.symbol);
+    const activeOrderId = activeOrderIdBySymbol.get(trade.symbol);
+    const isCurrentActiveTrade = activeOrderId === trade.orderId;
+    if (!openPositionsReliable) {
+      syncedTrades.push({
+        ...trade,
+        status: "active",
+        lastSyncedAt: endTime
+      });
+      continue;
+    }
+    if (isCurrentActiveTrade && openPosition && openPosition.direction === trade.direction) {
+      const nextTrade2 = {
+        ...trade,
+        status: "active",
+        currentPrice: openPosition.currentPrice,
+        currentPnl: openPosition.unrealizedPnl,
+        lastSyncedAt: endTime
+      };
+      await (0, import_redis2.setData)(
+        import_redis2.redisKeys.runtimeTrade(userName, trade.orderId),
+        nextTrade2,
+        {
+          expire: 0
+        }
+      );
+      await (0, import_redis2.setHashJsonField)(
+        import_redis2.redisKeys.runtimeTradeBucket(
+          userName,
+          (0, import_time2.getRuntimeStorageDayKey)(trade.entryTimestamp)
+        ),
+        trade.orderId,
+        nextTrade2,
+        { expire: 0 }
+      );
+      syncedTrades.push(nextTrade2);
+      continue;
+    }
+    const matchedClosedPnl = consumeClosedPnlMatch(closedPnlBuckets, trade);
+    const nextTrade = {
+      ...trade,
+      status: "closed",
+      currentPrice: matchedClosedPnl?.exitPrice ?? trade.currentPrice ?? null,
+      currentPnl: matchedClosedPnl?.closedPnl ?? trade.closedPnl ?? trade.currentPnl ?? null,
+      closedPnl: matchedClosedPnl?.closedPnl ?? trade.closedPnl ?? trade.currentPnl ?? null,
+      actualEntryPrice: matchedClosedPnl?.entryPrice ?? trade.actualEntryPrice ?? null,
+      exitPrice: matchedClosedPnl?.exitPrice ?? trade.exitPrice ?? null,
+      actualExitPrice: matchedClosedPnl?.exitPrice ?? trade.actualExitPrice ?? null,
+      exitTimestamp: matchedClosedPnl?.closedAt ?? trade.exitTimestamp ?? endTime,
+      exitType: trade.exitType ?? null,
+      openFee: matchedClosedPnl?.openFee ?? trade.openFee ?? null,
+      closeFee: matchedClosedPnl?.closeFee ?? trade.closeFee ?? null,
+      fundingFee: matchedClosedPnl?.fundingFee ?? trade.fundingFee ?? null,
+      totalFee: matchedClosedPnl?.totalFee ?? trade.totalFee ?? null,
+      lastSyncedAt: endTime
+    };
+    await Promise.all([
+      (0, import_redis2.setData)(import_redis2.redisKeys.runtimeTrade(userName, trade.orderId), nextTrade, {
+        expire: import_constants.TTL_1M
+      }),
+      (0, import_redis2.setHashJsonField)(
+        import_redis2.redisKeys.runtimeTradeBucket(
+          userName,
+          (0, import_time2.getRuntimeStorageDayKey)(trade.entryTimestamp)
+        ),
+        trade.orderId,
+        nextTrade,
+        { expire: import_constants.TTL_1M }
+      ),
+      ...isCurrentActiveTrade ? [(0, import_redis2.delKey)(import_redis2.redisKeys.runtimeActiveTrade(userName, trade.symbol))] : []
+    ]);
+    syncedTrades.push(nextTrade);
+  }
+  return syncedTrades;
+};
+
 // src/lib/telegramReports.ts
 var import_cli = require("@tradejs/node/cli");
 var TELEGRAM_REPORT_CHUNK_LIMIT = 3900;
@@ -84,8 +378,16 @@ ${line}` : line;
 };
 var sendTelegramReport = async (message, options = {}) => {
   const chunks = splitTelegramReport(message);
+  const sendAttachments = async () => {
+    for (const attachment of options.attachments || []) {
+      await (0, import_cli.sendDocumentToTG)(attachment, {
+        userName: options.userName
+      });
+    }
+  };
   if (chunks.length === 1) {
     await (0, import_cli.sendTextToTG)(chunks[0], options);
+    await sendAttachments();
     return chunks.length;
   }
   for (const [index, chunk] of chunks.entries()) {
@@ -97,9 +399,343 @@ ${chunk}`, {
       markup: index === chunks.length - 1 ? options.markup : void 0
     });
   }
+  await sendAttachments();
   return chunks.length;
 };
 
+// src/lib/runtimeSignalsLoader.ts
+var import_redis3 = require("@tradejs/infra/redis");
+
+// src/lib/runtimeSignalsStorage.ts
+var import_constants2 = require("@tradejs/core/constants");
+var import_time3 = require("@tradejs/core/time");
+var isRuntimeSignalBucketRef = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const record = value;
+  return typeof record.signalId === "string" && typeof record.symbol === "string" && typeof record.strategy === "string" && typeof record.timestamp === "number";
+};
+var toCount = (value) => {
+  const parsed = Number.parseInt(String(value ?? "0"), 10);
+  return Number.isFinite(parsed) ? parsed : 0;
+};
+var parseRuntimeSignalStatsBucket = (value) => {
+  const reasonGroups = /* @__PURE__ */ new Map();
+  for (const [field, rawCount] of Object.entries(value)) {
+    if (!field.startsWith("reason:")) {
+      continue;
+    }
+    const [, source, ...reasonParts] = field.split(":");
+    const reason = reasonParts.join(":");
+    if (!source || !reason) {
+      continue;
+    }
+    const reasons = reasonGroups.get(source) ?? /* @__PURE__ */ new Map();
+    reasons.set(reason, toCount(rawCount));
+    reasonGroups.set(source, reasons);
+  }
+  return {
+    evaluated: toCount(value.evaluated),
+    signals: toCount(value.signals),
+    reasonGroups
+  };
+};
+
+// src/lib/runtimeSignalsLoader.ts
+var isSignalRecord = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const record = value;
+  return typeof record.signalId === "string" && typeof record.strategy === "string" && typeof record.symbol === "string" && typeof record.timestamp === "number";
+};
+var sortByTimestamp = (records) => [...records].sort((left, right) => left.timestamp - right.timestamp);
+var filterBucketKeysByWindow = (bucketKeys, prefix, startTime, endTime) => {
+  if (!Number.isFinite(startTime) || !Number.isFinite(endTime) || startTime == null || endTime == null) {
+    return bucketKeys;
+  }
+  const allowedDayKeys = new Set((0, import_time3.getRuntimeStorageDayKeys)(startTime, endTime));
+  if (!allowedDayKeys.size) {
+    return [];
+  }
+  return bucketKeys.filter((key) => {
+    const suffix = key.slice(prefix.length);
+    const firstColon = suffix.indexOf(":");
+    if (firstColon <= 0) {
+      return false;
+    }
+    return allowedDayKeys.has(suffix.slice(0, firstColon));
+  });
+};
+var loadRuntimeSignals = async (userName, {
+  startTime,
+  endTime
+} = {}) => {
+  const bucketPrefix = import_redis3.redisKeys.runtimeSignalBuckets(userName);
+  const bucketKeys = filterBucketKeysByWindow(
+    await (0, import_redis3.getKeys)(bucketPrefix),
+    bucketPrefix,
+    startTime,
+    endTime
+  );
+  const refs = (await Promise.all(bucketKeys.map((key) => (0, import_redis3.getHashJsonValues)(key)))).flat().filter(isRuntimeSignalBucketRef);
+  const seen = /* @__PURE__ */ new Set();
+  const payloads = await Promise.all(
+    refs.map(async (ref) => {
+      const dedupeKey = `${ref.symbol}:${ref.signalId}`;
+      if (seen.has(dedupeKey)) {
+        return null;
+      }
+      seen.add(dedupeKey);
+      const signal = await (0, import_redis3.getData)(
+        import_redis3.redisKeys.storeSignal(ref.symbol, ref.signalId),
+        null
+      );
+      return isSignalRecord(signal) ? signal : null;
+    })
+  );
+  return sortByTimestamp(payloads.filter(isSignalRecord));
+};
+var parseBucketKey = (prefix, key) => {
+  if (!key.startsWith(prefix)) {
+    return null;
+  }
+  const suffix = key.slice(prefix.length);
+  const firstColon = suffix.indexOf(":");
+  if (firstColon <= 0 || firstColon >= suffix.length - 1) {
+    return null;
+  }
+  return {
+    dayKey: suffix.slice(0, firstColon),
+    strategy: suffix.slice(firstColon + 1)
+  };
+};
+var loadRuntimeSignalEvaluationStatsBuckets = async (userName) => {
+  const prefix = import_redis3.redisKeys.runtimeSignalEvaluationStatsBuckets(userName);
+  const keys = await (0, import_redis3.getKeys)(prefix);
+  const entries = await Promise.all(
+    keys.map(async (key) => {
+      const parsedKey = parseBucketKey(prefix, key);
+      if (!parsedKey) {
+        return null;
+      }
+      return {
+        key,
+        ...parsedKey,
+        stats: parseRuntimeSignalStatsBucket(await (0, import_redis3.getHashData)(key))
+      };
+    })
+  );
+  return entries.filter(Boolean);
+};
+
+// src/lib/runtimeDebugEvidence.ts
+var import_redis4 = require("@tradejs/infra/redis");
+var RUNTIME_DEBUG_TIMEZONE = "Europe/Moscow";
+var RUNTIME_DEBUG_TIMEZONE_LABEL = "MSK";
+var formatRuntimeDebugDateTime = (timestamp) => new Intl.DateTimeFormat("ru-RU", {
+  timeZone: RUNTIME_DEBUG_TIMEZONE,
+  year: "numeric",
+  month: "2-digit",
+  day: "2-digit",
+  hour: "2-digit",
+  minute: "2-digit",
+  hour12: false
+}).format(new Date(timestamp));
+var getRuntimeDebugDateParts = (timestamp) => Object.fromEntries(
+  new Intl.DateTimeFormat("en-US", {
+    timeZone: RUNTIME_DEBUG_TIMEZONE,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).formatToParts(new Date(timestamp)).map((part) => [part.type, part.value])
+);
+var formatRuntimeDebugIsoDayKey = (timestamp) => {
+  const parts = getRuntimeDebugDateParts(timestamp);
+  return `${parts.year}-${parts.month}-${parts.day}`;
+};
+var buildRuntimeDebugEvaluationId = ({
+  strategy,
+  symbol,
+  timestamp
+}) => `${strategy}:${symbol}:${timestamp}`;
+var buildRuntimeDebugReportPayload = async ({
+  userName,
+  startTime,
+  endTime,
+  signals,
+  evaluations,
+  trades,
+  strategyConfigs,
+  evaluationStatsBuckets
+}) => {
+  const signalById = new Map(
+    signals.map((signal) => [signal.signalId, signal])
+  );
+  const evaluationById = new Map(
+    evaluations.map((evaluation) => [evaluation.evaluationId, evaluation])
+  );
+  const evaluationBySignalShape = new Map(
+    evaluations.map((evaluation) => [
+      buildRuntimeDebugEvaluationId(evaluation),
+      evaluation
+    ])
+  );
+  const dayKeys = (0, import_time3.getRuntimeStorageDayKeys)(startTime, endTime);
+  const debugTrades = await Promise.all(
+    trades.map(async (trade) => {
+      const signal = trade.signalId != null ? signalById.get(trade.signalId) : void 0;
+      const evaluationId = buildRuntimeDebugEvaluationId({
+        strategy: trade.strategy,
+        symbol: trade.symbol,
+        timestamp: signal?.timestamp ?? trade.entryTimestamp
+      });
+      const knownEvaluation = evaluationById.get(evaluationId) ?? evaluationBySignalShape.get(evaluationId);
+      const tradeDayKey = (0, import_time3.getRuntimeStorageDayKey)(trade.entryTimestamp);
+      const signalDayKey = signal != null ? (0, import_time3.getRuntimeStorageDayKey)(signal.timestamp) : tradeDayKey;
+      const evaluationDayKey = knownEvaluation != null ? (0, import_time3.getRuntimeStorageDayKey)(knownEvaluation.timestamp) : signalDayKey;
+      const tradeKey = import_redis4.redisKeys.runtimeTrade(userName, trade.orderId);
+      const tradeBucketKey = import_redis4.redisKeys.runtimeTradeBucket(
+        userName,
+        tradeDayKey
+      );
+      const activeTradeKey = import_redis4.redisKeys.runtimeActiveTrade(
+        userName,
+        trade.symbol
+      );
+      const signalKey = trade.signalId != null ? import_redis4.redisKeys.storeSignal(trade.symbol, trade.signalId) : null;
+      const evaluationBucketKey = import_redis4.redisKeys.runtimeSignalEvaluationBucket(
+        userName,
+        evaluationDayKey,
+        knownEvaluation?.strategy ?? trade.strategy
+      );
+      const evaluationField = knownEvaluation?.evaluationId ?? evaluationId;
+      const evaluationKey = import_redis4.redisKeys.runtimeSignalEvaluation(
+        userName,
+        evaluationField
+      );
+      const [
+        tradeValue,
+        activeTradeValue,
+        signalValue,
+        directEvaluationValue,
+        bucketEvaluationValue
+      ] = await Promise.all([
+        (0, import_redis4.getData)(tradeKey, null),
+        (0, import_redis4.getData)(activeTradeKey, null),
+        signalKey ? (0, import_redis4.getData)(signalKey, null) : Promise.resolve(null),
+        (0, import_redis4.getData)(evaluationKey, null),
+        knownEvaluation ? Promise.resolve(knownEvaluation) : (0, import_redis4.getHashJsonField)(
+          evaluationBucketKey,
+          evaluationField,
+          null
+        )
+      ]);
+      const evaluationValue = directEvaluationValue ?? bucketEvaluationValue ?? knownEvaluation ?? null;
+      return {
+        redisDebug: {
+          trade: tradeKey,
+          tradeBucket: {
+            key: tradeBucketKey,
+            field: trade.orderId
+          },
+          activeTrade: activeTradeKey,
+          signal: signalKey,
+          evaluation: {
+            key: evaluationBucketKey,
+            field: evaluationField,
+            directKey: evaluationKey
+          }
+        },
+        trade,
+        redisValues: {
+          trade: tradeValue,
+          tradeBucket: trade,
+          activeTrade: activeTradeValue,
+          signal: signalValue ?? signal ?? null,
+          evaluation: evaluationValue ?? knownEvaluation ?? null
+        }
+      };
+    })
+  );
+  const linkedEvaluations = /* @__PURE__ */ new Map();
+  for (const trade of debugTrades) {
+    const evaluation = trade.redisValues.evaluation;
+    if (evaluation && typeof evaluation === "object" && "evaluationId" in evaluation && typeof evaluation.evaluationId === "string") {
+      linkedEvaluations.set(
+        evaluation.evaluationId,
+        evaluation
+      );
+    }
+  }
+  const reportEvaluations = evaluations.length > 0 ? evaluations : [...linkedEvaluations.values()];
+  return {
+    reportType: "runtime-daily-debug",
+    generatedAt: Date.now(),
+    generatedAtMsk: formatRuntimeDebugDateTime(Date.now()),
+    userName,
+    window: {
+      startTime,
+      endTime,
+      startMsk: formatRuntimeDebugDateTime(startTime),
+      endMsk: formatRuntimeDebugDateTime(endTime),
+      dayKeys
+    },
+    redisPrefixes: {
+      runtimeTrades: import_redis4.redisKeys.runtimeTrades(userName),
+      runtimeTradeBuckets: import_redis4.redisKeys.runtimeTradeBuckets(userName),
+      runtimeActiveTrades: import_redis4.redisKeys.runtimeActiveTrades(userName),
+      runtimeSignals: import_redis4.redisKeys.runtimeSignalBuckets(userName),
+      runtimeSignalEvaluations: import_redis4.redisKeys.runtimeSignalEvaluationBuckets(userName),
+      runtimeSignalEvaluationStats: import_redis4.redisKeys.runtimeSignalEvaluationStatsBuckets(userName)
+    },
+    counts: {
+      trades: trades.length,
+      signals: signals.length,
+      evaluations: reportEvaluations.length,
+      evaluationStatsBuckets: evaluationStatsBuckets?.length ?? 0,
+      strategyConfigs: strategyConfigs?.length ?? 0
+    },
+    trades: debugTrades,
+    signals: signals.map((signal) => ({
+      redisKey: import_redis4.redisKeys.storeSignal(signal.symbol, signal.signalId),
+      signal
+    })),
+    evaluations: reportEvaluations.map((evaluation) => ({
+      redisDebug: {
+        key: import_redis4.redisKeys.runtimeSignalEvaluationBucket(
+          userName,
+          (0, import_time3.getRuntimeStorageDayKey)(evaluation.timestamp),
+          evaluation.strategy
+        ),
+        field: evaluation.evaluationId,
+        directKey: import_redis4.redisKeys.runtimeSignalEvaluation(
+          userName,
+          evaluation.evaluationId
+        )
+      },
+      evaluation
+    })),
+    evaluationStatsBuckets: evaluationStatsBuckets ?? [],
+    strategyConfigs: strategyConfigs ?? []
+  };
+};
+var buildRuntimeDebugReportAttachment = async (params) => {
+  const payload = await buildRuntimeDebugReportPayload(params);
+  const dayKey = formatRuntimeDebugIsoDayKey(params.endTime);
+  return {
+    filename: `tradejs-runtime-debug-${params.userName}-${dayKey}.json`,
+    content: JSON.stringify(payload, null, 2),
+    caption: `Runtime debug ${dayKey} ${RUNTIME_DEBUG_TIMEZONE_LABEL}`,
+    summary: {
+      trades: payload.counts.trades,
+      signals: payload.counts.signals,
+      evaluations: payload.counts.evaluations
+    }
+  };
+};
+
 // src/scripts/signalsSummary.ts
 import_args.default.option(["u", "user"], "Use user config", "root");
 import_args.default.option(
@@ -109,6 +745,11 @@ import_args.default.option(
 );
 import_args.default.option(["H", "hours"], "Summary window in hours", 24);
 import_args.default.option(["P", "printOnly"], "Print summary instead of Telegram", false);
+import_args.default.option(
+  "debugAttachment",
+  "Attach runtime Redis debug JSON for replay diagnostics",
+  true
+);
 var flags = import_args.default.parse(process.argv);
 var projectRoot = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
 var SUMMARY_TIMEZONE = "Europe/Moscow";
@@ -124,6 +765,8 @@ var formatMskDateTime = (timestamp) => new Intl.DateTimeFormat("ru-RU", {
   hour12: false
 }).format(new Date(timestamp));
 var formatSigned = (value) => `${value >= 0 ? "+" : ""}${value.toFixed(2)}`;
+var formatPnlMoneyText = (value, knownCount) => knownCount > 0 ? `${formatSigned(value)}$` : "n/a";
+var formatWinRateText = (wins, closedKnown) => closedKnown > 0 ? `${(wins / closedKnown * 100).toFixed(2)}% (${wins}/${closedKnown})` : "n/a";
 var resolveSummaryTitle = (hours) => {
   if (hours === 24) {
     return "TradeJS daily summary";
@@ -131,6 +774,9 @@ var resolveSummaryTitle = (hours) => {
   if (hours === 168) {
     return "TradeJS weekly summary";
   }
+  if (hours === 720) {
+    return "TradeJS monthly summary";
+  }
   return `TradeJS ${hours}h summary`;
 };
 var normalizeStatus = (value) => {
@@ -139,57 +785,57 @@ var normalizeStatus = (value) => {
   }
   return "unknown";
 };
-var normalizeSkipStatsReason = (reason, fallbackSource) => {
-  let source = fallbackSource;
-  let normalizedReason = reason;
-  if (reason.startsWith("AI_QUALITY_BELOW_MIN")) {
-    source = "AI";
-    normalizedReason = "MIN_AI_QUALITY";
-  } else if (reason === "AI_QUALITY_UNAVAILABLE") {
-    source = "AI";
-    normalizedReason = "QUALITY_UNAVAILABLE";
-  } else if (reason === "ML_RESULT_UNAVAILABLE") {
-    source = "ML";
-    normalizedReason = "RESULT_UNAVAILABLE";
-  } else if (reason.startsWith("ML_THRESHOLD_NOT_MET")) {
-    source = "ML";
-    normalizedReason = "ML_THRESHOLD";
-  } else if (reason.startsWith("HOOK_BEFORE_ENTRY_GATE:")) {
-    source = "hook";
-    normalizedReason = `BEFORE_ENTRY_GATE:${reason.slice(
-      "HOOK_BEFORE_ENTRY_GATE:".length
-    )}`;
-  } else if (reason === "HOOK_BEFORE_ENTRY_GATE") {
-    source = "hook";
-    normalizedReason = "BEFORE_ENTRY_GATE";
-  } else if (reason === "MAKE_ORDERS_DISABLED" || reason === "ENTRY_POLICY_BLOCKED") {
-    source = "policy";
-  }
+var shouldAttachDebugReport = (value) => value !== false && String(value).toLowerCase() !== "false";
+var getSummaryDateParts = (timestamp) => Object.fromEntries(
+  new Intl.DateTimeFormat("en-US", {
+    timeZone: SUMMARY_TIMEZONE,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).formatToParts(new Date(timestamp)).map((part) => [part.type, part.value])
+);
+var formatSummaryIsoDayKey = (timestamp) => {
+  const parts = getSummaryDateParts(timestamp);
+  return `${parts.year}-${parts.month}-${parts.day}`;
+};
+var unescapeHtml = (value) => value.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
+var stripTelegramHtml = (value) => unescapeHtml(value.replace(/<\/?(?:b|code)>/g, ""));
+var buildSignalsSummaryAttachment = ({
+  userName,
+  endTime,
+  content
+}) => {
+  const dayKey = formatSummaryIsoDayKey(endTime);
   return {
-    source: `skip from ${source}`,
-    reason: normalizedReason
+    filename: `tradejs-signals-summary-${userName}-${dayKey}.txt`,
+    content: stripTelegramHtml(content),
+    caption: `Signals summary ${dayKey} ${SUMMARY_TIMEZONE_LABEL}`
   };
 };
-var isSignalRecord = (value) => {
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  const record = value;
-  return typeof record.signalId === "string" && typeof record.strategy === "string" && typeof record.symbol === "string" && typeof record.timestamp === "number";
-};
-var isRuntimeSignalEvaluationRecord = (value) => {
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  const record = value;
-  return typeof record.evaluationId === "string" && typeof record.strategy === "string" && typeof record.symbol === "string" && typeof record.timestamp === "number" && (record.status === "signal" || record.status === "skip" || record.status === "error");
-};
-var isRuntimeTradeRecord = (value) => {
-  if (!value || typeof value !== "object") {
-    return false;
+var appendReportAttachmentSummary = ({
+  message,
+  signalsFilename,
+  filename,
+  tradesCount,
+  signalsCount,
+  evaluationsCount
+}) => {
+  const lines = [
+    message,
+    "",
+    "\u{1F4CE} <b>Signal report file</b>",
+    `File: <code>${escapeHtml(signalsFilename)}</code>`
+  ];
+  if (filename) {
+    lines.push(
+      "",
+      "\u{1F4CE} <b>Replay debug file</b>",
+      `File: <code>${escapeHtml(filename)}</code>`,
+      `Inside: trades=<b>${tradesCount ?? 0}</b>, signals=<b>${signalsCount ?? 0}</b>, evaluations=<b>${evaluationsCount ?? 0}</b>`,
+      "Redis refs: <code>trade</code>, <code>tradeBucket</code>, <code>activeTrade</code>, <code>signal</code>, <code>evaluation</code>"
+    );
   }
-  const record = value;
-  return typeof record.orderId === "string" && typeof record.strategy === "string" && typeof record.symbol === "string" && typeof record.entryTimestamp === "number" && typeof record.entryPrice === "number" && typeof record.qty === "number";
+  return lines.join("\n");
 };
 var resolveSummaryConnectorName = async (value) => {
   const connectorName = await (0, import_connectors.resolveConnectorName)(value, projectRoot);
@@ -203,168 +849,75 @@ var resolveSummaryConnectorName = async (value) => {
   );
   return import_connectors.DEFAULT_CONNECTOR_NAME;
 };
-var loadRuntimeSignals = async (userName) => {
-  const keys = await (0, import_redis.getKeys)(import_redis.redisKeys.runtimeSignals(userName));
-  const signals = await Promise.all(keys.map((key) => (0, import_redis.getData)(key, null)));
-  return signals.filter(isSignalRecord).sort((left, right) => left.timestamp - right.timestamp);
-};
-var loadRuntimeSignalEvaluations = async (userName) => {
-  const keys = await (0, import_redis.getKeys)(import_redis.redisKeys.runtimeSignalEvaluations(userName));
-  const evaluations = await Promise.all(keys.map((key) => (0, import_redis.getData)(key, null)));
-  return evaluations.filter(isRuntimeSignalEvaluationRecord).sort((left, right) => left.timestamp - right.timestamp);
-};
-var resolveStrategyNameByConfigKey = (userName, key) => {
-  const parts = key.split(":");
-  if (parts.length !== 5) {
-    return null;
-  }
-  const [users, keyUserName, strategiesKey, strategyName, configKey] = parts;
-  if (users !== "users" || keyUserName !== userName || strategiesKey !== "strategies" || configKey !== "config" || !strategyName) {
-    return null;
+var createRuntimeSignalStats = () => ({
+  evaluated: 0,
+  signals: 0,
+  reasonGroups: /* @__PURE__ */ new Map()
+});
+var mergeRuntimeSignalStats = (target, source) => {
+  target.evaluated += source.evaluated;
+  target.signals += source.signals;
+  for (const [group, reasons] of source.reasonGroups.entries()) {
+    const targetReasons = target.reasonGroups.get(group) ?? /* @__PURE__ */ new Map();
+    for (const [reason, count] of reasons.entries()) {
+      targetReasons.set(reason, (targetReasons.get(reason) ?? 0) + count);
+    }
+    target.reasonGroups.set(group, targetReasons);
   }
-  return strategyName;
-};
-var loadRuntimeStrategyNames = async (userName) => {
-  const keys = await (0, import_redis.getKeys)(`${import_redis.redisKeys.strategies(userName)}:`);
-  return keys.filter((key) => key.endsWith(":config")).map((key) => resolveStrategyNameByConfigKey(userName, key)).filter((value) => Boolean(value)).sort((left, right) => left.localeCompare(right));
-};
-var loadRuntimeTrades = async (userName) => {
-  const keys = await (0, import_redis.getKeys)(import_redis.redisKeys.runtimeTrades(userName));
-  const trades = await Promise.all(keys.map((key) => (0, import_redis.getData)(key, null)));
-  return trades.filter(isRuntimeTradeRecord).sort((left, right) => left.entryTimestamp - right.entryTimestamp);
 };
-var loadClosedPnlRows = async ({
-  connector,
+var buildSummaryPrelude = ({
+  hours,
   startTime,
-  endTime
+  endTime,
+  realizedWindowPnlText,
+  winRateText,
+  longCount,
+  shortCount,
+  openCount,
+  openPnlText
 }) => {
-  if (typeof connector.getClosedPnl !== "function") {
-    return [];
-  }
-  try {
-    const rows = await connector.getClosedPnl({
-      startTime,
-      endTime,
-      limit: 100
-    });
-    return rows.sort((left, right) => left.closedAt - right.closedAt);
-  } catch (error) {
-    import_logger.logger.warn(
-      "signals summary: getClosedPnl failed: %s",
-      error?.message || String(error)
-    );
-    return [];
-  }
+  const windowPnlLabel = hours === 24 ? "24h Realized PnL" : `${hours}h Realized PnL`;
+  return [
+    `\u{1F4CB} <b>${escapeHtml(resolveSummaryTitle(hours))}</b>`,
+    "",
+    "\u{1F552} <b>Window</b>",
+    `<b>${escapeHtml(formatMskDateTime(startTime))} - ${escapeHtml(formatMskDateTime(endTime))} ${SUMMARY_TIMEZONE_LABEL}</b>`,
+    "",
+    `\u23F1 Range: <b>${hours}h</b>`,
+    `\u{1F4B0} <b>${windowPnlLabel}:</b> <b>${escapeHtml(realizedWindowPnlText)}</b>`,
+    `\u{1F3C6} <b>WinRate:</b> <b>${escapeHtml(winRateText)}</b>`,
+    `\u2197\uFE0F <b>LONG:</b> <b>${longCount}</b>, \u2198\uFE0F <b>SHORT:</b> <b>${shortCount}</b>`,
+    `\u{1F4CD} <b>Open positions:</b> <b>${openCount}</b>, Unrealized PnL: <b>${escapeHtml(openPnlText)}</b>`
+  ];
 };
-var consumeClosedPnlMatch = (buckets, trade) => {
-  const rows = buckets.get(trade.symbol);
-  if (!rows?.length) {
-    return null;
+var resolveTradeStatusEmoji = (status, pnl) => {
+  if (status === "active") {
+    return typeof pnl === "number" && Number.isFinite(pnl) && pnl < 0 ? "\u{1F534}" : "\u{1F7E2}";
   }
-  const minimumClosedAt = trade.entryTimestamp - 5 * 6e4;
-  const matchIndex = rows.findIndex(
-    (row2) => Number.isFinite(row2.closedAt) && row2.closedAt >= minimumClosedAt
-  );
-  if (matchIndex < 0) {
-    return null;
+  if (status === "closed") {
+    return typeof pnl === "number" && Number.isFinite(pnl) && pnl < 0 ? "\u274C" : "\u2705";
   }
-  const [row] = rows.splice(matchIndex, 1);
-  return row ?? null;
+  return "\u2754";
 };
-var syncRuntimeTrades = async ({
-  userName,
-  connector,
-  trades,
-  startTime,
-  endTime
-}) => {
-  const openPositions = typeof connector.getOpenPositionPnl === "function" ? await connector.getOpenPositionPnl() : [];
-  const openPositionsBySymbol = new Map(
-    openPositions.map((position) => [position.symbol, position])
-  );
-  const activeOrderIdBySymbol = /* @__PURE__ */ new Map();
-  const symbols = [...new Set(trades.map((trade) => trade.symbol))];
-  await Promise.all(
-    symbols.map(async (symbol) => {
-      const activeRef = await (0, import_redis.getData)(
-        import_redis.redisKeys.runtimeActiveTrade(userName, symbol),
-        null
-      );
-      activeOrderIdBySymbol.set(
-        symbol,
-        typeof activeRef?.orderId === "string" ? activeRef.orderId : null
-      );
-    })
-  );
-  const closedPnlRows = await loadClosedPnlRows({
-    connector,
-    startTime,
-    endTime
-  });
-  const closedPnlBuckets = /* @__PURE__ */ new Map();
-  for (const row of closedPnlRows) {
-    const bucket = closedPnlBuckets.get(row.symbol) ?? [];
-    bucket.push(row);
-    closedPnlBuckets.set(row.symbol, bucket);
-  }
-  const syncedTrades = [];
-  for (const trade of trades) {
-    if (trade.status !== "active") {
-      syncedTrades.push(trade);
-      continue;
-    }
-    const openPosition = openPositionsBySymbol.get(trade.symbol);
-    const activeOrderId = activeOrderIdBySymbol.get(trade.symbol);
-    const isCurrentActiveTrade = activeOrderId === trade.orderId;
-    if (isCurrentActiveTrade && openPosition && openPosition.direction === trade.direction) {
-      const nextTrade2 = {
-        ...trade,
-        status: "active",
-        currentPrice: openPosition.currentPrice,
-        currentPnl: openPosition.unrealizedPnl,
-        lastSyncedAt: endTime
-      };
-      await (0, import_redis.setData)(
-        import_redis.redisKeys.runtimeTrade(userName, trade.orderId),
-        nextTrade2,
-        {
-          expire: 0
-        }
-      );
-      syncedTrades.push(nextTrade2);
-      continue;
-    }
-    const matchedClosedPnl = consumeClosedPnlMatch(closedPnlBuckets, trade);
-    const nextTrade = {
-      ...trade,
-      status: "closed",
-      currentPrice: matchedClosedPnl?.exitPrice ?? trade.currentPrice ?? null,
-      currentPnl: matchedClosedPnl?.closedPnl ?? trade.closedPnl ?? trade.currentPnl ?? null,
-      closedPnl: matchedClosedPnl?.closedPnl ?? trade.closedPnl ?? trade.currentPnl ?? null,
-      exitPrice: matchedClosedPnl?.exitPrice ?? trade.exitPrice ?? null,
-      exitTimestamp: matchedClosedPnl?.closedAt ?? trade.exitTimestamp ?? endTime,
-      lastSyncedAt: endTime
-    };
-    await Promise.all([
-      (0, import_redis.setData)(import_redis.redisKeys.runtimeTrade(userName, trade.orderId), nextTrade, {
-        expire: import_constants.TTL_1M
-      }),
-      ...isCurrentActiveTrade ? [(0, import_redis.delKey)(import_redis.redisKeys.runtimeActiveTrade(userName, trade.symbol))] : []
-    ]);
-    syncedTrades.push(nextTrade);
+var isTimestampInWindow = (timestamp, startTime, endTime) => typeof timestamp === "number" && Number.isFinite(timestamp) && timestamp >= startTime && timestamp < endTime;
+var isRuntimeTradeClosedInWindow = (trade, startTime, endTime) => {
+  if (trade.status !== "closed" || !isTimestampInWindow(trade.exitTimestamp, startTime, endTime)) {
+    return false;
   }
-  return syncedTrades;
+  const looksLikeSyncFallbackClose = trade.exitTimestamp === trade.lastSyncedAt && trade.exitPrice == null && trade.actualExitPrice == null && trade.closeFee == null && trade.fundingFee == null && trade.totalFee == null;
+  return !looksLikeSyncFallbackClose;
 };
-var buildSummaryMessage = ({
+var buildSummaryMessages = ({
   hours,
   startTime,
   endTime,
   configuredStrategyNames,
   signals,
-  signalEvaluations,
+  evaluationStatsByStrategy,
   trades
 }) => {
-  const lines = [];
+  const signalLines = [];
+  const tradeLines = [];
   const statusOrder = [
     "completed",
     "skipped",
@@ -374,7 +927,6 @@ var buildSummaryMessage = ({
   ];
   const strategyNames = /* @__PURE__ */ new Set();
   const signalStats = /* @__PURE__ */ new Map();
-  const evaluationStats = /* @__PURE__ */ new Map();
   const tradeStats = /* @__PURE__ */ new Map();
   for (const strategyName of configuredStrategyNames) {
     if (strategyName) {
@@ -388,75 +940,49 @@ var buildSummaryMessage = ({
     stats.set(status, (stats.get(status) ?? 0) + 1);
     signalStats.set(signal.strategy, stats);
   }
-  for (const evaluation of signalEvaluations) {
-    strategyNames.add(evaluation.strategy);
-    const stats = evaluationStats.get(evaluation.strategy) ?? {
-      evaluated: 0,
-      signals: 0,
-      reasonGroups: /* @__PURE__ */ new Map()
-    };
-    stats.evaluated += 1;
-    if (evaluation.status === "signal") {
-      stats.signals += 1;
-    }
-    const orderStatus = normalizeStatus(evaluation.orderStatus);
-    let skipReason = null;
-    let fallbackSource = "core";
-    if (evaluation.status === "skip") {
-      skipReason = evaluation.reason || "NO_SIGNAL";
-      fallbackSource = "core";
-    } else if (evaluation.status === "signal" && (orderStatus === "skipped" || orderStatus === "canceled")) {
-      skipReason = evaluation.orderSkipReason || evaluation.reason || `orderStatus=${orderStatus}`;
-      fallbackSource = "runtime";
-    } else if (evaluation.status === "error") {
-      skipReason = evaluation.reason || "EVALUATION_ERROR";
-      fallbackSource = "runtime";
-    }
-    if (skipReason) {
-      const normalized = normalizeSkipStatsReason(skipReason, fallbackSource);
-      const reasons = stats.reasonGroups.get(normalized.source) ?? /* @__PURE__ */ new Map();
-      reasons.set(normalized.reason, (reasons.get(normalized.reason) ?? 0) + 1);
-      stats.reasonGroups.set(normalized.source, reasons);
-    }
-    evaluationStats.set(evaluation.strategy, stats);
-  }
-  for (const trade of trades) {
+  const realizedTrades = trades.filter(
+    (trade) => isRuntimeTradeClosedInWindow(trade, startTime, endTime)
+  );
+  const openTrades = trades.filter(
+    (trade) => trade.status === "active" && typeof trade.entryTimestamp === "number" && Number.isFinite(trade.entryTimestamp) && trade.entryTimestamp < endTime
+  );
+  const reportTrades = [...realizedTrades, ...openTrades];
+  for (const trade of reportTrades) {
     strategyNames.add(trade.strategy);
     const stats = tradeStats.get(trade.strategy) ?? {
-      total: 0,
       active: 0,
       closed: 0,
       activePnl: 0,
       activePnlKnown: 0,
       closedPnl: 0,
       closedPnlKnown: 0,
-      totalPnl: 0,
-      totalPnlKnown: 0,
-      trades: []
+      trades: [],
+      closedWins: 0,
+      closedKnown: 0
     };
     const pnl = trade.status === "active" ? trade.currentPnl : trade.closedPnl ?? trade.currentPnl;
-    const pnlText = typeof pnl === "number" && Number.isFinite(pnl) ? formatSigned(pnl) : "n/a";
-    stats.total += 1;
+    const pnlText = typeof pnl === "number" && Number.isFinite(pnl) ? `${formatSigned(pnl)}$` : "n/a";
     if (trade.status === "active") {
       stats.active += 1;
       if (typeof pnl === "number" && Number.isFinite(pnl)) {
         stats.activePnl += pnl;
         stats.activePnlKnown += 1;
-        stats.totalPnl += pnl;
-        stats.totalPnlKnown += 1;
       }
     } else {
       stats.closed += 1;
       if (typeof pnl === "number" && Number.isFinite(pnl)) {
         stats.closedPnl += pnl;
         stats.closedPnlKnown += 1;
-        stats.totalPnl += pnl;
-        stats.totalPnlKnown += 1;
+        stats.closedKnown += 1;
+        if (pnl > 0) {
+          stats.closedWins += 1;
+        }
       }
     }
     stats.trades.push({
       symbol: trade.symbol,
       status: trade.status,
+      pnl: typeof pnl === "number" && Number.isFinite(pnl) ? pnl : null,
       pnlText,
       entryTimestamp: trade.entryTimestamp,
       orderId: trade.orderId
@@ -466,39 +992,70 @@ var buildSummaryMessage = ({
   const sortedStrategies = [...strategyNames].sort(
     (left, right) => left.localeCompare(right)
   );
-  const totalWindowPnl = [...tradeStats.values()].reduce(
-    (sum, stats) => sum + stats.totalPnl,
+  const realizedWindowPnl = [...tradeStats.values()].reduce(
+    (sum, stats) => sum + stats.closedPnl,
+    0
+  );
+  const realizedWindowPnlKnown = [...tradeStats.values()].reduce(
+    (sum, stats) => sum + stats.closedPnlKnown,
+    0
+  );
+  const realizedWindowPnlText = realizedWindowPnlKnown > 0 ? formatSigned(realizedWindowPnl) : "n/a";
+  const longCount = realizedTrades.filter(
+    (trade) => trade.direction === "LONG"
+  ).length;
+  const shortCount = realizedTrades.filter(
+    (trade) => trade.direction === "SHORT"
+  ).length;
+  const openPnl = [...tradeStats.values()].reduce(
+    (sum, stats) => sum + stats.activePnl,
     0
   );
-  const totalWindowPnlKnown = [...tradeStats.values()].reduce(
-    (sum, stats) => sum + stats.totalPnlKnown,
+  const openPnlKnown = [...tradeStats.values()].reduce(
+    (sum, stats) => sum + stats.activePnlKnown,
     0
   );
-  const totalWindowPnlText = totalWindowPnlKnown > 0 ? formatSigned(totalWindowPnl) : "n/a";
-  const windowPnlLabel = hours === 24 ? "24h PnL" : `${hours}h PnL`;
-  lines.push(`\u{1F4CB} <b>${escapeHtml(resolveSummaryTitle(hours))}</b>`);
-  lines.push("");
-  lines.push("\u{1F552} <b>Window</b>");
-  lines.push(
-    `<b>${escapeHtml(formatMskDateTime(startTime))} - ${escapeHtml(formatMskDateTime(endTime))} ${SUMMARY_TIMEZONE_LABEL}</b>`
+  const openPnlText = openTrades.length > 0 ? formatPnlMoneyText(openPnl, openPnlKnown) : "n/a";
+  const closedWins = [...tradeStats.values()].reduce(
+    (sum, stats) => sum + stats.closedWins,
+    0
   );
-  lines.push("");
-  lines.push(`\u23F1 Range: <b>${hours}h</b>`);
-  lines.push(
-    `\u{1F4B0} <b>${windowPnlLabel}:</b> <b>${escapeHtml(totalWindowPnlText)}</b>`
+  const closedKnown = [...tradeStats.values()].reduce(
+    (sum, stats) => sum + stats.closedKnown,
+    0
   );
-  lines.push("");
-  lines.push("\u{1F4E1} <b>Signals</b>");
+  const winRateText = formatWinRateText(closedWins, closedKnown);
+  const prelude = buildSummaryPrelude({
+    hours,
+    startTime,
+    endTime,
+    realizedWindowPnlText,
+    winRateText,
+    longCount,
+    shortCount,
+    openCount: openTrades.length,
+    openPnlText
+  });
+  signalLines.push(...prelude);
+  signalLines.push("");
+  signalLines.push("\u{1F4E1} <b>Signals</b>");
+  tradeLines.push(...prelude);
+  tradeLines.push("");
+  tradeLines.push("\u{1F4BC} <b>Closed Trades</b>");
   if (!sortedStrategies.length) {
-    lines.push("\u26A0\uFE0F No runtime data for this window.");
-    return lines.join("\n");
+    signalLines.push("\u26A0\uFE0F No runtime data for this window.");
+    tradeLines.push("\u26A0\uFE0F No runtime data for this window.");
+    return {
+      signalsMessage: signalLines.join("\n"),
+      tradesMessage: tradeLines.join("\n")
+    };
   }
   const appendEvaluationDetails = (strategyName) => {
-    const evaluation = evaluationStats.get(strategyName);
+    const evaluation = evaluationStatsByStrategy.get(strategyName);
     if (!evaluation) {
       return;
     }
-    lines.push(
+    signalLines.push(
       `evaluated=<b>${evaluation.evaluated}</b>, signals=<b>${evaluation.signals}</b>`
     );
     const sourceOrder = ["skip from core", "skip from AI", "skip from ML"];
@@ -512,21 +1069,21 @@ var buildSummaryMessage = ({
       }
     );
     for (const [source, reasons] of sortedReasonGroups) {
-      lines.push(`<b>${escapeHtml(source)}</b>:`);
+      signalLines.push(`<b>${escapeHtml(source)}</b>:`);
       const sortedReasons = [...reasons.entries()].sort(
         (left, right) => right[1] - left[1] || left[0].localeCompare(right[0])
       );
       for (const [reason, count] of sortedReasons) {
-        lines.push(`${escapeHtml(reason)}: <b>${count}</b>`);
+        signalLines.push(`${escapeHtml(reason)}: <b>${count}</b>`);
       }
     }
   };
   for (const strategyName of sortedStrategies) {
     const stats = signalStats.get(strategyName);
     if (!stats || stats.size === 0) {
-      const evaluation = evaluationStats.get(strategyName);
-      lines.push("");
-      lines.push(
+      const evaluation = evaluationStatsByStrategy.get(strategyName);
+      signalLines.push("");
+      signalLines.push(
         evaluation?.evaluated ? `<b>${escapeHtml(strategyName)}</b>
 signals=<b>0</b>` : `<b>${escapeHtml(strategyName)}</b>
 none`
@@ -538,42 +1095,62 @@ none`
       const count = stats.get(status) ?? 0;
       return count > 0 ? `${status}=<b>${count}</b>` : null;
     }).filter(Boolean);
-    lines.push("");
-    lines.push(`<b>${escapeHtml(strategyName)}</b>`);
-    lines.push(parts.join(", "));
+    signalLines.push("");
+    signalLines.push(`<b>${escapeHtml(strategyName)}</b>`);
+    signalLines.push(parts.join(", "));
     appendEvaluationDetails(strategyName);
   }
-  lines.push("");
-  lines.push("\u{1F4BC} <b>Trades</b>");
-  for (const strategyName of sortedStrategies) {
+  const sortedTradeStrategies = [...tradeStats.entries()].filter(([, stats]) => stats.closed > 0).map(([strategyName]) => strategyName).sort((left, right) => left.localeCompare(right));
+  if (sortedTradeStrategies.length === 0) {
+    tradeLines.push("none");
+  }
+  for (const strategyName of sortedTradeStrategies) {
     const stats = tradeStats.get(strategyName);
-    if (!stats) {
-      lines.push("");
-      lines.push(`<b>${escapeHtml(strategyName)}</b>`);
-      lines.push(`total=<b>0</b>`);
-      continue;
+    if (!stats) continue;
+    tradeLines.push("");
+    tradeLines.push(
+      `<b>${escapeHtml(strategyName)}</b> (<b>${stats.closed}</b>)`
+    );
+    tradeLines.push(
+      `Closed PnL: <b>${escapeHtml(formatPnlMoneyText(stats.closedPnl, stats.closedPnlKnown))}</b> (<b>${stats.closed}</b>)`
+    );
+    const sortedTrades = stats.trades.filter((trade) => trade.status === "closed").sort(
+      (left, right) => left.entryTimestamp - right.entryTimestamp || left.symbol.localeCompare(right.symbol) || left.orderId.localeCompare(right.orderId)
+    );
+    for (const trade of sortedTrades) {
+      tradeLines.push(
+        `- ${escapeHtml(trade.symbol)}: PnL <b>${escapeHtml(trade.pnlText)}</b> ${resolveTradeStatusEmoji(trade.status, trade.pnl)}`
+      );
     }
-    const activePnlText = stats.activePnlKnown > 0 ? formatSigned(stats.activePnl) : "n/a";
-    const closedPnlText = stats.closedPnlKnown > 0 ? formatSigned(stats.closedPnl) : "n/a";
-    const totalPnlText = stats.totalPnlKnown > 0 ? formatSigned(stats.totalPnl) : "n/a";
-    lines.push("");
-    lines.push(`<b>${escapeHtml(strategyName)}</b>`);
-    lines.push(
-      `total=<b>${stats.total}</b>, active=<b>${stats.active}</b> (PnL <b>${escapeHtml(activePnlText)}</b>)`
+  }
+  const sortedOpenStrategies = [...tradeStats.entries()].filter(([, stats]) => stats.active > 0).map(([strategyName]) => strategyName).sort((left, right) => left.localeCompare(right));
+  if (sortedOpenStrategies.length > 0) {
+    tradeLines.push("");
+    tradeLines.push("\u{1F4CD} <b>Open Positions</b>");
+  }
+  for (const strategyName of sortedOpenStrategies) {
+    const stats = tradeStats.get(strategyName);
+    if (!stats) continue;
+    tradeLines.push("");
+    tradeLines.push(
+      `<b>${escapeHtml(strategyName)}</b> (<b>${stats.active}</b>)`
     );
-    lines.push(
-      `closed=<b>${stats.closed}</b> (PnL <b>${escapeHtml(closedPnlText)}</b>), totalPnL=<b>${escapeHtml(totalPnlText)}</b>`
+    tradeLines.push(
+      `Unrealized PnL: <b>${escapeHtml(formatPnlMoneyText(stats.activePnl, stats.activePnlKnown))}</b> (<b>${stats.active}</b>)`
     );
-    const sortedTrades = [...stats.trades].sort(
+    const sortedTrades = stats.trades.filter((trade) => trade.status === "active").sort(
       (left, right) => left.entryTimestamp - right.entryTimestamp || left.symbol.localeCompare(right.symbol) || left.orderId.localeCompare(right.orderId)
     );
     for (const trade of sortedTrades) {
-      lines.push(
-        `- ${escapeHtml(trade.symbol)}: PnL <b>${escapeHtml(trade.pnlText)}</b>, status=<b>${escapeHtml(trade.status)}</b>`
+      tradeLines.push(
+        `- ${escapeHtml(trade.symbol)}: PnL <b>${escapeHtml(trade.pnlText)}</b> ${resolveTradeStatusEmoji(trade.status, trade.pnl)}`
       );
     }
   }
-  return lines.join("\n");
+  return {
+    signalsMessage: signalLines.join("\n"),
+    tradesMessage: tradeLines.join("\n")
+  };
 };
 var signalsSummary = async () => {
   const hours = Math.max(
@@ -593,10 +1170,10 @@ var signalsSummary = async () => {
   const connector = await connectorFactory({
     userName: flags.user
   });
-  const [configuredStrategyNames, signals, signalEvaluations, trades] = await Promise.all([
+  const [configuredStrategyNames, signals, evaluationStatsBuckets, trades] = await Promise.all([
     loadRuntimeStrategyNames(flags.user),
-    loadRuntimeSignals(flags.user),
-    loadRuntimeSignalEvaluations(flags.user),
+    loadRuntimeSignals(flags.user, { startTime, endTime }),
+    loadRuntimeSignalEvaluationStatsBuckets(flags.user),
     loadRuntimeTrades(flags.user)
   ]);
   const syncedTrades = await syncRuntimeTrades({
@@ -604,52 +1181,117 @@ var signalsSummary = async () => {
     connector,
     trades,
     startTime,
-    endTime
+    endTime,
+    openPositionCallbacks: {
+      onError: (error) => {
+        import_logger.logger.warn(
+          "signals summary: getOpenPositionPnl failed: %s",
+          formatRuntimeTradeSyncError(error)
+        );
+      }
+    },
+    closedPnlCallbacks: {
+      onError: (error) => {
+        import_logger.logger.warn(
+          "signals summary: getClosedPnl failed: %s",
+          formatRuntimeTradeSyncError(error)
+        );
+      }
+    }
   });
   const windowSignals = signals.filter(
-    (signal) => signal.timestamp >= startTime && signal.timestamp <= endTime
+    (signal) => signal.timestamp >= startTime && signal.timestamp < endTime
   );
-  const windowSignalEvaluations = signalEvaluations.filter(
-    (evaluation) => evaluation.timestamp >= startTime && evaluation.timestamp <= endTime
+  const windowDayKeys = new Set((0, import_time3.getRuntimeStorageDayKeys)(startTime, endTime));
+  const windowEvaluationStats = /* @__PURE__ */ new Map();
+  for (const entry of evaluationStatsBuckets) {
+    if (!windowDayKeys.has(entry.dayKey)) {
+      continue;
+    }
+    const stats = windowEvaluationStats.get(entry.strategy) ?? createRuntimeSignalStats();
+    mergeRuntimeSignalStats(stats, entry.stats);
+    windowEvaluationStats.set(entry.strategy, stats);
+  }
+  const windowClosedTrades = syncedTrades.filter(
+    (trade) => isRuntimeTradeClosedInWindow(trade, startTime, endTime)
+  );
+  const openSnapshotTrades = syncedTrades.filter(
+    (trade) => trade.status === "active" && typeof trade.entryTimestamp === "number" && Number.isFinite(trade.entryTimestamp) && trade.entryTimestamp < endTime
   );
-  const signalIds = new Set(
-    signals.map((signal) => signal.signalId).filter(Boolean)
+  const windowTrades = [...windowClosedTrades, ...openSnapshotTrades];
+  const windowTradeSignalIds = new Set(
+    windowTrades.map((trade) => trade.signalId).filter((signalId) => typeof signalId === "string")
   );
-  const windowTrades = syncedTrades.filter(
-    (trade) => trade.entryTimestamp >= startTime && trade.entryTimestamp <= endTime && trade.signalId != null && signalIds.has(trade.signalId)
+  const debugSignals = windowSignals.filter(
+    (signal) => windowTradeSignalIds.has(signal.signalId)
   );
-  const message = buildSummaryMessage({
+  const { signalsMessage, tradesMessage } = buildSummaryMessages({
     hours,
     startTime,
     endTime,
     configuredStrategyNames,
     signals: windowSignals,
-    signalEvaluations: windowSignalEvaluations,
+    evaluationStatsByStrategy: windowEvaluationStats,
     trades: windowTrades
   });
+  const windowEvaluationsCount = [...windowEvaluationStats.values()].reduce(
+    (sum, stats) => sum + stats.evaluated,
+    0
+  );
   import_logger.logger.info(
     "signals summary window=%sh signals=%s evaluations=%s trades=%s connector=%s user=%s",
     hours,
     windowSignals.length,
-    windowSignalEvaluations.length,
-    windowTrades.length,
+    windowEvaluationsCount,
+    windowClosedTrades.length,
     connectorName,
     flags.user
   );
+  const debugAttachment = shouldAttachDebugReport(flags.debugAttachment) ? await buildRuntimeDebugReportAttachment({
+    userName: flags.user,
+    startTime,
+    endTime,
+    signals: debugSignals,
+    evaluations: [],
+    trades: windowTrades
+  }) : null;
+  const signalsAttachment = buildSignalsSummaryAttachment({
+    userName: flags.user,
+    endTime,
+    content: signalsMessage
+  });
+  const tradesMessageWithAttachmentSummary = appendReportAttachmentSummary({
+    message: tradesMessage,
+    signalsFilename: signalsAttachment.filename,
+    filename: debugAttachment?.filename,
+    tradesCount: debugAttachment ? windowTrades.length : void 0,
+    signalsCount: debugAttachment ? debugAttachment.summary?.signals ?? debugSignals.length : void 0,
+    evaluationsCount: debugAttachment ? debugAttachment.summary?.evaluations ?? 0 : void 0
+  });
+  const attachments = [
+    signalsAttachment,
+    ...debugAttachment ? [debugAttachment] : []
+  ];
   if (flags.printOnly) {
-    console.log(message);
+    console.log(tradesMessageWithAttachmentSummary);
+    console.log("");
+    console.log(`Signals attachment: ${signalsAttachment.filename}`);
+    console.log(signalsAttachment.content);
+    if (debugAttachment) {
+      console.log("");
+      console.log(`Debug attachment: ${debugAttachment.filename}`);
+      console.log(debugAttachment.content);
+    }
     return;
   }
-  await sendTelegramReport(message, { userName: flags.user });
-};
-if (process.env.NODE_ENV !== "test") {
-  signalsSummary().then(() => {
-    process.exit(0);
-  }).catch(() => {
-    process.exit(1);
+  await sendTelegramReport(tradesMessageWithAttachmentSummary, {
+    userName: flags.user,
+    attachments
   });
-}
+};
+var main = signalsSummary;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  main,
   signalsSummary
 });