@tradejs/node 2.0.18 → 2.0.20

package/dist/backtest.mjs

@@ -3,27 +3,20 @@ import {
   getConnectorCreatorByName
 } from "./chunk-V3YMKE4I.mjs";
 import {
+  buildAiPayload,
   buildMlPayload,
-  enrichSignalWithMarketContextStages
-} from "./chunk-3BP3ETAD.mjs";
-import {
-  buildAiPayload
-} from "./chunk-WK5EUCX5.mjs";
-import {
+  enrichSignalWithMarketContextStages,
   getStrategyCreator
-} from "./chunk-QVSMINLG.mjs";
+} from "./chunk-4AVFJMQL.mjs";
 import {
   getTradejsProjectCwd
 } from "./chunk-WS5DYEVZ.mjs";
-import "./chunk-UV2HVMKZ.mjs";
+import "./chunk-Y6FXYEAI.mjs";
 
 // src/backtest.ts
 export * from "@tradejs/core/backtest";
 
 // src/testing.ts
-import {
-  BACKTEST_WARNING_CODES
-} from "@tradejs/types";
 import { alignSortedCandlesByTimestamp } from "@tradejs/core/indicators";
 import {
   BACKTEST_EXECUTION_INTERVAL,
@@ -34,17 +27,227 @@ import {
   releaseStrategyReplayCache
 } from "@tradejs/core/strategies";
 import { getBacktestPreloadStart } from "@tradejs/core/time";
+import { logger } from "@tradejs/infra/logger";
+
+// src/backtest/progress.ts
+var DEFAULT_STRATEGY_CANDLE_TIMEOUT_MS = 6e4;
+var resolvePositiveInt = (value, fallback) => {
+  const parsed = parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+};
+var getEffectiveTimeoutMs = (baseTimeoutMs, stageTimeoutMs) => {
+  const base = baseTimeoutMs && baseTimeoutMs > 0 ? Math.trunc(baseTimeoutMs) : null;
+  const stage = stageTimeoutMs && stageTimeoutMs > 0 ? Math.trunc(stageTimeoutMs) : null;
+  if (base == null) return stage;
+  if (stage == null) return base;
+  return Math.min(base, stage);
+};
+var createBacktestProgress = ({
+  testName,
+  symbol,
+  strategyName,
+  timeoutMs,
+  timeoutSubject
+}) => {
+  const startedAt = Date.now();
+  let activeStageStartedAt = startedAt;
+  let lastProgressSentAt = 0;
+  let lastProgressSignature = "";
+  let currentCandleIndex = 0;
+  let totalCandles = 0;
+  const strategyCandleTimeoutMs = resolvePositiveInt(
+    process.env.BACKTEST_STRATEGY_CANDLE_TIMEOUT_MS,
+    DEFAULT_STRATEGY_CANDLE_TIMEOUT_MS
+  );
+  const emit = (stage, force = false) => {
+    const now = Date.now();
+    const signature = [
+      stage,
+      currentCandleIndex,
+      totalCandles,
+      Math.floor((now - activeStageStartedAt) / 5e3)
+    ].join(":");
+    if (!force) {
+      if (signature === lastProgressSignature || now - lastProgressSentAt < 4e3) {
+        return;
+      }
+    }
+    lastProgressSentAt = now;
+    lastProgressSignature = signature;
+    process.send?.({
+      progress: true,
+      testName,
+      symbol,
+      strategyName,
+      stage,
+      candleIndex: currentCandleIndex,
+      candleTotal: totalCandles,
+      elapsedMs: now - startedAt,
+      stageElapsedMs: now - activeStageStartedAt
+    });
+  };
+  const runWithTimeout = async (stage, action, stageTimeoutOverrideMs) => {
+    const stageTimeoutMs = getEffectiveTimeoutMs(
+      timeoutMs,
+      stageTimeoutOverrideMs
+    );
+    if (stageTimeoutMs == null) return action();
+    activeStageStartedAt = Date.now();
+    emit(stage, true);
+    const promise = action();
+    return await new Promise((resolve, reject) => {
+      const heartbeat = setInterval(() => emit(stage), 5e3);
+      const timer = setTimeout(() => {
+        clearInterval(heartbeat);
+        reject(
+          new Error(
+            `${timeoutSubject} timed out after ${stageTimeoutMs}ms during ${stage}`
+          )
+        );
+      }, stageTimeoutMs);
+      promise.then(
+        (value) => {
+          clearInterval(heartbeat);
+          clearTimeout(timer);
+          resolve(value);
+        },
+        (error) => {
+          clearInterval(heartbeat);
+          clearTimeout(timer);
+          reject(error);
+        }
+      );
+    });
+  };
+  return {
+    run: (stage, action) => runWithTimeout(stage, action, null),
+    runStrategy: (stage, action) => runWithTimeout(stage, action, strategyCandleTimeoutMs),
+    contextStage: (stage) => {
+      activeStageStartedAt = Date.now();
+      emit(`${stage} context`, true);
+    },
+    checkpoint: (stage) => {
+      if (timeoutMs && timeoutMs > 0) emit(stage);
+    },
+    setCandle: (index, total) => {
+      currentCandleIndex = index;
+      totalCandles = total;
+      emit("candle loop", index === 1 || index === total);
+    }
+  };
+};
+
+// src/backtest/session.ts
+import {
+  BACKTEST_WARNING_CODES
+} from "@tradejs/types";
 import { appendAiDatasetRow } from "@tradejs/infra/ai";
+import { appendCoreResearchTraceEvent } from "@tradejs/infra/coreResearch";
 import {
   appendMlDatasetRow,
   buildMlTrainingRow,
   trimMlTrainingRowWindows
 } from "@tradejs/infra/ml";
-import { logger } from "@tradejs/infra/logger";
+
+// src/executionCosts.ts
+import {
+  BACKTEST_BASE_SLIPPAGE_BPS,
+  BACKTEST_DELAY_RISK_MULTIPLIER,
+  BACKTEST_MARKET_IMPACT_BPS,
+  BACKTEST_SPREAD_SLIPPAGE_MULTIPLIER,
+  FEE_PERCENT
+} from "@tradejs/core/constants";
+var finiteOr = (value, fallback) => {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+};
+var feeCache = /* @__PURE__ */ new WeakMap();
+var fundingCache = /* @__PURE__ */ new WeakMap();
+var loadTradingFee = async (connector, symbol) => {
+  if (!connector.getTradingFeeRate) return null;
+  let cache = feeCache.get(connector);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    feeCache.set(connector, cache);
+  }
+  const key = symbol.toUpperCase();
+  const cached = cache.get(key);
+  if (cached) return cached;
+  const rate = await connector.getTradingFeeRate(symbol);
+  cache.set(key, rate);
+  return rate;
+};
+var loadFundingRates = (connector, symbol, startTime, endTime) => {
+  if (!connector.getFundingRateHistory) return Promise.resolve([]);
+  let cache = fundingCache.get(connector);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    fundingCache.set(connector, cache);
+  }
+  const key = `${symbol.toUpperCase()}:${startTime}:${endTime}`;
+  const cached = cache.get(key);
+  if (cached) return cached;
+  const pending = connector.getFundingRateHistory({ symbol, startTime, endTime }).catch(() => []);
+  cache.set(key, pending);
+  return pending;
+};
+var resolveExecutionCosts = async (params) => {
+  const { connector, symbol, config, startTime, endTime, instrument } = params;
+  const cacheOnly = config.EXECUTION_COSTS_CACHE_ONLY === true;
+  const hasConfiguredFees = Number.isFinite(Number(config.MAKER_FEE_RATE)) && Number.isFinite(Number(config.TAKER_FEE_RATE));
+  const exchangeFees = !cacheOnly && !hasConfiguredFees && connector.getTradingFeeRate ? await loadTradingFee(connector, symbol).catch(() => null) : null;
+  const makerRate = hasConfiguredFees ? Number(config.MAKER_FEE_RATE) : exchangeFees?.makerRate ?? FEE_PERCENT;
+  const takerRate = hasConfiguredFees ? Number(config.TAKER_FEE_RATE) : exchangeFees?.takerRate ?? FEE_PERCENT;
+  const fundingEnabled = config.FUNDING_ENABLED !== false && !cacheOnly && typeof connector.getFundingRateHistory === "function";
+  const fundingRates = fundingEnabled ? await loadFundingRates(connector, symbol, startTime, endTime) : [];
+  const requestedLeverage = Math.max(1, finiteOr(config.LEVERAGE, 10));
+  const venueMaxLeverage = Number(instrument?.venueMetadata?.maxLeverage);
+  const maxAllowed = Number.isFinite(venueMaxLeverage) ? venueMaxLeverage : null;
+  const effectiveLeverage = maxAllowed == null ? requestedLeverage : Math.min(requestedLeverage, maxAllowed);
+  const feeSource = hasConfiguredFees ? "config" : exchangeFees?.source ?? "fallback";
+  const fundingSource = !fundingEnabled ? cacheOnly ? "fallback" : "disabled" : fundingRates.length ? "historical" : "unavailable";
+  const usesFallback = feeSource === "fallback" || fundingEnabled && fundingSource === "unavailable" || config.SLIPPAGE_BASE_BPS == null && config.SLIPPAGE_SPREAD_MULTIPLIER == null && config.SLIPPAGE_MARKET_IMPACT_BPS == null;
+  return {
+    model: {
+      fees: { makerRate, takerRate, source: feeSource },
+      funding: {
+        enabled: fundingEnabled,
+        source: fundingSource,
+        points: fundingRates.length,
+        fromTimestamp: fundingRates[0]?.timestamp ?? null,
+        toTimestamp: fundingRates.at(-1)?.timestamp ?? null
+      },
+      slippage: {
+        baseBps: finiteOr(config.SLIPPAGE_BASE_BPS, BACKTEST_BASE_SLIPPAGE_BPS),
+        spreadMultiplier: finiteOr(
+          config.SLIPPAGE_SPREAD_MULTIPLIER,
+          BACKTEST_SPREAD_SLIPPAGE_MULTIPLIER
+        ),
+        marketImpactBps: finiteOr(
+          config.SLIPPAGE_MARKET_IMPACT_BPS,
+          BACKTEST_MARKET_IMPACT_BPS
+        ),
+        delayRiskMultiplier: finiteOr(
+          config.SLIPPAGE_DELAY_RISK_MULTIPLIER,
+          BACKTEST_DELAY_RISK_MULTIPLIER
+        ),
+        source: config.SLIPPAGE_BASE_BPS != null || config.SLIPPAGE_SPREAD_MULTIPLIER != null || config.SLIPPAGE_MARKET_IMPACT_BPS != null ? "config" : "fallback"
+      },
+      leverage: {
+        requested: requestedLeverage,
+        effective: effectiveLeverage,
+        maxAllowed
+      },
+      quality: usesFallback ? "fallback" : fundingEnabled && fundingRates.length ? "full" : "partial",
+      capturedAt: Date.now()
+    },
+    fundingRates
+  };
+};
 
 // src/testConnector.ts
 import { randomUUID } from "crypto";
-import { FEE_PERCENT, INITIAL_BACKTEST_AMOUNT } from "@tradejs/core/constants";
+import { FEE_PERCENT as FEE_PERCENT2, INITIAL_BACKTEST_AMOUNT } from "@tradejs/core/constants";
 import { calculateStatsFull } from "@tradejs/core/backtest";
 import {
   applyExecutionSlippage as applyModeledExecutionSlippage,
@@ -77,8 +280,8 @@ var createTestConnector = (connector, context) => {
   const positionLog = [];
   const fastMode = Boolean(context?.fastMode);
   const executionCostModel = context?.executionCostModel;
-  const makerFeeRate = executionCostModel?.fees.makerRate ?? FEE_PERCENT;
-  const takerFeeRate = executionCostModel?.fees.takerRate ?? FEE_PERCENT;
+  const makerFeeRate = executionCostModel?.fees.makerRate ?? FEE_PERCENT2;
+  const takerFeeRate = executionCostModel?.fees.takerRate ?? FEE_PERCENT2;
   const fundingRates = [...context?.fundingRates ?? []].sort(
     (left, right) => left.timestamp - right.timestamp
   );
@@ -1054,158 +1257,58 @@ var createTestConnector = (connector, context) => {
   };
 };
 
-// src/executionCosts.ts
-import {
-  BACKTEST_BASE_SLIPPAGE_BPS,
-  BACKTEST_DELAY_RISK_MULTIPLIER,
-  BACKTEST_MARKET_IMPACT_BPS,
-  BACKTEST_SPREAD_SLIPPAGE_MULTIPLIER,
-  FEE_PERCENT as FEE_PERCENT2
-} from "@tradejs/core/constants";
-var finiteOr = (value, fallback) => {
-  const parsed = Number(value);
-  return Number.isFinite(parsed) ? parsed : fallback;
-};
-var feeCache = /* @__PURE__ */ new WeakMap();
-var fundingCache = /* @__PURE__ */ new WeakMap();
-var loadTradingFee = async (connector, symbol) => {
-  if (!connector.getTradingFeeRate) return null;
-  let cache = feeCache.get(connector);
-  if (!cache) {
-    cache = /* @__PURE__ */ new Map();
-    feeCache.set(connector, cache);
+// src/backtest/researchTrace.ts
+var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
+var findSetupKey = (value, depth = 0) => {
+  if (depth > 5) return null;
+  const record = asRecord(value);
+  if (!record) return null;
+  for (const key of ["setupIdentity", "setupId", "patternId", "candidateId"]) {
+    const candidate = record[key];
+    if (typeof candidate === "string" && candidate.trim() || typeof candidate === "number" && Number.isFinite(candidate)) {
+      return `${key}:${String(candidate)}`;
+    }
   }
-  const key = symbol.toUpperCase();
-  const cached = cache.get(key);
-  if (cached) return cached;
-  const rate = await connector.getTradingFeeRate(symbol);
-  cache.set(key, rate);
-  return rate;
+  for (const [key, nested] of Object.entries(record)) {
+    if (/context|signal|setup|pattern|candidate|strategy/i.test(key) && nested != null) {
+      const found = findSetupKey(nested, depth + 1);
+      if (found) return found;
+    }
+  }
+  return null;
 };
-var loadFundingRates = (connector, symbol, startTime, endTime) => {
-  if (!connector.getFundingRateHistory) return Promise.resolve([]);
-  let cache = fundingCache.get(connector);
-  if (!cache) {
-    cache = /* @__PURE__ */ new Map();
-    fundingCache.set(connector, cache);
+var resolveCoreResearchSetupIdentity = (signal) => {
+  const strategyKey = findSetupKey(signal.additionalIndicators);
+  return strategyKey ? {
+    setupIdentity: `${signal.strategy}|${signal.symbol}|${signal.direction}|${strategyKey}`,
+    setupIdentitySource: "strategy-context"
+  } : {
+    setupIdentity: `${signal.strategy}|${signal.symbol}|${signal.direction}|${signal.timestamp}`,
+    setupIdentitySource: "signal-time-fallback"
+  };
+};
+
+// src/backtest/session.ts
+var createWarningCounts = () => ({
+  [BACKTEST_WARNING_CODES.TAKE_PROFIT_CROSSED_BEFORE_ENTRY]: 0
+});
+var recordSignalWarning = (warningCounts, signal) => {
+  if (signal && typeof signal !== "string" && signal.orderStatus === "failed" && signal.orderFailureReason === BACKTEST_WARNING_CODES.TAKE_PROFIT_CROSSED_BEFORE_ENTRY) {
+    const code = BACKTEST_WARNING_CODES.TAKE_PROFIT_CROSSED_BEFORE_ENTRY;
+    warningCounts[code] = (warningCounts[code] ?? 0) + 1;
   }
-  const key = `${symbol.toUpperCase()}:${startTime}:${endTime}`;
-  const cached = cache.get(key);
-  if (cached) return cached;
-  const pending = connector.getFundingRateHistory({ symbol, startTime, endTime }).catch(() => []);
-  cache.set(key, pending);
-  return pending;
 };
-var resolveExecutionCosts = async (params) => {
-  const { connector, symbol, config, startTime, endTime, instrument } = params;
-  const cacheOnly = config.EXECUTION_COSTS_CACHE_ONLY === true;
-  const hasConfiguredFees = Number.isFinite(Number(config.MAKER_FEE_RATE)) && Number.isFinite(Number(config.TAKER_FEE_RATE));
-  const exchangeFees = !cacheOnly && !hasConfiguredFees && connector.getTradingFeeRate ? await loadTradingFee(connector, symbol).catch(() => null) : null;
-  const makerRate = hasConfiguredFees ? Number(config.MAKER_FEE_RATE) : exchangeFees?.makerRate ?? FEE_PERCENT2;
-  const takerRate = hasConfiguredFees ? Number(config.TAKER_FEE_RATE) : exchangeFees?.takerRate ?? FEE_PERCENT2;
-  const fundingEnabled = config.FUNDING_ENABLED !== false && !cacheOnly && typeof connector.getFundingRateHistory === "function";
-  const fundingRates = fundingEnabled ? await loadFundingRates(connector, symbol, startTime, endTime) : [];
-  const requestedLeverage = Math.max(1, finiteOr(config.LEVERAGE, 10));
-  const venueMaxLeverage = Number(instrument?.venueMetadata?.maxLeverage);
-  const maxAllowed = Number.isFinite(venueMaxLeverage) ? venueMaxLeverage : null;
-  const effectiveLeverage = maxAllowed == null ? requestedLeverage : Math.min(requestedLeverage, maxAllowed);
-  const feeSource = hasConfiguredFees ? "config" : exchangeFees?.source ?? "fallback";
-  const fundingSource = !fundingEnabled ? cacheOnly ? "fallback" : "disabled" : fundingRates.length ? "historical" : "unavailable";
-  const usesFallback = feeSource === "fallback" || fundingEnabled && fundingSource === "unavailable" || config.SLIPPAGE_BASE_BPS == null && config.SLIPPAGE_SPREAD_MULTIPLIER == null && config.SLIPPAGE_MARKET_IMPACT_BPS == null;
-  return {
-    model: {
-      fees: { makerRate, takerRate, source: feeSource },
-      funding: {
-        enabled: fundingEnabled,
-        source: fundingSource,
-        points: fundingRates.length,
-        fromTimestamp: fundingRates[0]?.timestamp ?? null,
-        toTimestamp: fundingRates.at(-1)?.timestamp ?? null
-      },
-      slippage: {
-        baseBps: finiteOr(config.SLIPPAGE_BASE_BPS, BACKTEST_BASE_SLIPPAGE_BPS),
-        spreadMultiplier: finiteOr(
-          config.SLIPPAGE_SPREAD_MULTIPLIER,
-          BACKTEST_SPREAD_SLIPPAGE_MULTIPLIER
-        ),
-        marketImpactBps: finiteOr(
-          config.SLIPPAGE_MARKET_IMPACT_BPS,
-          BACKTEST_MARKET_IMPACT_BPS
-        ),
-        delayRiskMultiplier: finiteOr(
-          config.SLIPPAGE_DELAY_RISK_MULTIPLIER,
-          BACKTEST_DELAY_RISK_MULTIPLIER
-        ),
-        source: config.SLIPPAGE_BASE_BPS != null || config.SLIPPAGE_SPREAD_MULTIPLIER != null || config.SLIPPAGE_MARKET_IMPACT_BPS != null ? "config" : "fallback"
-      },
-      leverage: {
-        requested: requestedLeverage,
-        effective: effectiveLeverage,
-        maxAllowed
-      },
-      quality: usesFallback ? "fallback" : fundingEnabled && fundingRates.length ? "full" : "partial",
-      capturedAt: Date.now()
-    },
-    fundingRates
-  };
-};
-
-// src/testing.ts
-var isBacktestEntryDelayControlCode = (value) => typeof value === "string" && value.startsWith("BACKTEST_ENTRY_DELAY_");
-var CLOSED_RESULT_FLUSH_INTERVAL = 500;
-var DEFAULT_STRATEGY_CANDLE_TIMEOUT_MS = 6e4;
-var createBacktestWarningCounts = () => ({
-  [BACKTEST_WARNING_CODES.TAKE_PROFIT_CROSSED_BEFORE_ENTRY]: 0
-});
-var recordBacktestSignalWarning = (warningCounts, signal) => {
-  if (!signal || typeof signal === "string" || signal.orderStatus !== "failed" || signal.orderFailureReason !== BACKTEST_WARNING_CODES.TAKE_PROFIT_CROSSED_BEFORE_ENTRY) {
-    return;
-  }
-  const code = BACKTEST_WARNING_CODES.TAKE_PROFIT_CROSSED_BEFORE_ENTRY;
-  warningCounts[code] = (warningCounts[code] ?? 0) + 1;
-};
-var resolvePositiveInt = (value, fallback) => {
-  const parsed = parseInt(String(value ?? ""), 10);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
-};
-var getStrategyCandleTimeoutMs = () => resolvePositiveInt(
-  process.env.BACKTEST_STRATEGY_CANDLE_TIMEOUT_MS,
-  DEFAULT_STRATEGY_CANDLE_TIMEOUT_MS
-);
-var getEffectiveTimeoutMs = (baseTimeoutMs, stageTimeoutMs) => {
-  const base = baseTimeoutMs && baseTimeoutMs > 0 ? Math.trunc(baseTimeoutMs) : null;
-  const stage = stageTimeoutMs && stageTimeoutMs > 0 ? Math.trunc(stageTimeoutMs) : null;
-  if (base == null) return stage;
-  if (stage == null) return base;
-  return Math.min(base, stage);
-};
-var buildCandleByTimestamp = (candles) => new Map(
-  (candles ?? []).filter((candle) => typeof candle?.timestamp === "number").map((candle) => [candle.timestamp, candle])
-);
-var buildBacktestDatasetMetadata = ({
-  backtestRunId,
-  backtestTestKey,
-  chunkId
-}) => {
-  if (!backtestRunId || !backtestTestKey || !chunkId) {
-    return {};
-  }
-  return {
-    backtestRunId,
-    backtestTestKey,
-    backtestChunkId: chunkId
-  };
-};
-var cloneAiPayloadSignal = (signal) => {
-  const cloneValue = (value) => {
-    if (value == null) {
-      return value;
-    }
-    if (typeof structuredClone === "function") {
-      return structuredClone(value);
-    }
-    return JSON.parse(JSON.stringify(value));
-  };
+var buildDatasetMetadata = (test) => test.backtestRunId && test.backtestTestKey && test.chunkId ? {
+  backtestRunId: test.backtestRunId,
+  backtestTestKey: test.backtestTestKey,
+  backtestChunkId: test.chunkId
+} : {};
+var cloneSignal = (signal) => {
+  const cloneValue = (value) => {
+    if (value == null) return value;
+    if (typeof structuredClone === "function") return structuredClone(value);
+    return JSON.parse(JSON.stringify(value));
+  };
   return {
     ...signal,
     figures: cloneValue(signal.figures),
@@ -1213,21 +1316,18 @@ var cloneAiPayloadSignal = (signal) => {
     additionalIndicators: cloneValue(signal.additionalIndicators)
   };
 };
-var buildReplaySignalEvaluationRecord = ({
+var buildReplayEvaluation = ({
   signal,
-  testId,
-  userName,
-  strategyName,
-  symbol,
+  test,
   interval,
   candle
 }) => {
   if (!signal || typeof signal === "string") {
     return {
-      evaluationId: `${testId}:${strategyName}:${symbol}:${candle.timestamp}`,
-      userName,
-      strategy: strategyName,
-      symbol,
+      evaluationId: `${test.testId}:${test.strategyName}:${test.symbol}:${candle.timestamp}`,
+      userName: test.userName,
+      strategy: test.strategyName,
+      symbol: test.symbol,
       interval,
       timestamp: candle.timestamp,
       evaluatedAt: candle.timestamp,
@@ -1237,10 +1337,10 @@ var buildReplaySignalEvaluationRecord = ({
   }
   const signalTimestamp = typeof signal.timestamp === "number" && Number.isFinite(signal.timestamp) ? signal.timestamp : candle.timestamp;
   return {
-    evaluationId: `${signal.signalId || testId}:${strategyName}:${symbol}:${signalTimestamp}`,
-    userName,
-    strategy: signal.strategy || strategyName,
-    symbol: signal.symbol || symbol,
+    evaluationId: `${signal.signalId || test.testId}:${test.strategyName}:${test.symbol}:${signalTimestamp}`,
+    userName: test.userName,
+    strategy: signal.strategy || test.strategyName,
+    symbol: signal.symbol || test.symbol,
     interval: signal.interval || interval,
     timestamp: signalTimestamp,
     evaluatedAt: candle.timestamp,
@@ -1254,6 +1354,320 @@ var buildReplaySignalEvaluationRecord = ({
     ml: signal.ml
   };
 };
+var createBacktestSession = async ({
+  test,
+  connector,
+  strategyCreator,
+  preparedData,
+  interval,
+  sharedIndicatorsReplayKey,
+  monitor
+}) => {
+  const instrument = test.instrument;
+  const start = test.options.start;
+  if (!start) throw new Error("no start");
+  const { model: executionCostModel, fundingRates } = await resolveExecutionCosts({
+    connector,
+    symbol: test.symbol,
+    config: test.strategyConfig,
+    startTime: start,
+    endTime: test.options.end,
+    instrument
+  });
+  const testConnector = createTestConnector(connector, {
+    userName: test.userName,
+    mlEnabled: test.ml,
+    aiEnabled: Boolean(test.ai || test.researchTrace),
+    fastMode: test.fast,
+    instrument,
+    executionCostModel,
+    fundingRates
+  });
+  const strategy = await monitor.run(
+    "strategy init",
+    () => strategyCreator({
+      userName: test.userName,
+      connectorName: test.connectorName,
+      universe: test.universe ?? "crypto",
+      assetClass: test.assetClass ?? instrument?.assetClass,
+      instrument,
+      accountId: test.accountId,
+      deploymentId: test.deploymentId,
+      policyProfileId: test.policyProfileId,
+      config: { ...test.strategyConfig, INTERVAL: test.interval ?? interval },
+      symbol: test.symbol,
+      data: preparedData.prevData.slice(),
+      btcData: preparedData.btcPrevData.slice(),
+      ethData: [...preparedData.ethPrevData, ...preparedData.ethTestData],
+      btcBinanceData: preparedData.btcBinanceData,
+      btcCoinbaseData: preparedData.btcCoinbaseData,
+      backtestExecutionMarketData: {
+        interval: preparedData.backtestExecutionInterval,
+        data: preparedData.backtestExecutionData,
+        btcData: preparedData.backtestExecutionBtcData,
+        dataByTimestamp: preparedData.backtestExecutionDataByTimestamp,
+        btcDataByTimestamp: preparedData.backtestExecutionBtcDataByTimestamp
+      },
+      connector: testConnector,
+      sharedIndicatorsReplayKey
+    })
+  );
+  const pendingMlPayloadBySignalId = /* @__PURE__ */ new Map();
+  const pendingAiRowBySignalId = /* @__PURE__ */ new Map();
+  const pendingResearchSetupBySignalId = /* @__PURE__ */ new Map();
+  const researchSkipCounts = /* @__PURE__ */ new Map();
+  const researchEventCounts = /* @__PURE__ */ new Map();
+  const warningCounts = createWarningCounts();
+  const replayEvaluations = test.collectReplaySignalEvaluations ? [] : null;
+  const chunkId = test.chunkId ?? "single";
+  const processSignal = async (signal, candle) => {
+    recordSignalWarning(warningCounts, signal);
+    if (test.researchTrace && typeof signal === "string") {
+      const reason = signal.trim() || "NO_SIGNAL";
+      researchSkipCounts.set(reason, (researchSkipCounts.get(reason) ?? 0) + 1);
+    }
+    if (typeof signal === "string" && signal.startsWith("BACKTEST_ENTRY_DELAY_")) {
+      return;
+    }
+    if (replayEvaluations) {
+      replayEvaluations.push(
+        buildReplayEvaluation({ signal, test, interval, candle })
+      );
+    }
+    if (signal && typeof signal !== "string" && signal.signalId && (test.ml || test.ai)) {
+      await enrichSignalWithMarketContextStages({
+        signal,
+        env: "BACKTEST",
+        coinMarketCapEnabled: true,
+        onStageStart: monitor.contextStage
+      });
+    }
+    if (test.researchTrace && signal && typeof signal !== "string" && signal.signalId) {
+      const identity = resolveCoreResearchSetupIdentity(signal);
+      pendingResearchSetupBySignalId.set(signal.signalId, identity);
+      await appendCoreResearchTraceEvent({
+        strategyName: test.strategyName,
+        chunkId,
+        event: {
+          schema: "tradejs-core-research-trace/v1",
+          event: signal.orderStatus === "failed" || signal.orderStatus === "skipped" ? "entry_rejected" : "signal_emitted",
+          timestamp: signal.timestamp,
+          strategy: signal.strategy || test.strategyName,
+          symbol: signal.symbol || test.symbol,
+          direction: signal.direction,
+          signalId: signal.signalId,
+          configId: test.configId,
+          backtestRunId: test.backtestRunId,
+          backtestTestKey: test.backtestTestKey,
+          ...identity
+        }
+      });
+      const traceEvent = signal.orderStatus === "failed" || signal.orderStatus === "skipped" ? "entry_rejected" : "signal_emitted";
+      researchEventCounts.set(
+        traceEvent,
+        (researchEventCounts.get(traceEvent) ?? 0) + 1
+      );
+    }
+    if (test.ml && signal && typeof signal !== "string" && signal.signalId) {
+      pendingMlPayloadBySignalId.set(
+        signal.signalId,
+        buildMlPayload({
+          signal,
+          context: {
+            userName: test.userName,
+            testId: test.testId,
+            testSuiteId: test.testSuiteId,
+            testName: test.name,
+            configId: test.configId,
+            symbol: test.symbol,
+            strategyName: test.strategyName,
+            strategyConfig: test.strategyConfig,
+            connectorName: test.connectorName
+          }
+        })
+      );
+    }
+    if (test.ai && signal && typeof signal !== "string" && signal.signalId) {
+      pendingAiRowBySignalId.set(signal.signalId, {
+        signalId: signal.signalId,
+        strategyName: signal.strategy || test.strategyName,
+        symbol: signal.symbol || test.symbol,
+        direction: signal.direction,
+        timestamp: signal.timestamp,
+        signal: cloneSignal(signal),
+        testId: test.testId,
+        testSuiteId: test.testSuiteId,
+        testName: test.name,
+        configId: test.configId,
+        connectorName: test.connectorName,
+        ...buildDatasetMetadata({ ...test, chunkId })
+      });
+    }
+  };
+  const flush = async () => {
+    if (!test.ml && !test.ai && !test.researchTrace) return;
+    const batch = await testConnector.drainMlResultsBatch();
+    for (const resultRecord of batch) {
+      const payload = pendingMlPayloadBySignalId.get(resultRecord.signalId);
+      if (payload) {
+        pendingMlPayloadBySignalId.delete(resultRecord.signalId);
+        const fullRow = buildMlTrainingRow(payload, {
+          profit: resultRecord.profit
+        });
+        await appendMlDatasetRow({
+          strategyName: test.strategyName,
+          chunkId,
+          row: {
+            ...trimMlTrainingRowWindows(fullRow, 5),
+            ...buildDatasetMetadata({ ...test, chunkId })
+          }
+        });
+      }
+      const aiRowBase = pendingAiRowBySignalId.get(resultRecord.signalId);
+      if (aiRowBase) {
+        pendingAiRowBySignalId.delete(resultRecord.signalId);
+        const { signal: aiSignal, ...rowBase } = aiRowBase;
+        await appendAiDatasetRow({
+          strategyName: test.strategyName,
+          chunkId,
+          row: {
+            ...rowBase,
+            payload: buildAiPayload(aiSignal),
+            profit: resultRecord.profit,
+            tradeResult: resultRecord.tradeResult,
+            research: {
+              schema: "tradejs-core-research-row/v1",
+              ...resolveCoreResearchSetupIdentity(aiSignal)
+            }
+          }
+        });
+      }
+      const researchSetup = pendingResearchSetupBySignalId.get(
+        resultRecord.signalId
+      );
+      if (test.researchTrace && researchSetup && resultRecord.tradeResult) {
+        pendingResearchSetupBySignalId.delete(resultRecord.signalId);
+        await appendCoreResearchTraceEvent({
+          strategyName: test.strategyName,
+          chunkId,
+          event: {
+            schema: "tradejs-core-research-trace/v1",
+            event: "entry_executed",
+            timestamp: resultRecord.tradeResult.entryTimestamp,
+            strategy: test.strategyName,
+            symbol: test.symbol,
+            direction: resultRecord.tradeResult.direction,
+            signalId: resultRecord.signalId,
+            configId: test.configId,
+            backtestRunId: test.backtestRunId,
+            backtestTestKey: test.backtestTestKey,
+            ...researchSetup
+          }
+        });
+        researchEventCounts.set(
+          "entry_executed",
+          (researchEventCounts.get("entry_executed") ?? 0) + 1
+        );
+        await appendCoreResearchTraceEvent({
+          strategyName: test.strategyName,
+          chunkId,
+          event: {
+            schema: "tradejs-core-research-trace/v1",
+            event: "position_exited",
+            timestamp: resultRecord.tradeResult.exitTimestamp,
+            strategy: test.strategyName,
+            symbol: test.symbol,
+            direction: resultRecord.tradeResult.direction,
+            signalId: resultRecord.signalId,
+            configId: test.configId,
+            backtestRunId: test.backtestRunId,
+            backtestTestKey: test.backtestTestKey,
+            netProfit: resultRecord.tradeResult.netProfit,
+            exitReason: resultRecord.tradeResult.exitReason,
+            ...researchSetup
+          }
+        });
+        researchEventCounts.set(
+          "position_exited",
+          (researchEventCounts.get("position_exited") ?? 0) + 1
+        );
+      }
+    }
+  };
+  return {
+    detectorFanoutKey: strategy.detectorFanoutKey,
+    detectorNoSignalSkipReason: strategy.detectorNoSignalSkipReason,
+    next: async (candle, btcCandle, detectorSkipCode) => {
+      const delayedSignal = await monitor.runStrategy(
+        "delayed entry",
+        () => strategy.__tradejsFlushBacktestDelayedEntry?.(candle, btcCandle) ?? Promise.resolve(void 0)
+      );
+      if (delayedSignal && typeof delayedSignal !== "string") {
+        await processSignal(delayedSignal, candle);
+      }
+      await monitor.run("exit checks", () => testConnector.checkExits(candle));
+      const signal = await monitor.runStrategy(
+        detectorSkipCode ? "strategy detector skip" : "strategy signal",
+        () => detectorSkipCode && strategy.canFastAdvanceDetectorNoSignal && strategy.advanceDetectorNoSignal ? strategy.advanceDetectorNoSignal(
+          candle,
+          btcCandle,
+          detectorSkipCode
+        ) : detectorSkipCode && strategy.skipDetectorNoSignal ? strategy.skipDetectorNoSignal(
+          candle,
+          btcCandle,
+          detectorSkipCode
+        ) : strategy(candle, btcCandle)
+      );
+      await processSignal(signal, candle);
+      return signal;
+    },
+    flush: () => monitor.run("flush closed results", flush),
+    result: async () => {
+      await monitor.run("flush closed results", flush);
+      if (test.researchTrace) {
+        await appendCoreResearchTraceEvent({
+          strategyName: test.strategyName,
+          chunkId,
+          event: {
+            schema: "tradejs-core-research-trace/v1",
+            event: "skip_summary",
+            timestamp: test.options.end ?? test.options.start ?? 0,
+            strategy: test.strategyName,
+            symbol: test.symbol,
+            configId: test.configId,
+            backtestRunId: test.backtestRunId,
+            backtestTestKey: test.backtestTestKey,
+            skipCounts: Object.fromEntries(
+              [...researchSkipCounts.entries()].sort(
+                ([left], [right]) => left < right ? -1 : left > right ? 1 : 0
+              )
+            )
+          }
+        });
+      }
+      const result = await monitor.run(
+        "collect result",
+        () => testConnector.getResult()
+      );
+      const researchTraceSummary = test.researchTrace ? {
+        events: Object.fromEntries(researchEventCounts),
+        skipCounts: Object.fromEntries(researchSkipCounts)
+      } : void 0;
+      return replayEvaluations ? {
+        ...result,
+        warningCounts,
+        inlineReplaySignalEvaluations: replayEvaluations,
+        researchTraceSummary
+      } : { ...result, warningCounts, researchTraceSummary };
+    }
+  };
+};
+
+// src/testing.ts
+var CLOSED_RESULT_FLUSH_INTERVAL = 500;
+var buildCandleByTimestamp = (candles) => new Map(
+  (candles ?? []).filter((candle) => typeof candle?.timestamp === "number").map((candle) => [candle.timestamp, candle])
+);
 var createTestingKlineCacheState = () => ({
   coinKlineCache: /* @__PURE__ */ new Map(),
   btcKlineCache: /* @__PURE__ */ new Map(),
@@ -1763,132 +2177,35 @@ var canRunTestsInSharedCandleLoop = (tests) => {
     (test) => test.userName === first.userName && test.connectorName === first.connectorName && (test.universe ?? "crypto") === (first.universe ?? "crypto") && (test.accountId ?? null) === (first.accountId ?? null) && (test.deploymentId ?? null) === (first.deploymentId ?? null) && test.symbol === first.symbol && test.strategyName === first.strategyName && test.options?.start === firstStart && test.options?.end === firstEnd && Boolean(test.ml) === Boolean(first.ml) && Boolean(test.ai) === Boolean(first.ai) && Boolean(test.fast) === Boolean(first.fast) && Boolean(test.collectReplaySignalEvaluations) === Boolean(first.collectReplaySignalEvaluations) && (test.interval ?? BACKTEST_INTERVAL) === (first.interval ?? BACKTEST_INTERVAL) && (test.timeoutMs ?? null) === (first.timeoutMs ?? null)
   );
 };
-var testing = async ({
-  userName,
-  symbol,
-  options: { start, end },
-  name,
-  testId,
-  testSuiteId,
-  configId,
-  strategyName,
-  strategyConfig,
-  connectorName,
-  universe = "crypto",
-  assetClass,
-  instrument: requestedInstrument,
-  accountId,
-  deploymentId,
-  policyProfileId,
-  interval = BACKTEST_INTERVAL,
-  ml = false,
-  ai = false,
-  fast = false,
-  collectReplaySignalEvaluations = false,
-  chunkId = "single",
-  backtestRunId,
-  backtestTestKey,
-  timeoutMs
-}) => {
+var testing = async (test) => {
+  const {
+    userName,
+    symbol,
+    options: { start, end },
+    name,
+    strategyName,
+    connectorName,
+    universe = "crypto",
+    accountId,
+    deploymentId,
+    interval = BACKTEST_INTERVAL,
+    timeoutMs
+  } = test;
   if (!start) {
     throw new Error("no start");
   }
   const preloadStart = getBacktestPreloadStart(start);
-  const startedAt = Date.now();
-  let activeStageStartedAt = startedAt;
-  let lastProgressSentAt = 0;
-  let lastProgressSignature = "";
-  let currentCandleIndex = 0;
-  let totalCandles = 0;
-  const strategyCandleTimeoutMs = getStrategyCandleTimeoutMs();
-  const formatTimeoutMessage = (stage, stageTimeoutMs) => `Test ${name} (${symbol}) timed out after ${stageTimeoutMs}ms during ${stage}`;
-  const emitProgress = (stage, options = {}) => {
-    const now = Date.now();
-    const candleIndex = typeof options.candleIndex === "number" ? options.candleIndex : currentCandleIndex;
-    const candleTotal = typeof options.candleTotal === "number" ? options.candleTotal : totalCandles;
-    const signature = [
-      stage,
-      candleIndex,
-      candleTotal,
-      Math.floor((now - activeStageStartedAt) / 5e3)
-    ].join(":");
-    if (!options.force) {
-      if (signature === lastProgressSignature) {
-        return;
-      }
-      if (now - lastProgressSentAt < 4e3) {
-        return;
-      }
-    }
-    lastProgressSentAt = now;
-    lastProgressSignature = signature;
-    process.send?.({
-      progress: true,
-      testName: name,
-      symbol,
-      strategyName,
-      stage,
-      candleIndex,
-      candleTotal,
-      elapsedMs: now - startedAt,
-      stageElapsedMs: now - activeStageStartedAt
-    });
-  };
-  const getStageTimeoutMs = () => {
-    if (!timeoutMs || timeoutMs <= 0) {
-      return null;
-    }
-    return timeoutMs;
-  };
-  const throwIfTimedOut = (stage) => {
-    if (getStageTimeoutMs() == null) {
-      return;
-    }
-    emitProgress(stage);
-  };
-  const withTimeout = async (stage, promise, stageTimeoutOverrideMs = null) => {
-    const stageTimeoutMs = getEffectiveTimeoutMs(
-      getStageTimeoutMs() ?? void 0,
-      stageTimeoutOverrideMs
-    );
-    if (stageTimeoutMs == null) {
-      return promise;
-    }
-    activeStageStartedAt = Date.now();
-    emitProgress(stage, { force: true });
-    return await new Promise((resolve, reject) => {
-      const heartbeat = setInterval(() => {
-        emitProgress(stage);
-      }, 5e3);
-      const timer = setTimeout(() => {
-        clearInterval(heartbeat);
-        reject(new Error(formatTimeoutMessage(stage, stageTimeoutMs)));
-      }, stageTimeoutMs);
-      promise.then(
-        (value) => {
-          clearInterval(heartbeat);
-          clearTimeout(timer);
-          resolve(value);
-        },
-        (error) => {
-          clearInterval(heartbeat);
-          clearTimeout(timer);
-          reject(error);
-        }
-      );
-    });
-  };
-  const runStage = (stage, fn) => {
-    if (getStageTimeoutMs() == null) {
-      return fn();
-    }
-    return withTimeout(stage, fn());
-  };
-  const runStrategyCandleStage = (stage, fn) => withTimeout(stage, fn(), strategyCandleTimeoutMs);
+  const progress = createBacktestProgress({
+    testName: name,
+    symbol,
+    strategyName,
+    timeoutMs,
+    timeoutSubject: `Test ${name} (${symbol})`
+  });
   const { projectRoot, state } = getTestingKlineCacheState();
-  const connector = await withTimeout(
+  const connector = await progress.run(
     "connector init",
-    getCachedConnector({
+    () => getCachedConnector({
       state,
       projectRoot,
       userName,
@@ -1901,16 +2218,16 @@ var testing = async ({
   if (!connector) {
     throw new Error(`Unknown connector: ${connectorName}`);
   }
-  const strategyCreator = await withTimeout(
+  const strategyCreator = await progress.run(
     "strategy lookup",
-    getStrategyCreator(strategyName, projectRoot)
+    () => getStrategyCreator(strategyName, projectRoot)
   );
   if (!strategyCreator) {
     throw new Error(`Unknown strategy: ${strategyName}`);
   }
-  const preparedData = await withTimeout(
+  const preparedData = await progress.run(
     "kline preload",
-    prepareTestingData({
+    () => prepareTestingData({
       state,
       projectRoot,
       userName,
@@ -1928,225 +2245,26 @@ var testing = async ({
   if (!preparedData) {
     throw new Error("Prepared backtest data not available");
   }
-  const {
-    prevData,
-    btcPrevData,
-    ethPrevData,
-    ethTestData,
-    testData,
-    btcTestData,
-    btcBinanceData,
-    btcCoinbaseData,
-    backtestExecutionInterval,
-    backtestExecutionData,
-    backtestExecutionBtcData,
-    backtestExecutionDataByTimestamp,
-    backtestExecutionBtcDataByTimestamp
-  } = preparedData;
-  const runtimePrevData = prevData.slice();
-  const runtimeBtcPrevData = btcPrevData.slice();
-  const runtimeEthData = [...ethPrevData, ...ethTestData];
-  totalCandles = testData.length;
-  const instrument = requestedInstrument;
-  const { model: executionCostModel, fundingRates } = await resolveExecutionCosts({
+  const { testData, btcTestData } = preparedData;
+  const session = await createBacktestSession({
+    test,
     connector,
-    symbol,
-    config: strategyConfig,
-    startTime: start,
-    endTime: end,
-    instrument
-  });
-  const testConnector = createTestConnector(connector, {
-    userName,
-    mlEnabled: ml,
-    aiEnabled: ai,
-    fastMode: fast,
-    instrument,
-    executionCostModel,
-    fundingRates
+    strategyCreator,
+    preparedData,
+    interval,
+    monitor: progress
   });
-  const strategy = await withTimeout(
-    "strategy init",
-    strategyCreator({
-      userName,
-      connectorName,
-      universe,
-      assetClass: assetClass ?? instrument?.assetClass,
-      instrument,
-      accountId,
-      deploymentId,
-      policyProfileId,
-      config: {
-        ...strategyConfig,
-        INTERVAL: interval
-      },
-      symbol,
-      data: runtimePrevData,
-      btcData: runtimeBtcPrevData,
-      ethData: runtimeEthData,
-      btcBinanceData,
-      btcCoinbaseData,
-      backtestExecutionMarketData: {
-        interval: backtestExecutionInterval,
-        data: backtestExecutionData,
-        btcData: backtestExecutionBtcData,
-        dataByTimestamp: backtestExecutionDataByTimestamp,
-        btcDataByTimestamp: backtestExecutionBtcDataByTimestamp
-      },
-      connector: testConnector
-    })
-  );
-  const pendingMlPayloadBySignalId = /* @__PURE__ */ new Map();
-  const pendingAiRowBySignalId = /* @__PURE__ */ new Map();
-  const warningCounts = createBacktestWarningCounts();
-  const replaySignalEvaluations = collectReplaySignalEvaluations ? [] : null;
-  const flushClosedResultsBatch = async () => {
-    if (!ml && !ai) return;
-    const batch = await testConnector.drainMlResultsBatch();
-    if (!batch.length) return;
-    for (const resultRecord of batch) {
-      const payload = pendingMlPayloadBySignalId.get(resultRecord.signalId);
-      if (payload) {
-        pendingMlPayloadBySignalId.delete(resultRecord.signalId);
-        const fullRow = buildMlTrainingRow(payload, {
-          profit: resultRecord.profit
-        });
-        const row = {
-          ...trimMlTrainingRowWindows(fullRow, 5),
-          ...buildBacktestDatasetMetadata({
-            backtestRunId,
-            backtestTestKey,
-            chunkId
-          })
-        };
-        await appendMlDatasetRow({
-          strategyName,
-          chunkId,
-          row
-        });
-      }
-      const aiRowBase = pendingAiRowBySignalId.get(resultRecord.signalId);
-      if (aiRowBase) {
-        pendingAiRowBySignalId.delete(resultRecord.signalId);
-        const { signal: aiSignal, ...rowBase } = aiRowBase;
-        await appendAiDatasetRow({
-          strategyName,
-          chunkId,
-          row: {
-            ...rowBase,
-            payload: buildAiPayload(aiSignal),
-            profit: resultRecord.profit,
-            tradeResult: resultRecord.tradeResult
-          }
-        });
-      }
-    }
-  };
-  const processSignal = async (signal, candle) => {
-    recordBacktestSignalWarning(warningCounts, signal);
-    if (isBacktestEntryDelayControlCode(signal)) {
-      return;
-    }
-    if (replaySignalEvaluations) {
-      replaySignalEvaluations.push(
-        buildReplaySignalEvaluationRecord({
-          signal,
-          testId,
-          userName,
-          strategyName,
-          symbol,
-          interval,
-          candle
-        })
-      );
-    }
-    const shouldCapturePayload = signal && typeof signal !== "string" && signal.signalId && (ml || ai);
-    if (shouldCapturePayload) {
-      await enrichSignalWithMarketContextStages({
-        signal,
-        env: "BACKTEST",
-        coinMarketCapEnabled: true,
-        onStageStart: (stage) => {
-          activeStageStartedAt = Date.now();
-          emitProgress(`${stage} context`, { force: true });
-        }
-      });
-    }
-    if (ml && signal && typeof signal !== "string" && signal.signalId) {
-      const payload = buildMlPayload({
-        signal,
-        context: {
-          userName,
-          testId,
-          testSuiteId,
-          testName: name,
-          configId,
-          symbol,
-          strategyName,
-          strategyConfig,
-          connectorName
-        }
-      });
-      pendingMlPayloadBySignalId.set(signal.signalId, payload);
-    }
-    if (ai && signal && typeof signal !== "string" && signal.signalId) {
-      pendingAiRowBySignalId.set(signal.signalId, {
-        signalId: signal.signalId,
-        strategyName: signal.strategy || strategyName,
-        symbol: signal.symbol || symbol,
-        direction: signal.direction,
-        timestamp: signal.timestamp,
-        signal: cloneAiPayloadSignal(signal),
-        testId,
-        testSuiteId,
-        testName: name,
-        configId,
-        connectorName,
-        ...buildBacktestDatasetMetadata({
-          backtestRunId,
-          backtestTestKey,
-          chunkId
-        })
-      });
-    }
-  };
   for (let candleIndex = 0; candleIndex < testData.length; candleIndex++) {
     if (candleIndex % 25 === 0) {
-      throwIfTimedOut("candle loop");
+      progress.checkpoint("candle loop");
     }
-    currentCandleIndex = candleIndex + 1;
-    emitProgress("candle loop", {
-      force: candleIndex === 0 || currentCandleIndex === totalCandles
-    });
-    const candle = testData[candleIndex];
-    const btcCandle = btcTestData[candleIndex];
-    const delayedSignal = await runStrategyCandleStage(
-      "delayed entry",
-      async () => strategy.__tradejsFlushBacktestDelayedEntry?.(candle, btcCandle)
-    );
-    if (delayedSignal && typeof delayedSignal !== "string") {
-      await processSignal(delayedSignal, candle);
-    }
-    await runStage("exit checks", () => testConnector.checkExits(candle));
-    const signal = await runStrategyCandleStage(
-      "strategy signal",
-      () => strategy(candle, btcCandle)
-    );
-    await processSignal(signal, candle);
+    progress.setCandle(candleIndex + 1, testData.length);
+    await session.next(testData[candleIndex], btcTestData[candleIndex]);
     if ((candleIndex + 1) % CLOSED_RESULT_FLUSH_INTERVAL === 0) {
-      await withTimeout("flush closed results", flushClosedResultsBatch());
+      await session.flush();
     }
   }
-  await withTimeout("flush closed results", flushClosedResultsBatch());
-  const result = await withTimeout("collect result", testConnector.getResult());
-  const resultWithWarnings = {
-    ...result,
-    warningCounts
-  };
-  return replaySignalEvaluations ? {
-    ...resultWithWarnings,
-    inlineReplaySignalEvaluations: replaySignalEvaluations
-  } : resultWithWarnings;
+  return session.result();
 };
 var testingGroupInSharedCandleLoop = async (tests) => {
   if (!canRunTestsInSharedCandleLoop(tests)) {
@@ -2170,10 +2288,6 @@ var testingGroupInSharedCandleLoop = async (tests) => {
     accountId,
     deploymentId,
     interval = BACKTEST_INTERVAL,
-    ml = false,
-    ai = false,
-    fast = false,
-    collectReplaySignalEvaluations = false,
     chunkId = "single",
     timeoutMs
   } = first;
@@ -2181,101 +2295,17 @@ var testingGroupInSharedCandleLoop = async (tests) => {
     throw new Error("no start");
   }
   const preloadStart = getBacktestPreloadStart(start);
-  const startedAt = Date.now();
-  let activeStageStartedAt = startedAt;
-  let lastProgressSentAt = 0;
-  let lastProgressSignature = "";
-  let currentCandleIndex = 0;
-  let totalCandles = 0;
-  const strategyCandleTimeoutMs = getStrategyCandleTimeoutMs();
-  const formatTimeoutMessage = (stage, stageTimeoutMs) => `Test group ${strategyName}/${symbol} timed out after ${stageTimeoutMs}ms during ${stage}`;
-  const emitProgress = (stage, options = {}) => {
-    const now = Date.now();
-    const candleIndex = typeof options.candleIndex === "number" ? options.candleIndex : currentCandleIndex;
-    const candleTotal = typeof options.candleTotal === "number" ? options.candleTotal : totalCandles;
-    const signature = [
-      stage,
-      candleIndex,
-      candleTotal,
-      Math.floor((now - activeStageStartedAt) / 5e3)
-    ].join(":");
-    if (!options.force) {
-      if (signature === lastProgressSignature) {
-        return;
-      }
-      if (now - lastProgressSentAt < 4e3) {
-        return;
-      }
-    }
-    lastProgressSentAt = now;
-    lastProgressSignature = signature;
-    process.send?.({
-      progress: true,
-      testName: first.name,
-      symbol,
-      strategyName,
-      stage,
-      candleIndex,
-      candleTotal,
-      elapsedMs: now - startedAt,
-      stageElapsedMs: now - activeStageStartedAt
-    });
-  };
-  const getStageTimeoutMs = () => {
-    if (!timeoutMs || timeoutMs <= 0) {
-      return null;
-    }
-    return timeoutMs;
-  };
-  const throwIfTimedOut = (stage) => {
-    if (getStageTimeoutMs() == null) {
-      return;
-    }
-    emitProgress(stage);
-  };
-  const withTimeout = async (stage, promise, stageTimeoutOverrideMs = null) => {
-    const stageTimeoutMs = getEffectiveTimeoutMs(
-      getStageTimeoutMs() ?? void 0,
-      stageTimeoutOverrideMs
-    );
-    if (stageTimeoutMs == null) {
-      return promise;
-    }
-    activeStageStartedAt = Date.now();
-    emitProgress(stage, { force: true });
-    return await new Promise((resolve, reject) => {
-      const heartbeat = setInterval(() => {
-        emitProgress(stage);
-      }, 5e3);
-      const timer = setTimeout(() => {
-        clearInterval(heartbeat);
-        reject(new Error(formatTimeoutMessage(stage, stageTimeoutMs)));
-      }, stageTimeoutMs);
-      promise.then(
-        (value) => {
-          clearInterval(heartbeat);
-          clearTimeout(timer);
-          resolve(value);
-        },
-        (error) => {
-          clearInterval(heartbeat);
-          clearTimeout(timer);
-          reject(error);
-        }
-      );
-    });
-  };
-  const runStage = (stage, fn) => {
-    if (getStageTimeoutMs() == null) {
-      return fn();
-    }
-    return withTimeout(stage, fn());
-  };
-  const runStrategyCandleStage = (stage, fn) => withTimeout(stage, fn(), strategyCandleTimeoutMs);
+  const progress = createBacktestProgress({
+    testName: first.name,
+    symbol,
+    strategyName,
+    timeoutMs,
+    timeoutSubject: `Test group ${strategyName}/${symbol}`
+  });
   const { projectRoot, state } = getTestingKlineCacheState();
-  const connector = await withTimeout(
+  const connector = await progress.run(
     "connector init",
-    getCachedConnector({
+    () => getCachedConnector({
       state,
       projectRoot,
       userName,
@@ -2288,16 +2318,16 @@ var testingGroupInSharedCandleLoop = async (tests) => {
   if (!connector) {
     throw new Error(`Unknown connector: ${connectorName}`);
   }
-  const strategyCreator = await withTimeout(
+  const strategyCreator = await progress.run(
     "strategy lookup",
-    getStrategyCreator(strategyName, projectRoot)
+    () => getStrategyCreator(strategyName, projectRoot)
   );
   if (!strategyCreator) {
     throw new Error(`Unknown strategy: ${strategyName}`);
   }
-  const preparedData = await withTimeout(
+  const preparedData = await progress.run(
     "kline preload",
-    prepareTestingData({
+    () => prepareTestingData({
       state,
       projectRoot,
       userName,
@@ -2315,22 +2345,7 @@ var testingGroupInSharedCandleLoop = async (tests) => {
   if (!preparedData) {
     throw new Error("Prepared backtest data not available");
   }
-  const {
-    prevData,
-    btcPrevData,
-    ethPrevData,
-    ethTestData,
-    testData,
-    btcTestData,
-    btcBinanceData,
-    btcCoinbaseData,
-    backtestExecutionInterval,
-    backtestExecutionData,
-    backtestExecutionBtcData,
-    backtestExecutionDataByTimestamp,
-    backtestExecutionBtcDataByTimestamp
-  } = preparedData;
-  totalCandles = testData.length;
+  const { testData, btcTestData } = preparedData;
   const sharedIndicatorsReplayKey = [
     "shared",
     userName,
@@ -2345,250 +2360,45 @@ var testingGroupInSharedCandleLoop = async (tests) => {
   const runners = [];
   try {
     for (const test of tests) {
-      const instrument = test.instrument;
-      const { model: executionCostModel, fundingRates } = await resolveExecutionCosts({
-        connector,
-        symbol: test.symbol,
-        config: test.strategyConfig,
-        startTime: start,
-        endTime: end,
-        instrument
-      });
-      const testConnector = createTestConnector(connector, {
-        userName: test.userName,
-        mlEnabled: test.ml,
-        aiEnabled: test.ai,
-        fastMode: test.fast,
-        instrument,
-        executionCostModel,
-        fundingRates
-      });
-      const strategy = await withTimeout(
-        "strategy init",
-        strategyCreator({
-          userName: test.userName,
-          connectorName: test.connectorName,
-          universe: test.universe ?? universe,
-          assetClass: test.assetClass ?? instrument?.assetClass,
-          instrument,
-          accountId: test.accountId ?? accountId,
-          deploymentId: test.deploymentId ?? deploymentId,
-          policyProfileId: test.policyProfileId,
-          config: {
-            ...test.strategyConfig,
-            INTERVAL: test.interval ?? interval
-          },
-          symbol: test.symbol,
-          data: prevData.slice(),
-          btcData: btcPrevData.slice(),
-          ethData: [...ethPrevData, ...ethTestData],
-          btcBinanceData,
-          btcCoinbaseData,
-          backtestExecutionMarketData: {
-            interval: backtestExecutionInterval,
-            data: backtestExecutionData,
-            btcData: backtestExecutionBtcData,
-            dataByTimestamp: backtestExecutionDataByTimestamp,
-            btcDataByTimestamp: backtestExecutionBtcDataByTimestamp
-          },
-          connector: testConnector,
-          sharedIndicatorsReplayKey
-        })
-      );
       runners.push({
         test,
-        strategy,
-        testConnector,
-        pendingMlPayloadBySignalId: /* @__PURE__ */ new Map(),
-        pendingAiRowBySignalId: /* @__PURE__ */ new Map(),
-        warningCounts: createBacktestWarningCounts(),
-        replaySignalEvaluations: collectReplaySignalEvaluations ? [] : null
+        session: await createBacktestSession({
+          test,
+          connector,
+          strategyCreator,
+          preparedData,
+          interval,
+          sharedIndicatorsReplayKey,
+          monitor: progress
+        })
       });
     }
-    const flushClosedResultsBatch = async (runner) => {
-      if (!runner.test.ml && !runner.test.ai) return;
-      const batch = await runner.testConnector.drainMlResultsBatch();
-      if (!batch.length) return;
-      for (const resultRecord of batch) {
-        const payload = runner.pendingMlPayloadBySignalId.get(
-          resultRecord.signalId
-        );
-        if (payload) {
-          runner.pendingMlPayloadBySignalId.delete(resultRecord.signalId);
-          const fullRow = buildMlTrainingRow(payload, {
-            profit: resultRecord.profit
-          });
-          const resolvedChunkId = runner.test.chunkId ?? "single";
-          const row = {
-            ...trimMlTrainingRowWindows(fullRow, 5),
-            ...buildBacktestDatasetMetadata({
-              backtestRunId: runner.test.backtestRunId,
-              backtestTestKey: runner.test.backtestTestKey,
-              chunkId: resolvedChunkId
-            })
-          };
-          await appendMlDatasetRow({
-            strategyName: runner.test.strategyName,
-            chunkId: resolvedChunkId,
-            row
-          });
-        }
-        const aiRowBase = runner.pendingAiRowBySignalId.get(
-          resultRecord.signalId
-        );
-        if (aiRowBase) {
-          runner.pendingAiRowBySignalId.delete(resultRecord.signalId);
-          const { signal: aiSignal, ...rowBase } = aiRowBase;
-          const resolvedChunkId = runner.test.chunkId ?? "single";
-          await appendAiDatasetRow({
-            strategyName: runner.test.strategyName,
-            chunkId: resolvedChunkId,
-            row: {
-              ...rowBase,
-              payload: buildAiPayload(aiSignal),
-              profit: resultRecord.profit,
-              tradeResult: resultRecord.tradeResult
-            }
-          });
-        }
-      }
-    };
-    const processRunnerSignal = async (runner, signal, candle) => {
-      recordBacktestSignalWarning(runner.warningCounts, signal);
-      if (isBacktestEntryDelayControlCode(signal)) {
-        return;
-      }
-      const { test } = runner;
-      if (runner.replaySignalEvaluations) {
-        runner.replaySignalEvaluations.push(
-          buildReplaySignalEvaluationRecord({
-            signal,
-            testId: test.testId,
-            userName: test.userName,
-            strategyName: test.strategyName,
-            symbol: test.symbol,
-            interval: test.interval ?? interval,
-            candle
-          })
-        );
-      }
-      const shouldCapturePayload = signal && typeof signal !== "string" && signal.signalId && (test.ml || test.ai);
-      if (shouldCapturePayload) {
-        await enrichSignalWithMarketContextStages({
-          signal,
-          env: "BACKTEST",
-          coinMarketCapEnabled: true,
-          onStageStart: (stage) => {
-            activeStageStartedAt = Date.now();
-            emitProgress(`${stage} context`, { force: true });
-          }
-        });
-      }
-      if (test.ml && signal && typeof signal !== "string" && signal.signalId) {
-        const payload = buildMlPayload({
-          signal,
-          context: {
-            userName: test.userName,
-            testId: test.testId,
-            testSuiteId: test.testSuiteId,
-            testName: test.name,
-            configId: test.configId,
-            symbol: test.symbol,
-            strategyName: test.strategyName,
-            strategyConfig: test.strategyConfig,
-            connectorName: test.connectorName
-          }
-        });
-        runner.pendingMlPayloadBySignalId.set(signal.signalId, payload);
-      }
-      if (test.ai && signal && typeof signal !== "string" && signal.signalId) {
-        runner.pendingAiRowBySignalId.set(signal.signalId, {
-          signalId: signal.signalId,
-          strategyName: signal.strategy || test.strategyName,
-          symbol: signal.symbol || test.symbol,
-          direction: signal.direction,
-          timestamp: signal.timestamp,
-          signal: cloneAiPayloadSignal(signal),
-          testId: test.testId,
-          testSuiteId: test.testSuiteId,
-          testName: test.name,
-          configId: test.configId,
-          connectorName: test.connectorName,
-          ...buildBacktestDatasetMetadata({
-            backtestRunId: test.backtestRunId,
-            backtestTestKey: test.backtestTestKey,
-            chunkId: test.chunkId ?? "single"
-          })
-        });
-      }
-    };
     for (let candleIndex = 0; candleIndex < testData.length; candleIndex++) {
       if (candleIndex % 25 === 0) {
-        throwIfTimedOut("candle loop");
+        progress.checkpoint("candle loop");
       }
-      currentCandleIndex = candleIndex + 1;
-      emitProgress("candle loop", {
-        force: candleIndex === 0 || currentCandleIndex === totalCandles
-      });
+      progress.setCandle(candleIndex + 1, testData.length);
       const candle = testData[candleIndex];
       const btcCandle = btcTestData[candleIndex];
       const detectorNoSignalByKey = /* @__PURE__ */ new Map();
       for (const runner of runners) {
-        const { test, testConnector, strategy } = runner;
-        const delayedSignal = await runStrategyCandleStage(
-          "delayed entry",
-          async () => strategy.__tradejsFlushBacktestDelayedEntry?.(candle, btcCandle)
-        );
-        if (delayedSignal && typeof delayedSignal !== "string") {
-          await processRunnerSignal(runner, delayedSignal, candle);
-        }
-        await runStage("exit checks", () => testConnector.checkExits(candle));
-        const detectorFanoutKey = strategy.detectorFanoutKey;
+        const { session } = runner;
+        const detectorFanoutKey = session.detectorFanoutKey;
         const detectorSkipCode = detectorFanoutKey ? detectorNoSignalByKey.get(detectorFanoutKey) : void 0;
-        const signal = await runStrategyCandleStage(
-          detectorSkipCode ? "strategy detector skip" : "strategy signal",
-          () => detectorSkipCode && strategy.canFastAdvanceDetectorNoSignal && strategy.advanceDetectorNoSignal ? strategy.advanceDetectorNoSignal(
-            candle,
-            btcCandle,
-            detectorSkipCode
-          ) : detectorSkipCode && strategy.skipDetectorNoSignal ? strategy.skipDetectorNoSignal(
-            candle,
-            btcCandle,
-            detectorSkipCode
-          ) : strategy(candle, btcCandle)
-        );
-        if (detectorFanoutKey && strategy.detectorNoSignalSkipReason && typeof signal === "string" && signal === strategy.detectorNoSignalSkipReason) {
+        const signal = await session.next(candle, btcCandle, detectorSkipCode);
+        if (detectorFanoutKey && session.detectorNoSignalSkipReason && typeof signal === "string" && signal === session.detectorNoSignalSkipReason) {
           detectorNoSignalByKey.set(detectorFanoutKey, signal);
         }
-        await processRunnerSignal(runner, signal, candle);
       }
       if ((candleIndex + 1) % CLOSED_RESULT_FLUSH_INTERVAL === 0) {
-        await withTimeout(
-          "flush closed results",
-          Promise.all(runners.map((runner) => flushClosedResultsBatch(runner)))
-        );
+        await Promise.all(runners.map(({ session }) => session.flush()));
       }
     }
     const results = [];
     for (const runner of runners) {
-      await withTimeout(
-        "flush closed results",
-        flushClosedResultsBatch(runner)
-      );
-      const result = await withTimeout(
-        "collect result",
-        runner.testConnector.getResult()
-      );
       results.push({
         test: runner.test,
-        result: runner.replaySignalEvaluations ? {
-          ...result,
-          warningCounts: runner.warningCounts,
-          inlineReplaySignalEvaluations: runner.replaySignalEvaluations
-        } : {
-          ...result,
-          warningCounts: runner.warningCounts
-        }
+        result: await runner.session.result()
       });
     }
     return results;