backtest-kit 3.6.0 → 3.7.1

package/build/index.cjs

@@ -463,6 +463,14 @@ const GLOBAL_CONFIG = {
      * Default: true (mutex locking enabled for candle fetching)
      */
     CC_ENABLE_CANDLE_FETCH_MUTEX: true,
+    /**
+     * Enables DCA (Dollar-Cost Averaging) logic even if antirecord is not broken.
+     * Allows to commitAverageBuy if currentPrice is not the lowest price since entry, but still lower than priceOpen.
+     * This can help improve average entry price in cases where price has rebounded after entry but is still below priceOpen, without waiting for a new lower price.
+     *
+     * Default: true (DCA logic enabled everywhere, not just when antirecord is broken)
+     */
+    CC_ENABLE_DCA_EVERYWHERE: false,
 };
 const DEFAULT_CONFIG = Object.freeze({ ...GLOBAL_CONFIG });
 
@@ -801,6 +809,11 @@ const PERSIST_LOG_UTILS_METHOD_NAME_WRITE_DATA = "PersistLogUtils.writeLogData";
 const PERSIST_LOG_UTILS_METHOD_NAME_USE_JSON = "PersistLogUtils.useJson";
 const PERSIST_LOG_UTILS_METHOD_NAME_USE_DUMMY = "PersistLogUtils.useDummy";
 const PERSIST_LOG_UTILS_METHOD_NAME_USE_PERSIST_LOG_ADAPTER = "PersistLogUtils.usePersistLogAdapter";
+const PERSIST_MEASURE_UTILS_METHOD_NAME_READ_DATA = "PersistMeasureUtils.readMeasureData";
+const PERSIST_MEASURE_UTILS_METHOD_NAME_WRITE_DATA = "PersistMeasureUtils.writeMeasureData";
+const PERSIST_MEASURE_UTILS_METHOD_NAME_USE_JSON = "PersistMeasureUtils.useJson";
+const PERSIST_MEASURE_UTILS_METHOD_NAME_USE_DUMMY = "PersistMeasureUtils.useDummy";
+const PERSIST_MEASURE_UTILS_METHOD_NAME_USE_PERSIST_MEASURE_ADAPTER = "PersistMeasureUtils.usePersistMeasureAdapter";
 const BASE_WAIT_FOR_INIT_FN_METHOD_NAME = "PersistBase.waitForInitFn";
 const BASE_UNLINK_RETRY_COUNT = 5;
 const BASE_UNLINK_RETRY_DELAY = 1000;
@@ -2071,6 +2084,92 @@ class PersistLogUtils {
  * Used by LogPersistUtils for log entry persistence.
  */
 const PersistLogAdapter = new PersistLogUtils();
+/**
+ * Utility class for managing external API response cache persistence.
+ *
+ * Features:
+ * - Memoized storage instances per cache bucket (aligned timestamp + symbol)
+ * - Custom adapter support
+ * - Atomic read/write operations
+ * - Crash-safe cache state management
+ *
+ * Used by Cache.file for persistent caching of external API responses.
+ */
+class PersistMeasureUtils {
+    constructor() {
+        this.PersistMeasureFactory = PersistBase;
+        this.getMeasureStorage = functoolsKit.memoize(([bucket]) => bucket, (bucket) => Reflect.construct(this.PersistMeasureFactory, [
+            bucket,
+            `./dump/data/measure/`,
+        ]));
+        /**
+         * Reads cached measure data for a given bucket and key.
+         *
+         * @param bucket - Storage bucket (e.g. aligned timestamp + symbol)
+         * @param key - Dynamic cache key within the bucket
+         * @returns Promise resolving to cached value or null if not found
+         */
+        this.readMeasureData = async (bucket, key) => {
+            bt.loggerService.info(PERSIST_MEASURE_UTILS_METHOD_NAME_READ_DATA, {
+                bucket,
+                key,
+            });
+            const isInitial = !this.getMeasureStorage.has(bucket);
+            const stateStorage = this.getMeasureStorage(bucket);
+            await stateStorage.waitForInit(isInitial);
+            if (await stateStorage.hasValue(key)) {
+                return await stateStorage.readValue(key);
+            }
+            return null;
+        };
+        /**
+         * Writes measure data to disk with atomic file writes.
+         *
+         * @param data - Data to cache
+         * @param bucket - Storage bucket (e.g. aligned timestamp + symbol)
+         * @param key - Dynamic cache key within the bucket
+         * @returns Promise that resolves when write is complete
+         */
+        this.writeMeasureData = async (data, bucket, key) => {
+            bt.loggerService.info(PERSIST_MEASURE_UTILS_METHOD_NAME_WRITE_DATA, {
+                bucket,
+                key,
+            });
+            const isInitial = !this.getMeasureStorage.has(bucket);
+            const stateStorage = this.getMeasureStorage(bucket);
+            await stateStorage.waitForInit(isInitial);
+            await stateStorage.writeValue(key, data);
+        };
+    }
+    /**
+     * Registers a custom persistence adapter.
+     *
+     * @param Ctor - Custom PersistBase constructor
+     */
+    usePersistMeasureAdapter(Ctor) {
+        bt.loggerService.info(PERSIST_MEASURE_UTILS_METHOD_NAME_USE_PERSIST_MEASURE_ADAPTER);
+        this.PersistMeasureFactory = Ctor;
+    }
+    /**
+     * Switches to the default JSON persist adapter.
+     */
+    useJson() {
+        bt.loggerService.log(PERSIST_MEASURE_UTILS_METHOD_NAME_USE_JSON);
+        this.usePersistMeasureAdapter(PersistBase);
+    }
+    /**
+     * Switches to a dummy persist adapter that discards all writes.
+     */
+    useDummy() {
+        bt.loggerService.log(PERSIST_MEASURE_UTILS_METHOD_NAME_USE_DUMMY);
+        this.usePersistMeasureAdapter(PersistDummy);
+    }
+}
+/**
+ * Global singleton instance of PersistMeasureUtils.
+ * Used by Cache.file for persistent caching of external API responses.
+ */
+const PersistMeasureAdapter = new PersistMeasureUtils();
 
 var _a$3, _b$3;
 const BUSY_DELAY = 100;
@@ -3103,75 +3202,90 @@ class ExchangeConnectionService {
     }
 }
 
+const COST_BASIS_PER_ENTRY$3 = 100;
 /**
  * Returns the effective entry price for price calculations.
  *
- * When the _entry array exists and has at least one element, returns
- * the simple arithmetic mean of all entry prices (DCA average).
- * Otherwise returns the original signal.priceOpen.
+ * Uses harmonic mean (correct for fixed-dollar DCA: $100 per entry).
  *
- * This mirrors the _trailingPriceStopLoss pattern: original price is preserved
- * in signal.priceOpen (for identity/tracking), while calculations use the
- * effective averaged price returned by this function.
+ * When partial closes exist, replays the partial sequence to reconstruct
+ * the running cost basis at each partial — no extra stored fields needed.
  *
- * @param signal - Signal row (ISignalRow or IScheduledSignalRow)
- * @returns Effective entry price for distance and PNL calculations
+ * Cost basis replay:
+ *   costBasis starts at 0
+ *   for each partial[i]:
+ *     newEntries = entryCountAtClose[i] - entryCountAtClose[i-1]  (or entryCountAtClose[0] for i=0)
+ *     costBasis += newEntries × $100          ← add DCA entries up to this partial
+ *     positionCostBasisAtClose[i] = costBasis ← snapshot BEFORE close
+ *     costBasis × = (1 - percent[i] / 100)    ← reduce after close
+ *
+ * @param signal - Signal row
+ * @returns Effective entry price for PNL calculations
  */
 const getEffectivePriceOpen = (signal) => {
-    if (signal._entry && signal._entry.length > 0) {
-        return signal._entry.reduce((sum, e) => sum + e.price, 0) / signal._entry.length;
-    }
-    return signal.priceOpen;
+    if (!signal._entry || signal._entry.length === 0)
+        return signal.priceOpen;
+    const entries = signal._entry;
+    const partials = signal._partial ?? [];
+    // No partial exits — pure harmonic mean of all entries
+    if (partials.length === 0) {
+        return harmonicMean(entries.map((e) => e.price));
+    }
+    // Replay cost basis through all partials to get snapshot at the last one
+    let costBasis = 0;
+    for (let i = 0; i < partials.length; i++) {
+        const prevCount = i === 0 ? 0 : partials[i - 1].entryCountAtClose;
+        const newEntryCount = partials[i].entryCountAtClose - prevCount;
+        costBasis += newEntryCount * COST_BASIS_PER_ENTRY$3;
+        // costBasis is now positionCostBasisAtClose for partials[i]
+        if (i < partials.length - 1) {
+            costBasis *= 1 - partials[i].percent / 100;
+        }
+    }
+    const lastPartial = partials[partials.length - 1];
+    // Dollar cost basis remaining after the last partial close
+    const remainingCostBasis = costBasis * (1 - lastPartial.percent / 100);
+    // Coins remaining from the old position
+    const oldCoins = remainingCostBasis / lastPartial.effectivePrice;
+    // New DCA entries added AFTER the last partial close
+    const newEntries = entries.slice(lastPartial.entryCountAtClose);
+    // Coins from new DCA entries (each costs $100)
+    const newCoins = newEntries.reduce((sum, e) => sum + 100 / e.price, 0);
+    const totalCoins = oldCoins + newCoins;
+    if (totalCoins === 0)
+        return lastPartial.effectivePrice;
+    const totalCost = remainingCostBasis + newEntries.length * 100;
+    return totalCost / totalCoins;
+};
+const harmonicMean = (prices) => {
+    if (prices.length === 0)
+        return 0;
+    return prices.length / prices.reduce((sum, p) => sum + 1 / p, 0);
 };
 
+const COST_BASIS_PER_ENTRY$2 = 100;
 /**
  * Calculates profit/loss for a closed signal with slippage and fees.
  *
  * For signals with partial closes:
- * - Calculates weighted PNL: Σ(percent_i × pnl_i) for each partial + (remaining% × final_pnl)
- * - Each partial close has its own slippage
- * - Open fee is charged once; close fees are proportional to each partial's size
- * - Total fees = CC_PERCENT_FEE (open) + Σ CC_PERCENT_FEE × (partial% / 100) × (closeWithSlip / openWithSlip)
- *
- * Formula breakdown:
- * 1. Apply slippage to open/close prices (worse execution)
- *    - LONG: buy higher (+slippage), sell lower (-slippage)
- *    - SHORT: sell lower (-slippage), buy higher (+slippage)
- * 2. Calculate raw PNL percentage
- *    - LONG: ((closePrice - openPrice) / openPrice) * 100
- *    - SHORT: ((openPrice - closePrice) / openPrice) * 100
- * 3. Subtract total fees: open fee + close fee adjusted for slippage-affected execution price
+ * - Weights are calculated by ACTUAL DOLLAR VALUE of each partial relative to total invested.
+ *   This correctly handles DCA entries that occur before or after partial closes.
+ *
+ * Cost basis is reconstructed by replaying the partial sequence via entryCountAtClose + percent:
+ *   costBasis = 0
+ *   for each partial[i]:
+ *     costBasis += (entryCountAtClose[i] - entryCountAtClose[i-1]) × $100
+ *     partialDollarValue[i] = (percent[i] / 100) × costBasis
+ *     weight[i]             = partialDollarValue[i] / totalInvested
+ *     costBasis            *= (1 - percent[i] / 100)
+ *
+ * Fee structure:
+ *   - Open fee:  CC_PERCENT_FEE (charged once)
+ *   - Close fee: CC_PERCENT_FEE × weight × (closeWithSlip / openWithSlip) per partial/remaining
  *
  * @param signal - Closed signal with position details and optional partial history
  * @param priceClose - Actual close price at final exit
  * @returns PNL data with percentage and prices
- *
- * @example
- * ```typescript
- * // Signal without partial closes
- * const pnl = toProfitLossDto(
- *   {
- *     position: "long",
- *     priceOpen: 100,
- *   },
- *   110 // close at +10%
- * );
- * console.log(pnl.pnlPercentage); // ~9.6% (after slippage and fees)
- *
- * // Signal with partial closes
- * const pnlPartial = toProfitLossDto(
- *   {
- *     position: "long",
- *     priceOpen: 100,
- *     _partial: [
- *       { type: "profit", percent: 30, price: 120 }, // +20% on 30%
- *       { type: "profit", percent: 40, price: 115 }, // +15% on 40%
- *     ],
- *   },
- *   105 // final close at +5% for remaining 30%
- * );
- * // Weighted PNL = 30% × 20% + 40% × 15% + 30% × 5% = 6% + 6% + 1.5% = 13.5% (before fees)
- * ```
  */
 const toProfitLossDto = (signal, priceClose) => {
     const priceOpen = getEffectivePriceOpen(signal);
@@ -3180,47 +3294,65 @@ const toProfitLossDto = (signal, priceClose) => {
         let totalWeightedPnl = 0;
         // Open fee is paid once for the whole position
         let totalFees = GLOBAL_CONFIG.CC_PERCENT_FEE;
-        // priceOpenWithSlippage is the same for all partials — compute once
-        const priceOpenWithSlippage = signal.position === "long"
-            ? priceOpen * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100)
-            : priceOpen * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+        // Total invested capital = number of DCA entries × $100 per entry
+        const totalInvested = signal._entry ? signal._entry.length * 100 : 100;
+        let closedDollarValue = 0;
+        // Running cost basis — replayed from entryCountAtClose + percent
+        let costBasis = 0;
         // Calculate PNL for each partial close
-        for (const partial of signal._partial) {
-            const partialPercent = partial.percent;
+        for (let i = 0; i < signal._partial.length; i++) {
+            const partial = signal._partial[i];
+            // Add DCA entries that existed at this partial but not at the previous one
+            const prevCount = i === 0 ? 0 : signal._partial[i - 1].entryCountAtClose;
+            const newEntryCount = partial.entryCountAtClose - prevCount;
+            costBasis += newEntryCount * COST_BASIS_PER_ENTRY$2;
+            // Real dollar value sold in this partial
+            const partialDollarValue = (partial.percent / 100) * costBasis;
+            // Weight relative to total invested capital
+            const weight = partialDollarValue / totalInvested;
+            closedDollarValue += partialDollarValue;
+            // Reduce cost basis after close
+            costBasis *= 1 - partial.percent / 100;
+            // Use the effective entry price snapshot captured at the time of this partial close
+            const priceOpenWithSlippage = signal.position === "long"
+                ? partial.effectivePrice * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100)
+                : partial.effectivePrice * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
             const priceCloseWithSlippage = signal.position === "long"
                 ? partial.price * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100)
                 : partial.price * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
-            // Calculate PNL for this partial
             const partialPnl = signal.position === "long"
                 ? ((priceCloseWithSlippage - priceOpenWithSlippage) / priceOpenWithSlippage) * 100
                 : ((priceOpenWithSlippage - priceCloseWithSlippage) / priceOpenWithSlippage) * 100;
-            // Weight by percentage of position closed
-            totalWeightedPnl += (partialPercent / 100) * partialPnl;
-            // Close fee is proportional to the size of this partial and adjusted for slippage
-            totalFees += GLOBAL_CONFIG.CC_PERCENT_FEE * (partialPercent / 100) * (priceCloseWithSlippage / priceOpenWithSlippage);
-        }
-        // Calculate PNL for remaining position (if any)
-        // Compute totalClosed from _partial array
-        const totalClosed = signal._partial.reduce((sum, p) => sum + p.percent, 0);
-        if (totalClosed > 100) {
-            throw new Error(`Partial closes exceed 100%: ${totalClosed}% (signal id: ${signal.id})`);
-        }
-        const remainingPercent = 100 - totalClosed;
-        if (remainingPercent > 0) {
+            totalWeightedPnl += weight * partialPnl;
+            // Close fee proportional to real dollar weight
+            totalFees +=
+                GLOBAL_CONFIG.CC_PERCENT_FEE *
+                    weight *
+                    (priceCloseWithSlippage / priceOpenWithSlippage);
+        }
+        if (closedDollarValue > totalInvested + 0.001) {
+            throw new Error(`Partial closes dollar value (${closedDollarValue.toFixed(4)}) exceeds total invested (${totalInvested}) — signal id: ${signal.id}`);
+        }
+        // Remaining position
+        const remainingDollarValue = totalInvested - closedDollarValue;
+        const remainingWeight = remainingDollarValue / totalInvested;
+        if (remainingWeight > 0) {
+            // Use current effective price — reflects all DCA including post-partial entries
+            const remainingOpenWithSlippage = signal.position === "long"
+                ? priceOpen * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100)
+                : priceOpen * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
             const priceCloseWithSlippage = signal.position === "long"
                 ? priceClose * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100)
                 : priceClose * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
-            // Calculate PNL for remaining
             const remainingPnl = signal.position === "long"
-                ? ((priceCloseWithSlippage - priceOpenWithSlippage) / priceOpenWithSlippage) * 100
-                : ((priceOpenWithSlippage - priceCloseWithSlippage) / priceOpenWithSlippage) * 100;
-            // Weight by remaining percentage
-            totalWeightedPnl += (remainingPercent / 100) * remainingPnl;
-            // Close fee is proportional to the remaining size and adjusted for slippage
-            totalFees += GLOBAL_CONFIG.CC_PERCENT_FEE * (remainingPercent / 100) * (priceCloseWithSlippage / priceOpenWithSlippage);
+                ? ((priceCloseWithSlippage - remainingOpenWithSlippage) / remainingOpenWithSlippage) * 100
+                : ((remainingOpenWithSlippage - priceCloseWithSlippage) / remainingOpenWithSlippage) * 100;
+            totalWeightedPnl += remainingWeight * remainingPnl;
+            totalFees +=
+                GLOBAL_CONFIG.CC_PERCENT_FEE *
+                    remainingWeight *
+                    (priceCloseWithSlippage / remainingOpenWithSlippage);
         }
-        // Subtract total fees from weighted PNL
-        // totalFees = CC_PERCENT_FEE (open) + Σ CC_PERCENT_FEE × (partialPercent/100) × (closeWithSlip/openWithSlip)
         const pnlPercentage = totalWeightedPnl - totalFees;
         return {
             pnlPercentage,
@@ -3232,33 +3364,24 @@ const toProfitLossDto = (signal, priceClose) => {
     let priceOpenWithSlippage;
     let priceCloseWithSlippage;
     if (signal.position === "long") {
-        // LONG: покупаем дороже, продаем дешевле
         priceOpenWithSlippage = priceOpen * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
         priceCloseWithSlippage = priceClose * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
     }
     else {
-        // SHORT: продаем дешевле, покупаем дороже
         priceOpenWithSlippage = priceOpen * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
         priceCloseWithSlippage = priceClose * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
     }
-    // Открытие: комиссия от цены входа; закрытие: комиссия от фактической цены выхода (с учётом slippage)
-    const totalFee = GLOBAL_CONFIG.CC_PERCENT_FEE * (1 + priceCloseWithSlippage / priceOpenWithSlippage);
+    const totalFee = GLOBAL_CONFIG.CC_PERCENT_FEE *
+        (1 + priceCloseWithSlippage / priceOpenWithSlippage);
     let pnlPercentage;
     if (signal.position === "long") {
-        // LONG: прибыль при росте цены
         pnlPercentage =
-            ((priceCloseWithSlippage - priceOpenWithSlippage) /
-                priceOpenWithSlippage) *
-                100;
+            ((priceCloseWithSlippage - priceOpenWithSlippage) / priceOpenWithSlippage) * 100;
     }
     else {
-        // SHORT: прибыль при падении цены
         pnlPercentage =
-            ((priceOpenWithSlippage - priceCloseWithSlippage) /
-                priceOpenWithSlippage) *
-                100;
+            ((priceOpenWithSlippage - priceCloseWithSlippage) / priceOpenWithSlippage) * 100;
     }
-    // Вычитаем комиссии
     pnlPercentage -= totalFee;
     return {
         pnlPercentage,
@@ -3314,6 +3437,54 @@ const toPlainString = (content) => {
     return text.trim();
 };
 
+const COST_BASIS_PER_ENTRY$1 = 100;
+/**
+ * Returns the total closed state of a position using cost-basis replay.
+ *
+ * Correctly accounts for DCA entries added between partial closes via averageBuy().
+ * Simple percent summation (sum of _partial[i].percent) is INCORRECT when averageBuy()
+ * is called between partials — this function uses the same cost-basis replay as
+ * toProfitLossDto to compute the true dollar-weighted closed fraction.
+ *
+ * Cost-basis replay:
+ *   costBasis = 0
+ *   for each partial[i]:
+ *     costBasis += (entryCountAtClose[i] - entryCountAtClose[i-1]) × $100
+ *     closedDollar += (percent[i] / 100) × costBasis
+ *     costBasis ×= (1 - percent[i] / 100)
+ *   // then add entries added AFTER the last partial
+ *   costBasis += (currentEntryCount - lastPartialEntryCount) × $100
+ *
+ * @param signal - Signal row with _partial and _entry arrays
+ * @returns Object with totalClosedPercent (0–100+) and remainingCostBasis (dollar value still open)
+ */
+const getTotalClosed = (signal) => {
+    const partials = signal._partial ?? [];
+    const currentEntryCount = signal._entry?.length ?? 1;
+    const totalInvested = currentEntryCount * COST_BASIS_PER_ENTRY$1;
+    if (partials.length === 0) {
+        return {
+            totalClosedPercent: 0,
+            remainingCostBasis: totalInvested,
+        };
+    }
+    let costBasis = 0;
+    let closedDollarValue = 0;
+    for (let i = 0; i < partials.length; i++) {
+        const prevCount = i === 0 ? 0 : partials[i - 1].entryCountAtClose;
+        costBasis += (partials[i].entryCountAtClose - prevCount) * COST_BASIS_PER_ENTRY$1;
+        closedDollarValue += (partials[i].percent / 100) * costBasis;
+        costBasis *= 1 - partials[i].percent / 100;
+    }
+    // Add entries added AFTER the last partial (not yet accounted for in the loop)
+    const lastEntryCount = partials[partials.length - 1].entryCountAtClose;
+    costBasis += (currentEntryCount - lastEntryCount) * COST_BASIS_PER_ENTRY$1;
+    return {
+        totalClosedPercent: totalInvested > 0 ? (closedDollarValue / totalInvested) * 100 : 0,
+        remainingCostBasis: costBasis,
+    };
+};
+
 /**
  * Wraps a function to execute it outside of the current execution context if one exists.
  *
@@ -3356,6 +3527,19 @@ const beginTime = (run) => (...args) => {
     return fn();
 };
 
+/**
+ * Retrieves the current timestamp for debugging purposes.
+ * If an execution context is active (e.g., during a backtest), it returns the timestamp from the context to ensure consistency with the simulated time.
+ * Can be empty (undefined) if not called from strategy async context, as it's intended for debugging and not critical for logic.
+ * @return {number | undefined} The current timestamp in milliseconds from the execution context, or undefined if not available.
+ */
+const getDebugTimestamp = () => {
+    if (ExecutionContextService.hasContext()) {
+        return bt.executionContextService.context.when.getTime();
+    }
+    return undefined;
+};
+
 const INTERVAL_MINUTES$6 = {
     "1m": 1,
     "3m": 3,
@@ -3364,6 +3548,7 @@ const INTERVAL_MINUTES$6 = {
     "30m": 30,
     "1h": 60,
 };
+const COST_BASIS_PER_ENTRY = 100;
 /**
  * Mock value for scheduled signal pendingAt timestamp.
  * Used to indicate that the actual pendingAt will be set upon activation.
@@ -3965,7 +4150,7 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
                 scheduledAt: currentTime,
                 pendingAt: currentTime, // Для immediate signal оба времени одинаковые
                 _isScheduled: false,
-                _entry: [{ price: signal.priceOpen }],
+                _entry: [{ price: signal.priceOpen, debugTimestamp: currentTime }],
             };
             // Валидируем сигнал перед возвратом
             VALIDATE_SIGNAL_FN(signalRow, currentPrice, false);
@@ -3987,7 +4172,7 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
             scheduledAt: currentTime,
             pendingAt: SCHEDULED_SIGNAL_PENDING_MOCK, // Временно, обновится при активации
             _isScheduled: true,
-            _entry: [{ price: signal.priceOpen }],
+            _entry: [{ price: signal.priceOpen, debugTimestamp: currentTime }],
         };
         // Валидируем сигнал перед возвратом
         VALIDATE_SIGNAL_FN(scheduledSignalRow, currentPrice, true);
@@ -4005,7 +4190,7 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
         scheduledAt: currentTime,
         pendingAt: currentTime, // Для immediate signal оба времени одинаковые
         _isScheduled: false,
-        _entry: [{ price: currentPrice }],
+        _entry: [{ price: currentPrice, debugTimestamp: currentTime }],
     };
     // Валидируем сигнал перед возвратом
     VALIDATE_SIGNAL_FN(signalRow, currentPrice, false);
@@ -4079,37 +4264,39 @@ const PARTIAL_PROFIT_FN = (self, signal, percentToClose, currentPrice) => {
     // Initialize partial array if not present
     if (!signal._partial)
         signal._partial = [];
-    // Calculate current totals (computed values)
-    const tpClosed = signal._partial
-        .filter((p) => p.type === "profit")
-        .reduce((sum, p) => sum + p.percent, 0);
-    const slClosed = signal._partial
-        .filter((p) => p.type === "loss")
-        .reduce((sum, p) => sum + p.percent, 0);
-    const totalClosed = tpClosed + slClosed;
-    // Check if would exceed 100% total closed
-    const newTotalClosed = totalClosed + percentToClose;
-    if (newTotalClosed > 100) {
-        self.params.logger.warn("PARTIAL_PROFIT_FN: would exceed 100% closed, skipping", {
+    // Check if would exceed 100% total closed (dollar-basis, DCA-aware)
+    const { totalClosedPercent, remainingCostBasis } = getTotalClosed(signal);
+    const totalInvested = (signal._entry?.length ?? 1) * COST_BASIS_PER_ENTRY;
+    const newPartialDollar = (percentToClose / 100) * remainingCostBasis;
+    const newTotalClosedDollar = (totalClosedPercent / 100) * totalInvested + newPartialDollar;
+    if (newTotalClosedDollar > totalInvested) {
+        self.params.logger.warn("PARTIAL_PROFIT_FN: would exceed 100% closed (dollar basis), skipping", {
             signalId: signal.id,
-            currentTotalClosed: totalClosed,
+            totalClosedPercent,
+            remainingCostBasis,
             percentToClose,
-            newTotalClosed,
+            newPartialDollar,
+            totalInvested,
         });
         return false;
     }
+    // Capture effective entry price at the moment of partial close (for DCA-aware PNL)
+    const effectivePrice = getEffectivePriceOpen(signal);
+    const entryCountAtClose = signal._entry ? signal._entry.length : 1;
     // Add new partial close entry
     signal._partial.push({
         type: "profit",
         percent: percentToClose,
+        entryCountAtClose,
         price: currentPrice,
+        debugTimestamp: getDebugTimestamp(),
+        effectivePrice,
     });
     self.params.logger.info("PARTIAL_PROFIT_FN executed", {
         signalId: signal.id,
         percentClosed: percentToClose,
-        totalClosed: newTotalClosed,
+        totalClosedPercent: totalClosedPercent + (newPartialDollar / totalInvested) * 100,
         currentPrice,
-        tpClosed: tpClosed + percentToClose,
     });
     return true;
 };
@@ -4117,37 +4304,39 @@ const PARTIAL_LOSS_FN = (self, signal, percentToClose, currentPrice) => {
     // Initialize partial array if not present
     if (!signal._partial)
         signal._partial = [];
-    // Calculate current totals (computed values)
-    const tpClosed = signal._partial
-        .filter((p) => p.type === "profit")
-        .reduce((sum, p) => sum + p.percent, 0);
-    const slClosed = signal._partial
-        .filter((p) => p.type === "loss")
-        .reduce((sum, p) => sum + p.percent, 0);
-    const totalClosed = tpClosed + slClosed;
-    // Check if would exceed 100% total closed
-    const newTotalClosed = totalClosed + percentToClose;
-    if (newTotalClosed > 100) {
-        self.params.logger.warn("PARTIAL_LOSS_FN: would exceed 100% closed, skipping", {
+    // Check if would exceed 100% total closed (dollar-basis, DCA-aware)
+    const { totalClosedPercent, remainingCostBasis } = getTotalClosed(signal);
+    const totalInvested = (signal._entry?.length ?? 1) * COST_BASIS_PER_ENTRY;
+    const newPartialDollar = (percentToClose / 100) * remainingCostBasis;
+    const newTotalClosedDollar = (totalClosedPercent / 100) * totalInvested + newPartialDollar;
+    if (newTotalClosedDollar > totalInvested) {
+        self.params.logger.warn("PARTIAL_LOSS_FN: would exceed 100% closed (dollar basis), skipping", {
             signalId: signal.id,
-            currentTotalClosed: totalClosed,
+            totalClosedPercent,
+            remainingCostBasis,
             percentToClose,
-            newTotalClosed,
+            newPartialDollar,
+            totalInvested,
         });
         return false;
     }
+    // Capture effective entry price at the moment of partial close (for DCA-aware PNL)
+    const effectivePrice = getEffectivePriceOpen(signal);
+    const entryCountAtClose = signal._entry ? signal._entry.length : 1;
     // Add new partial close entry
     signal._partial.push({
         type: "loss",
         percent: percentToClose,
         price: currentPrice,
+        entryCountAtClose,
+        effectivePrice,
+        debugTimestamp: getDebugTimestamp(),
     });
     self.params.logger.warn("PARTIAL_LOSS_FN executed", {
         signalId: signal.id,
         percentClosed: percentToClose,
-        totalClosed: newTotalClosed,
+        totalClosedPercent: totalClosedPercent + (newPartialDollar / totalInvested) * 100,
         currentPrice,
-        slClosed: slClosed + percentToClose,
     });
     return true;
 };
@@ -4541,12 +4730,12 @@ const BREAKEVEN_FN = (self, signal, currentPrice) => {
 const AVERAGE_BUY_FN = (self, signal, currentPrice) => {
     // Ensure _entry is initialized (handles signals loaded from disk without _entry)
     if (!signal._entry || signal._entry.length === 0) {
-        signal._entry = [{ price: signal.priceOpen }];
+        signal._entry = [{ price: signal.priceOpen, debugTimestamp: getDebugTimestamp() }];
     }
     const lastEntry = signal._entry[signal._entry.length - 1];
     if (signal.position === "long") {
         // LONG: averaging down = currentPrice must be strictly lower than last entry
-        if (currentPrice >= lastEntry.price) {
+        if (!GLOBAL_CONFIG.CC_ENABLE_DCA_EVERYWHERE && currentPrice >= lastEntry.price) {
             self.params.logger.debug("AVERAGE_BUY_FN: rejected — currentPrice >= last entry (LONG)", {
                 signalId: signal.id,
                 position: signal.position,
@@ -4559,7 +4748,7 @@ const AVERAGE_BUY_FN = (self, signal, currentPrice) => {
     }
     else {
         // SHORT: averaging down = currentPrice must be strictly higher than last entry
-        if (currentPrice <= lastEntry.price) {
+        if (!GLOBAL_CONFIG.CC_ENABLE_DCA_EVERYWHERE && currentPrice <= lastEntry.price) {
             self.params.logger.debug("AVERAGE_BUY_FN: rejected — currentPrice <= last entry (SHORT)", {
                 signalId: signal.id,
                 position: signal.position,
@@ -4570,7 +4759,7 @@ const AVERAGE_BUY_FN = (self, signal, currentPrice) => {
             return false;
         }
     }
-    signal._entry.push({ price: currentPrice });
+    signal._entry.push({ price: currentPrice, debugTimestamp: getDebugTimestamp() });
     self.params.logger.info("AVERAGE_BUY_FN executed", {
         signalId: signal.id,
         position: signal.position,
@@ -6035,6 +6224,52 @@ class ClientStrategy {
         });
         return this._isStopped;
     }
+    /**
+     * Returns how much of the position is still held, as a percentage of totalInvested.
+     *
+     * Uses dollar-basis cost-basis replay (DCA-aware).
+     * 100% means nothing was closed yet. Decreases with each partial close.
+     *
+     * Example: 1 entry $100, partialProfit(30%) → returns 70
+     * Example: 2 entries $200, partialProfit(50%) → returns 50
+     *
+     * Returns 100 if no pending signal or no partial closes.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to held percentage (0–100)
+     */
+    async getTotalPercentClosed(symbol) {
+        this.params.logger.debug("ClientStrategy getTotalPercentClosed", { symbol });
+        if (!this._pendingSignal) {
+            return null;
+        }
+        const { totalClosedPercent } = getTotalClosed(this._pendingSignal);
+        return 100 - totalClosedPercent;
+    }
+    /**
+     * Returns how many dollars of cost basis are still held (not yet closed by partials).
+     *
+     * Equal to remainingCostBasis from getTotalClosed.
+     * Full position open: equals totalInvested (entries × $100).
+     * Decreases with each partial close, increases with each averageBuy().
+     *
+     * Example: 1 entry $100, no partials → returns 100
+     * Example: 1 entry $100, partialProfit(30%) → returns 70
+     * Example: 2 entries $200, partialProfit(50%) → returns 100
+     *
+     * Returns totalInvested if no pending signal or no partial closes.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to held cost basis in dollars
+     */
+    async getTotalCostClosed(symbol) {
+        this.params.logger.debug("ClientStrategy getTotalCostClosed", { symbol });
+        if (!this._pendingSignal) {
+            return null;
+        }
+        const { remainingCostBasis } = getTotalClosed(this._pendingSignal);
+        return remainingCostBasis;
+    }
     /**
      * Performs a single tick of strategy execution.
      *
@@ -7495,14 +7730,6 @@ class ClientStrategy {
         if (typeof currentPrice !== "number" || !isFinite(currentPrice) || currentPrice <= 0) {
             throw new Error(`ClientStrategy averageBuy: currentPrice must be a positive finite number, got ${currentPrice}`);
         }
-        // Reject if any partial closes have already been executed
-        if (this._pendingSignal._partial && this._pendingSignal._partial.length > 0) {
-            this.params.logger.debug("ClientStrategy averageBuy: rejected — partial closes already executed", {
-                symbol,
-                partialCount: this._pendingSignal._partial.length,
-            });
-            return false;
-        }
         // Execute averaging logic
         const result = AVERAGE_BUY_FN(this, this._pendingSignal, currentPrice);
         if (!result) {
@@ -8181,6 +8408,43 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             return await strategy.getPendingSignal(symbol);
         };
+        /**
+         * Returns the percentage of the position currently held (not closed).
+         * 100 = nothing has been closed (full position), 0 = fully closed.
+         * Correctly accounts for DCA entries between partial closes.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise<number> - held percentage (0–100)
+         */
+        this.getTotalPercentClosed = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getTotalPercentClosed", {
+                symbol,
+                context,
+                backtest,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return await strategy.getTotalPercentClosed(symbol);
+        };
+        /**
+         * Returns the cost basis in dollars of the position currently held (not closed).
+         * Correctly accounts for DCA entries between partial closes.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise<number> - held cost basis in dollars
+         */
+        this.getTotalCostClosed = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getTotalCostClosed", {
+                symbol,
+                context,
+                backtest,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return await strategy.getTotalCostClosed(symbol);
+        };
         /**
          * Retrieves the currently active scheduled signal for the strategy.
          * If no scheduled signal exists, returns null.
@@ -10371,7 +10635,7 @@ class ActionBase {
      * @example
      * ```typescript
      * pingScheduled(event: SchedulePingContract) {
-     *   const waitTime = Date.now() - event.data.timestampScheduled;
+     *   const waitTime = getTimestamp() - event.data.timestampScheduled;
      *   const waitMinutes = Math.floor(waitTime / 60000);
      *   console.log(`Scheduled signal waiting ${waitMinutes} minutes`);
      * }
@@ -10400,7 +10664,7 @@ class ActionBase {
      * @example
      * ```typescript
      * pingActive(event: ActivePingContract) {
-     *   const holdTime = Date.now() - event.data.pendingAt;
+     *   const holdTime = getTimestamp() - event.data.pendingAt;
      *   const holdMinutes = Math.floor(holdTime / 60000);
      *   console.log(`Active signal holding ${holdMinutes} minutes`);
      * }
@@ -11584,6 +11848,41 @@ class StrategyCoreService {
             await this.validate(context);
             return await this.strategyConnectionService.getPendingSignal(backtest, symbol, context);
         };
+        /**
+         * Returns the percentage of the position currently held (not closed).
+         * 100 = nothing has been closed (full position), 0 = fully closed.
+         * Correctly accounts for DCA entries between partial closes.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise<number> - held percentage (0–100)
+         */
+        this.getTotalPercentClosed = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getTotalPercentClosed", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getTotalPercentClosed(backtest, symbol, context);
+        };
+        /**
+         * Returns the cost basis in dollars of the position currently held (not closed).
+         * Correctly accounts for DCA entries between partial closes.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise<number> - held cost basis in dollars
+         */
+        this.getTotalCostClosed = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getTotalCostClosed", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getTotalCostClosed(backtest, symbol, context);
+        };
         /**
          * Retrieves the currently active scheduled signal for the symbol.
          * If no scheduled signal exists, returns null.
@@ -16102,6 +16401,20 @@ const COLUMN_CONFIG = {
  */
 const DEFAULT_COLUMNS = Object.freeze({ ...COLUMN_CONFIG });
 
+/**
+ * Retrieves the current timestamp based on the execution context.
+ * If an execution context is active (e.g., during a backtest), it returns the timestamp from the context to ensure consistency with the simulated time.
+ * If no execution context is active (e.g., during live operation), it returns the current real-world timestamp.
+ * This function helps maintain accurate timing for logs, metrics, and other time-sensitive operations across both live and backtest modes.
+ * @return {number} The current timestamp in milliseconds, either from the execution context or the real-world clock.
+ */
+const getContextTimestamp = () => {
+    if (ExecutionContextService.hasContext()) {
+        return bt.executionContextService.context.when.getTime();
+    }
+    return Date.now();
+};
+
 var _a$2, _b$2;
 const MARKDOWN_METHOD_NAME_ENABLE = "MarkdownUtils.enable";
 const MARKDOWN_METHOD_NAME_DISABLE = "MarkdownUtils.disable";
@@ -16235,7 +16548,7 @@ class MarkdownFileBase {
             markdownName: this.markdownName,
             data,
             ...searchFlags,
-            timestamp: Date.now(),
+            timestamp: getContextTimestamp(),
         }) + "\n";
         const status = await this[WRITE_SAFE_SYMBOL$2](line);
         if (status === functoolsKit.TIMEOUT_SYMBOL) {
@@ -16779,7 +17092,7 @@ let ReportStorage$7 = class ReportStorage {
      */
     async dump(strategyName, path = "./dump/backtest", columns = COLUMN_CONFIG.backtest_columns) {
         const markdown = await this.getReport(strategyName, columns);
-        const timestamp = Date.now();
+        const timestamp = getContextTimestamp();
         const filename = CREATE_FILE_NAME_FN$9(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
         await Markdown.writeData("backtest", markdown, {
             path,
@@ -17114,7 +17427,7 @@ let ReportStorage$6 = class ReportStorage {
      */
     addIdleEvent(currentPrice) {
         const newEvent = {
-            timestamp: Date.now(),
+            timestamp: getContextTimestamp(),
             action: "idle",
             currentPrice,
         };
@@ -17170,7 +17483,7 @@ let ReportStorage$6 = class ReportStorage {
      */
     addActiveEvent(data) {
         const newEvent = {
-            timestamp: Date.now(),
+            timestamp: getContextTimestamp(),
             action: "active",
             symbol: data.signal.symbol,
             signalId: data.signal.id,
@@ -17272,7 +17585,7 @@ let ReportStorage$6 = class ReportStorage {
      */
     addWaitingEvent(data) {
         const newEvent = {
-            timestamp: Date.now(),
+            timestamp: getContextTimestamp(),
             action: "waiting",
             symbol: data.signal.symbol,
             signalId: data.signal.id,
@@ -17466,7 +17779,7 @@ let ReportStorage$6 = class ReportStorage {
      */
     async dump(strategyName, path = "./dump/live", columns = COLUMN_CONFIG.live_columns) {
         const markdown = await this.getReport(strategyName, columns);
-        const timestamp = Date.now();
+        const timestamp = getContextTimestamp();
         const filename = CREATE_FILE_NAME_FN$8(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
         await Markdown.writeData("live", markdown, {
             path,
@@ -17998,7 +18311,7 @@ let ReportStorage$5 = class ReportStorage {
      */
     async dump(strategyName, path = "./dump/schedule", columns = COLUMN_CONFIG.schedule_columns) {
         const markdown = await this.getReport(strategyName, columns);
-        const timestamp = Date.now();
+        const timestamp = getContextTimestamp();
         const filename = CREATE_FILE_NAME_FN$7(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
         await Markdown.writeData("schedule", markdown, {
             path,
@@ -18463,7 +18776,7 @@ class PerformanceStorage {
      */
     async dump(strategyName, path = "./dump/performance", columns = COLUMN_CONFIG.performance_columns) {
         const markdown = await this.getReport(strategyName, columns);
-        const timestamp = Date.now();
+        const timestamp = getContextTimestamp();
         const filename = CREATE_FILE_NAME_FN$6(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
         await Markdown.writeData("performance", markdown, {
             path,
@@ -18914,7 +19227,7 @@ let ReportStorage$4 = class ReportStorage {
      */
     async dump(symbol, metric, context, path = "./dump/walker", strategyColumns = COLUMN_CONFIG.walker_strategy_columns, pnlColumns = COLUMN_CONFIG.walker_pnl_columns) {
         const markdown = await this.getReport(symbol, metric, context, strategyColumns, pnlColumns);
-        const timestamp = Date.now();
+        const timestamp = getContextTimestamp();
         const filename = CREATE_FILE_NAME_FN$5(this.walkerName, timestamp);
         await Markdown.writeData("walker", markdown, {
             path,
@@ -19468,7 +19781,7 @@ class HeatmapStorage {
      */
     async dump(strategyName, path = "./dump/heatmap", columns = COLUMN_CONFIG.heat_columns) {
         const markdown = await this.getReport(strategyName, columns);
-        const timestamp = Date.now();
+        const timestamp = getContextTimestamp();
         const filename = CREATE_FILE_NAME_FN$4(strategyName, this.exchangeName, this.frameName, timestamp);
         await Markdown.writeData("heat", markdown, {
             path,
@@ -21148,7 +21461,7 @@ let ReportStorage$3 = class ReportStorage {
      */
     async dump(symbol, strategyName, path = "./dump/partial", columns = COLUMN_CONFIG.partial_columns) {
         const markdown = await this.getReport(symbol, strategyName, columns);
-        const timestamp = Date.now();
+        const timestamp = getContextTimestamp();
         const filename = CREATE_FILE_NAME_FN$3(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
         await Markdown.writeData("partial", markdown, {
             path,
@@ -22241,7 +22554,7 @@ let ReportStorage$2 = class ReportStorage {
      */
     async dump(symbol, strategyName, path = "./dump/breakeven", columns = COLUMN_CONFIG.breakeven_columns) {
         const markdown = await this.getReport(symbol, strategyName, columns);
-        const timestamp = Date.now();
+        const timestamp = getContextTimestamp();
         const filename = CREATE_FILE_NAME_FN$2(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
         await Markdown.writeData("breakeven", markdown, {
             path,
@@ -22909,7 +23222,7 @@ let ReportStorage$1 = class ReportStorage {
      */
     async dump(symbol, strategyName, path = "./dump/risk", columns = COLUMN_CONFIG.risk_columns) {
         const markdown = await this.getReport(symbol, strategyName, columns);
-        const timestamp = Date.now();
+        const timestamp = getContextTimestamp();
         const filename = CREATE_FILE_NAME_FN$1(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
         await Markdown.writeData("risk", markdown, {
             path,
@@ -23393,7 +23706,7 @@ class ReportBase {
             reportName: this.reportName,
             data,
             ...searchFlags,
-            timestamp: Date.now(),
+            timestamp: getContextTimestamp(),
         }) + "\n";
         const status = await this[WRITE_SAFE_SYMBOL$1](line);
         if (status === functoolsKit.TIMEOUT_SYMBOL) {
@@ -23732,7 +24045,7 @@ class BacktestReportService {
         this.tick = async (data) => {
             this.loggerService.log(BACKTEST_REPORT_METHOD_NAME_TICK, { data });
             const baseEvent = {
-                timestamp: Date.now(),
+                timestamp: getContextTimestamp(),
                 action: data.action,
                 symbol: data.symbol,
                 strategyName: data.strategyName,
@@ -23911,7 +24224,7 @@ class LiveReportService {
         this.tick = async (data) => {
             this.loggerService.log(LIVE_REPORT_METHOD_NAME_TICK, { data });
             const baseEvent = {
-                timestamp: Date.now(),
+                timestamp: getContextTimestamp(),
                 action: data.action,
                 symbol: data.symbol,
                 strategyName: data.strategyName,
@@ -24434,7 +24747,7 @@ class WalkerReportService {
         this.tick = async (data) => {
             this.loggerService.log(WALKER_REPORT_METHOD_NAME_TICK, { data });
             await Report.writeData("walker", {
-                timestamp: Date.now(),
+                timestamp: getContextTimestamp(),
                 walkerName: data.walkerName,
                 symbol: data.symbol,
                 exchangeName: data.exchangeName,
@@ -24561,7 +24874,7 @@ class HeatReportService {
                 return;
             }
             await Report.writeData("heat", {
-                timestamp: Date.now(),
+                timestamp: getContextTimestamp(),
                 action: data.action,
                 symbol: data.symbol,
                 strategyName: data.strategyName,
@@ -25883,7 +26196,7 @@ class ReportStorage {
      */
     async dump(symbol, strategyName, path = "./dump/strategy", columns = COLUMN_CONFIG.strategy_columns) {
         const markdown = await this.getReport(symbol, strategyName, columns);
-        const timestamp = Date.now();
+        const timestamp = getContextTimestamp();
         const filename = CREATE_FILE_NAME_FN(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
         await Markdown.writeData("strategy", markdown, {
             path,
@@ -28199,6 +28512,7 @@ const GET_AVERAGE_PRICE_METHOD_NAME = "exchange.getAveragePrice";
 const FORMAT_PRICE_METHOD_NAME = "exchange.formatPrice";
 const FORMAT_QUANTITY_METHOD_NAME = "exchange.formatQuantity";
 const GET_DATE_METHOD_NAME = "exchange.getDate";
+const GET_TIMESTAMP_METHOD_NAME = "exchange.getTimestamp";
 const GET_MODE_METHOD_NAME = "exchange.getMode";
 const GET_SYMBOL_METHOD_NAME = "exchange.getSymbol";
 const GET_CONTEXT_METHOD_NAME = "exchange.getContext";
@@ -28364,6 +28678,26 @@ async function getDate() {
     const { when } = bt.executionContextService.context;
     return new Date(when.getTime());
 }
+/**
+ * Gets the current timestamp from execution context.
+ *
+ * In backtest mode: returns the current timeframe timestamp being processed
+ * In live mode: returns current real-time timestamp
+ *
+ * @returns Promise resolving to current execution context timestamp in milliseconds
+ * @example
+ * ```typescript
+ * const timestamp = await getTimestamp();
+ * console.log(timestamp); // 1700000000000
+ * ```
+ */
+async function getTimestamp() {
+    bt.loggerService.info(GET_TIMESTAMP_METHOD_NAME);
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getTimestamp requires an execution context");
+    }
+    return getContextTimestamp();
+}
 /**
  * Gets the current execution mode.
  *
@@ -28580,6 +28914,11 @@ const TRAILING_PROFIT_METHOD_NAME = "strategy.commitTrailingTake";
 const BREAKEVEN_METHOD_NAME = "strategy.commitBreakeven";
 const ACTIVATE_SCHEDULED_METHOD_NAME = "strategy.commitActivateScheduled";
 const AVERAGE_BUY_METHOD_NAME = "strategy.commitAverageBuy";
+const GET_TOTAL_PERCENT_CLOSED_METHOD_NAME = "strategy.getTotalPercentClosed";
+const GET_TOTAL_COST_CLOSED_METHOD_NAME = "strategy.getTotalCostClosed";
+const GET_PENDING_SIGNAL_METHOD_NAME = "strategy.getPendingSignal";
+const GET_SCHEDULED_SIGNAL_METHOD_NAME = "strategy.getScheduledSignal";
+const GET_BREAKEVEN_METHOD_NAME = "strategy.getBreakeven";
 /**
  * Cancels the scheduled signal without stopping the strategy.
  *
@@ -28971,6 +29310,173 @@ async function commitAverageBuy(symbol) {
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
     return await bt.strategyCoreService.averageBuy(isBacktest, symbol, currentPrice, { exchangeName, frameName, strategyName });
 }
+/**
+ * Returns the percentage of the position currently held (not closed).
+ * 100 = nothing has been closed (full position), 0 = fully closed.
+ * Correctly accounts for DCA entries between partial closes.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise<number> - held percentage (0–100)
+ *
+ * @example
+ * ```typescript
+ * import { getTotalPercentClosed } from "backtest-kit";
+ *
+ * const heldPct = await getTotalPercentClosed("BTCUSDT");
+ * console.log(`Holding ${heldPct}% of position`);
+ * ```
+ */
+async function getTotalPercentClosed(symbol) {
+    bt.loggerService.info(GET_TOTAL_PERCENT_CLOSED_METHOD_NAME, {
+        symbol,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getTotalPercentClosed requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getTotalPercentClosed requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    return await bt.strategyCoreService.getTotalPercentClosed(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
+/**
+ * Returns the cost basis in dollars of the position currently held (not closed).
+ * Correctly accounts for DCA entries between partial closes.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise<number> - held cost basis in dollars
+ *
+ * @example
+ * ```typescript
+ * import { getTotalCostClosed } from "backtest-kit";
+ *
+ * const heldCost = await getTotalCostClosed("BTCUSDT");
+ * console.log(`Holding $${heldCost} of position`);
+ * ```
+ */
+async function getTotalCostClosed(symbol) {
+    bt.loggerService.info(GET_TOTAL_COST_CLOSED_METHOD_NAME, {
+        symbol,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getTotalCostClosed requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getTotalCostClosed requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    return await bt.strategyCoreService.getTotalCostClosed(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
+/**
+ * Returns the currently active pending signal for the strategy.
+ * If no active signal exists, returns null.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to pending signal or null
+ *
+ * @example
+ * ```typescript
+ * import { getPendingSignal } from "backtest-kit";
+ *
+ * const pending = await getPendingSignal("BTCUSDT");
+ * if (pending) {
+ *   console.log("Active signal:", pending.id);
+ * }
+ * ```
+ */
+async function getPendingSignal(symbol) {
+    bt.loggerService.info(GET_PENDING_SIGNAL_METHOD_NAME, {
+        symbol,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getPendingSignal requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getPendingSignal requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    return await bt.strategyCoreService.getPendingSignal(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
+/**
+ * Returns the currently active scheduled signal for the strategy.
+ * If no scheduled signal exists, returns null.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to scheduled signal or null
+ *
+ * @example
+ * ```typescript
+ * import { getScheduledSignal } from "backtest-kit";
+ *
+ * const scheduled = await getScheduledSignal("BTCUSDT");
+ * if (scheduled) {
+ *   console.log("Scheduled signal:", scheduled.id);
+ * }
+ * ```
+ */
+async function getScheduledSignal(symbol) {
+    bt.loggerService.info(GET_SCHEDULED_SIGNAL_METHOD_NAME, {
+        symbol,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getScheduledSignal requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getScheduledSignal requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    return await bt.strategyCoreService.getScheduledSignal(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
+/**
+ * Checks if breakeven threshold has been reached for the current pending signal.
+ *
+ * Returns true if price has moved far enough in profit direction to cover
+ * transaction costs. Threshold is calculated as: (CC_PERCENT_SLIPPAGE + CC_PERCENT_FEE) * 2
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @param currentPrice - Current market price to check against threshold
+ * @returns Promise<boolean> - true if breakeven threshold reached, false otherwise
+ *
+ * @example
+ * ```typescript
+ * import { getBreakeven, getAveragePrice } from "backtest-kit";
+ *
+ * const price = await getAveragePrice("BTCUSDT");
+ * const canBreakeven = await getBreakeven("BTCUSDT", price);
+ * if (canBreakeven) {
+ *   console.log("Breakeven available");
+ * }
+ * ```
+ */
+async function getBreakeven(symbol, currentPrice) {
+    bt.loggerService.info(GET_BREAKEVEN_METHOD_NAME, {
+        symbol,
+        currentPrice,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getBreakeven requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getBreakeven requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    return await bt.strategyCoreService.getBreakeven(isBacktest, symbol, currentPrice, { exchangeName, frameName, strategyName });
+}
 
 const STOP_STRATEGY_METHOD_NAME = "control.stopStrategy";
 /**
@@ -30158,6 +30664,8 @@ const BACKTEST_METHOD_NAME_DUMP = "BacktestUtils.dump";
 const BACKTEST_METHOD_NAME_TASK = "BacktestUtils.task";
 const BACKTEST_METHOD_NAME_GET_STATUS = "BacktestUtils.getStatus";
 const BACKTEST_METHOD_NAME_GET_PENDING_SIGNAL = "BacktestUtils.getPendingSignal";
+const BACKTEST_METHOD_NAME_GET_TOTAL_PERCENT_CLOSED = "BacktestUtils.getTotalPercentClosed";
+const BACKTEST_METHOD_NAME_GET_TOTAL_COST_CLOSED = "BacktestUtils.getTotalCostClosed";
 const BACKTEST_METHOD_NAME_GET_SCHEDULED_SIGNAL = "BacktestUtils.getScheduledSignal";
 const BACKTEST_METHOD_NAME_GET_BREAKEVEN = "BacktestUtils.getBreakeven";
 const BACKTEST_METHOD_NAME_BREAKEVEN = "Backtest.commitBreakeven";
@@ -30559,6 +31067,71 @@ class BacktestUtils {
             }
             return await bt.strategyCoreService.getPendingSignal(true, symbol, context);
         };
+        /**
+         * Returns the percentage of the position currently held (not closed).
+         * 100 = nothing has been closed (full position), 0 = fully closed.
+         * Correctly accounts for DCA entries between partial closes.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Context with strategyName, exchangeName, frameName
+         * @returns Promise<number> - held percentage (0–100)
+         *
+         * @example
+         * ```typescript
+         * const heldPct = await Backtest.getTotalPercentClosed("BTCUSDT", { strategyName, exchangeName, frameName });
+         * console.log(`Holding ${heldPct}% of position`);
+         * ```
+         */
+        this.getTotalPercentClosed = async (symbol, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_GET_TOTAL_PERCENT_CLOSED, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_TOTAL_PERCENT_CLOSED);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_TOTAL_PERCENT_CLOSED);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_TOTAL_PERCENT_CLOSED);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_TOTAL_PERCENT_CLOSED));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_TOTAL_PERCENT_CLOSED));
+            }
+            return await bt.strategyCoreService.getTotalPercentClosed(true, symbol, context);
+        };
+        /**
+         * Returns the cost basis in dollars of the position currently held (not closed).
+         * Correctly accounts for DCA entries between partial closes.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Context with strategyName, exchangeName, frameName
+         * @returns Promise<number> - held cost basis in dollars
+         *
+         * @example
+         * ```typescript
+         * const heldCost = await Backtest.getTotalCostClosed("BTCUSDT", { strategyName, exchangeName, frameName });
+         * console.log(`Holding $${heldCost} of position`);
+         * ```
+         */
+        this.getTotalCostClosed = async (symbol, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_GET_TOTAL_COST_CLOSED, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_TOTAL_COST_CLOSED);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_TOTAL_COST_CLOSED);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_TOTAL_COST_CLOSED);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_TOTAL_COST_CLOSED));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_TOTAL_COST_CLOSED));
+            }
+            return await bt.strategyCoreService.getTotalCostClosed(true, symbol, context);
+        };
         /**
          * Retrieves the currently active scheduled signal for the strategy.
          * If no scheduled signal exists, returns null.
@@ -31274,6 +31847,8 @@ const LIVE_METHOD_NAME_DUMP = "LiveUtils.dump";
 const LIVE_METHOD_NAME_TASK = "LiveUtils.task";
 const LIVE_METHOD_NAME_GET_STATUS = "LiveUtils.getStatus";
 const LIVE_METHOD_NAME_GET_PENDING_SIGNAL = "LiveUtils.getPendingSignal";
+const LIVE_METHOD_NAME_GET_TOTAL_PERCENT_CLOSED = "LiveUtils.getTotalPercentClosed";
+const LIVE_METHOD_NAME_GET_TOTAL_COST_CLOSED = "LiveUtils.getTotalCostClosed";
 const LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL = "LiveUtils.getScheduledSignal";
 const LIVE_METHOD_NAME_GET_BREAKEVEN = "LiveUtils.getBreakeven";
 const LIVE_METHOD_NAME_BREAKEVEN = "Live.commitBreakeven";
@@ -31644,6 +32219,73 @@ class LiveUtils {
                 frameName: "",
             });
         };
+        /**
+         * Returns the percentage of the position currently held (not closed).
+         * 100 = nothing has been closed (full position), 0 = fully closed.
+         * Correctly accounts for DCA entries between partial closes.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Context with strategyName and exchangeName
+         * @returns Promise<number> - held percentage (0–100)
+         *
+         * @example
+         * ```typescript
+         * const heldPct = await Live.getTotalPercentClosed("BTCUSDT", { strategyName, exchangeName });
+         * console.log(`Holding ${heldPct}% of position`);
+         * ```
+         */
+        this.getTotalPercentClosed = async (symbol, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_TOTAL_PERCENT_CLOSED, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_TOTAL_PERCENT_CLOSED);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_TOTAL_PERCENT_CLOSED);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_TOTAL_PERCENT_CLOSED);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_TOTAL_PERCENT_CLOSED));
+                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_TOTAL_PERCENT_CLOSED));
+            }
+            return await bt.strategyCoreService.getTotalPercentClosed(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
+        /**
+         * Returns the cost basis in dollars of the position currently held (not closed).
+         * Correctly accounts for DCA entries between partial closes.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Context with strategyName and exchangeName
+         * @returns Promise<number> - held cost basis in dollars
+         *
+         * @example
+         * ```typescript
+         * const heldCost = await Live.getTotalCostClosed("BTCUSDT", { strategyName, exchangeName });
+         * console.log(`Holding $${heldCost} of position`);
+         * ```
+         */
+        this.getTotalCostClosed = async (symbol, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_TOTAL_COST_CLOSED, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_TOTAL_COST_CLOSED);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_TOTAL_COST_CLOSED);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_TOTAL_COST_CLOSED);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_TOTAL_COST_CLOSED));
+                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_TOTAL_COST_CLOSED));
+            }
+            return await bt.strategyCoreService.getTotalCostClosed(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
         /**
          * Retrieves the currently active scheduled signal for the strategy.
          * If no scheduled signal exists, returns null.
@@ -32561,7 +33203,6 @@ const ADD_ACTION_METHOD_NAME = "add.addActionSchema";
  *     priceTakeProfit: 51000,
  *     priceStopLoss: 49000,
  *     minuteEstimatedTime: 60,
- *     timestamp: Date.now(),
  *   }),
  *   callbacks: {
  *     onOpen: (symbol, signal, currentPrice, backtest) => console.log("Signal opened"),
@@ -33488,8 +34129,8 @@ const WAIT_FOR_INIT_SYMBOL = Symbol("wait-for-init");
 const WRITE_SAFE_SYMBOL = Symbol("write-safe");
 /**
  * Backtest execution time retrieval function.
- * Returns the 'when' timestamp from the execution context if available, otherwise returns the current time.
- * This allows log entries to be timestamped according to the backtest timeline rather than real-world time, improving log relevance and user experience during backtest analysis.
+ * Returns the 'when' priority from the execution context if available, otherwise returns the current time.
+ * This allows log entries to be priorityed according to the backtest timeline rather than real-world time, improving log relevance and user experience during backtest analysis.
  */
 const GET_DATE_FN = () => {
     if (ExecutionContextService.hasContext()) {
@@ -33511,7 +34152,7 @@ const GET_METHOD_CONTEXT_FN = () => {
 /**
  * Execution context retrieval function.
  * Returns the current execution context from ExecutionContextService if available, otherwise returns null.
- * This allows log entries to include contextual information about the symbol, timestamp, and backtest mode associated with the log event, providing additional insights into the execution environment when analyzing logs.
+ * This allows log entries to include contextual information about the symbol, priority, and backtest mode associated with the log event, providing additional insights into the execution environment when analyzing logs.
  */
 const GET_EXECUTION_CONTEXT_FN = () => {
     if (ExecutionContextService.hasContext()) {
@@ -33541,7 +34182,7 @@ class LogPersistUtils {
         this.waitForInit = functoolsKit.singleshot(async () => {
             bt.loggerService.info(LOG_PERSIST_METHOD_NAME_WAIT_FOR_INIT);
             const list = await PersistLogAdapter.readLogData();
-            list.sort((a, b) => a.timestamp - b.timestamp);
+            list.sort((a, b) => a.priority - b.priority);
             this._entries = list.slice(-GLOBAL_CONFIG.CC_MAX_LOG_LINES);
         });
         /**
@@ -33557,7 +34198,8 @@ class LogPersistUtils {
             this._entries.push({
                 id: functoolsKit.randomString(),
                 type: "log",
-                timestamp: Date.now(),
+                priority: Date.now(),
+                timestamp: getContextTimestamp(),
                 createdAt: date.toISOString(),
                 methodContext: GET_METHOD_CONTEXT_FN(),
                 executionContext: GET_EXECUTION_CONTEXT_FN(),
@@ -33580,7 +34222,8 @@ class LogPersistUtils {
             this._entries.push({
                 id: functoolsKit.randomString(),
                 type: "debug",
-                timestamp: Date.now(),
+                priority: Date.now(),
+                timestamp: getContextTimestamp(),
                 createdAt: date.toISOString(),
                 methodContext: GET_METHOD_CONTEXT_FN(),
                 executionContext: GET_EXECUTION_CONTEXT_FN(),
@@ -33603,7 +34246,8 @@ class LogPersistUtils {
             this._entries.push({
                 id: functoolsKit.randomString(),
                 type: "info",
-                timestamp: Date.now(),
+                priority: Date.now(),
+                timestamp: getContextTimestamp(),
                 createdAt: date.toISOString(),
                 methodContext: GET_METHOD_CONTEXT_FN(),
                 executionContext: GET_EXECUTION_CONTEXT_FN(),
@@ -33626,7 +34270,8 @@ class LogPersistUtils {
             this._entries.push({
                 id: functoolsKit.randomString(),
                 type: "warn",
-                timestamp: Date.now(),
+                priority: Date.now(),
+                timestamp: getContextTimestamp(),
                 createdAt: date.toISOString(),
                 methodContext: GET_METHOD_CONTEXT_FN(),
                 executionContext: GET_EXECUTION_CONTEXT_FN(),
@@ -33682,7 +34327,8 @@ class LogMemoryUtils {
             this._entries.push({
                 id: functoolsKit.randomString(),
                 type: "log",
-                timestamp: Date.now(),
+                priority: Date.now(),
+                timestamp: getContextTimestamp(),
                 createdAt: date.toISOString(),
                 methodContext: GET_METHOD_CONTEXT_FN(),
                 executionContext: GET_EXECUTION_CONTEXT_FN(),
@@ -33703,7 +34349,8 @@ class LogMemoryUtils {
             this._entries.push({
                 id: functoolsKit.randomString(),
                 type: "debug",
-                timestamp: Date.now(),
+                priority: Date.now(),
+                timestamp: getContextTimestamp(),
                 createdAt: date.toISOString(),
                 methodContext: GET_METHOD_CONTEXT_FN(),
                 executionContext: GET_EXECUTION_CONTEXT_FN(),
@@ -33724,7 +34371,8 @@ class LogMemoryUtils {
             this._entries.push({
                 id: functoolsKit.randomString(),
                 type: "info",
-                timestamp: Date.now(),
+                priority: Date.now(),
+                timestamp: getContextTimestamp(),
                 createdAt: date.toISOString(),
                 methodContext: GET_METHOD_CONTEXT_FN(),
                 executionContext: GET_EXECUTION_CONTEXT_FN(),
@@ -33745,7 +34393,8 @@ class LogMemoryUtils {
             this._entries.push({
                 id: functoolsKit.randomString(),
                 type: "warn",
-                timestamp: Date.now(),
+                priority: Date.now(),
+                timestamp: getContextTimestamp(),
                 createdAt: date.toISOString(),
                 methodContext: GET_METHOD_CONTEXT_FN(),
                 executionContext: GET_EXECUTION_CONTEXT_FN(),
@@ -33859,7 +34508,8 @@ class LogJsonlUtils {
             await this._append({
                 id: functoolsKit.randomString(),
                 type: "log",
-                timestamp: Date.now(),
+                priority: Date.now(),
+                timestamp: getContextTimestamp(),
                 createdAt: date.toISOString(),
                 methodContext: GET_METHOD_CONTEXT_FN(),
                 executionContext: GET_EXECUTION_CONTEXT_FN(),
@@ -33878,7 +34528,8 @@ class LogJsonlUtils {
             await this._append({
                 id: functoolsKit.randomString(),
                 type: "debug",
-                timestamp: Date.now(),
+                priority: Date.now(),
+                timestamp: getContextTimestamp(),
                 createdAt: date.toISOString(),
                 methodContext: GET_METHOD_CONTEXT_FN(),
                 executionContext: GET_EXECUTION_CONTEXT_FN(),
@@ -33897,7 +34548,8 @@ class LogJsonlUtils {
             await this._append({
                 id: functoolsKit.randomString(),
                 type: "info",
-                timestamp: Date.now(),
+                priority: Date.now(),
+                timestamp: getContextTimestamp(),
                 createdAt: date.toISOString(),
                 methodContext: GET_METHOD_CONTEXT_FN(),
                 executionContext: GET_EXECUTION_CONTEXT_FN(),
@@ -33916,7 +34568,8 @@ class LogJsonlUtils {
             await this._append({
                 id: functoolsKit.randomString(),
                 type: "warn",
-                timestamp: Date.now(),
+                priority: Date.now(),
+                timestamp: getContextTimestamp(),
                 createdAt: date.toISOString(),
                 methodContext: GET_METHOD_CONTEXT_FN(),
                 executionContext: GET_EXECUTION_CONTEXT_FN(),
@@ -38343,6 +38996,8 @@ const CACHE_METHOD_NAME_CLEAR = "CacheInstance.clear";
 const CACHE_METHOD_NAME_RUN = "CacheInstance.run";
 const CACHE_METHOD_NAME_GC = "CacheInstance.gc";
 const CACHE_METHOD_NAME_FN = "CacheUtils.fn";
+const CACHE_METHOD_NAME_FILE = "CacheUtils.file";
+const CACHE_FILE_INSTANCE_METHOD_NAME_RUN = "CacheFileInstance.run";
 const MS_PER_MINUTE$1 = 60000;
 const INTERVAL_MINUTES$1 = {
     "1m": 1,
@@ -38564,6 +39219,95 @@ class CacheInstance {
         };
     }
 }
+/**
+ * Instance class for caching async function results in persistent file storage.
+ *
+ * Provides automatic cache invalidation based on candle intervals.
+ * Cache key = `${alignedTimestamp}_${symbol}` (bucket) + dynamic key (file within bucket).
+ * On cache hit reads from disk, on miss calls the function and writes the result.
+ *
+ * @template T - Async function type to cache
+ * @template K - Dynamic key type
+ *
+ * @example
+ * ```typescript
+ * const instance = new CacheFileInstance(fetchFromApi, "1h");
+ * const result = await instance.run("BTCUSDT", extraArg);
+ * ```
+ */
+class CacheFileInstance {
+    /**
+     * Allocates a new unique index. Called once in the constructor to give each
+     * CacheFileInstance its own namespace in the persistent key space.
+     */
+    static createIndex() {
+        return CacheFileInstance._indexCounter++;
+    }
+    /**
+     * Creates a new CacheFileInstance.
+     *
+     * @param fn - Async function to cache
+     * @param interval - Candle interval for cache invalidation
+     * @param name - Human-readable bucket name used as the directory key (replaces symbol in bucket path)
+     * @param key - Dynamic key generator; receives all args, must return a string.
+     *              Default: `([symbol, alignMs]) => \`${symbol}_${alignMs}\``
+     */
+    constructor(fn, interval, name, key = ([symbol, alignMs]) => `${symbol}_${alignMs}`) {
+        this.fn = fn;
+        this.interval = interval;
+        this.name = name;
+        this.key = key;
+        /**
+         * Execute async function with persistent file caching.
+         *
+         * Algorithm:
+         * 1. Build bucket = `${name}_${interval}_${index}` — fixed per instance, used as directory name
+         * 2. Align execution context `when` to interval boundary → `alignedTs`
+         * 3. Build entity key from the key generator (receives `[symbol, alignedTs, ...rest]`)
+         * 4. Try to read from PersistMeasureAdapter using (bucket, entityKey)
+         * 5. On hit — return cached value
+         * 6. On miss — call fn, write result to disk, return result
+         *
+         * Cache invalidation happens through the entity key: the default key embeds `alignedTs`,
+         * so each new candle interval produces a new file name while the bucket directory stays the same.
+         *
+         * Requires active execution context (symbol, when) and method context.
+         *
+         * @param args - Arguments forwarded to the wrapped function
+         * @returns Cached or freshly computed result
+         */
+        this.run = async (...args) => {
+            bt.loggerService.debug(CACHE_FILE_INSTANCE_METHOD_NAME_RUN, { args });
+            const step = INTERVAL_MINUTES$1[this.interval];
+            {
+                if (!MethodContextService.hasContext()) {
+                    throw new Error("CacheFileInstance run requires method context");
+                }
+                if (!ExecutionContextService.hasContext()) {
+                    throw new Error("CacheFileInstance run requires execution context");
+                }
+                if (!step) {
+                    throw new Error(`CacheFileInstance unknown cache ttl interval=${this.interval}`);
+                }
+            }
+            const [symbol, ...rest] = args;
+            const { when } = bt.executionContextService.context;
+            const alignedTs = align(when.getTime(), this.interval);
+            const bucket = `${this.name}_${this.interval}_${this.index}`;
+            const entityKey = this.key([symbol, alignedTs, ...rest]);
+            const cached = await PersistMeasureAdapter.readMeasureData(bucket, entityKey);
+            if (cached !== null) {
+                return cached;
+            }
+            const result = await this.fn.call(null, ...args);
+            await PersistMeasureAdapter.writeMeasureData(result, bucket, entityKey);
+            return result;
+        };
+        this.index = CacheFileInstance.createIndex();
+    }
+}
+/** Global counter — incremented once per CacheFileInstance construction */
+CacheFileInstance._indexCounter = 0;
 /**
  * Utility class for function caching with timeframe-based invalidation.
  *
@@ -38585,7 +39329,12 @@ class CacheUtils {
          * Memoized function to get or create CacheInstance for a function.
          * Each function gets its own isolated cache instance.
          */
-        this._getInstance = functoolsKit.memoize(([run]) => run, (run, interval, key) => new CacheInstance(run, interval, key));
+        this._getFnInstance = functoolsKit.memoize(([run]) => run, (run, interval, key) => new CacheInstance(run, interval, key));
+        /**
+         * Memoized function to get or create CacheFileInstance for an async function.
+         * Each function gets its own isolated file-cache instance.
+         */
+        this._getFileInstance = functoolsKit.memoize(([run]) => run, (run, interval, name, key) => new CacheFileInstance(run, interval, name, key));
         /**
          * Wrap a function with caching based on timeframe intervals.
          *
@@ -38624,11 +39373,57 @@ class CacheUtils {
                 context,
             });
             const wrappedFn = (...args) => {
-                const instance = this._getInstance(run, context.interval, context.key);
+                const instance = this._getFnInstance(run, context.interval, context.key);
                 return instance.run(...args).value;
             };
             return wrappedFn;
         };
+        /**
+         * Wrap an async function with persistent file-based caching.
+         *
+         * Returns a wrapped version of the function that reads from disk on cache hit
+         * and writes the result to disk on cache miss. Files are stored under
+         * `./dump/data/measure/{name}_{interval}_{index}/`.
+         *
+         * The `run` function reference is used as the memoization key for the underlying
+         * `CacheFileInstance`, so each unique function reference gets its own isolated instance.
+         * Pass the same function reference each time to reuse the same cache.
+         *
+         * @template T - Async function type to cache
+         * @param run - Async function to wrap with file caching
+         * @param context.interval - Candle interval for cache invalidation
+         * @param context.name - Human-readable bucket name; becomes the directory prefix
+         * @param context.key - Optional entity key generator. Receives `[symbol, alignMs, ...rest]`
+         *                      where `alignMs` is the timestamp aligned to `interval`.
+         *                      Default: `([symbol, alignMs]) => \`${symbol}_${alignMs}\``
+         * @returns Wrapped async function with automatic persistent caching
+         *
+         * @example
+         * ```typescript
+         * const fetchData = async (symbol: string, period: number) => {
+         *   return await externalApi.fetch(symbol, period);
+         * };
+         *
+         * // Default key — one cache file per symbol per aligned candle
+         * const cachedFetch = Cache.file(fetchData, { interval: "1h", name: "fetchData" });
+         *
+         * // Custom key — one cache file per symbol + period combination
+         * const cachedFetch = Cache.file(fetchData, {
+         *   interval: "1h",
+         *   name: "fetchData",
+         *   key: ([symbol, alignMs, period]) => `${symbol}_${alignMs}_${period}`,
+         * });
+         * const result = await cachedFetch("BTCUSDT", 14);
+         * ```
+         */
+        this.file = (run, context) => {
+            bt.loggerService.info(CACHE_METHOD_NAME_FILE, { context });
+            const wrappedFn = (...args) => {
+                const instance = this._getFileInstance(run, context.interval, context.name, context.key);
+                return instance.run(...args);
+            };
+            return wrappedFn;
+        };
         /**
          * Flush (remove) cached CacheInstance for a specific function or all functions.
          *
@@ -38662,7 +39457,7 @@ class CacheUtils {
             bt.loggerService.info(CACHE_METHOD_NAME_FLUSH, {
                 run,
             });
-            this._getInstance.clear(run);
+            this._getFnInstance.clear(run);
         };
         /**
          * Clear cached value for current execution context of a specific function.
@@ -38705,7 +39500,7 @@ class CacheUtils {
                 console.warn(`${CACHE_METHOD_NAME_CLEAR} called without execution context, skipping clear`);
                 return;
             }
-            this._getInstance.get(run).clear();
+            this._getFnInstance.get(run).clear();
         };
         /**
          * Garbage collect expired cache entries for a specific function.
@@ -38737,7 +39532,7 @@ class CacheUtils {
                 console.warn(`${CACHE_METHOD_NAME_GC} called without execution context, skipping garbage collection`);
                 return;
             }
-            return this._getInstance.get(run).gc();
+            return this._getFnInstance.get(run).gc();
         };
     }
 }
@@ -39330,6 +40125,7 @@ exports.PersistBase = PersistBase;
 exports.PersistBreakevenAdapter = PersistBreakevenAdapter;
 exports.PersistCandleAdapter = PersistCandleAdapter;
 exports.PersistLogAdapter = PersistLogAdapter;
+exports.PersistMeasureAdapter = PersistMeasureAdapter;
 exports.PersistNotificationAdapter = PersistNotificationAdapter;
 exports.PersistPartialAdapter = PersistPartialAdapter;
 exports.PersistRiskAdapter = PersistRiskAdapter;
@@ -39373,6 +40169,7 @@ exports.getActionSchema = getActionSchema;
 exports.getAggregatedTrades = getAggregatedTrades;
 exports.getAveragePrice = getAveragePrice;
 exports.getBacktestTimeframe = getBacktestTimeframe;
+exports.getBreakeven = getBreakeven;
 exports.getCandles = getCandles;
 exports.getColumns = getColumns;
 exports.getConfig = getConfig;
@@ -39380,16 +40177,23 @@ exports.getContext = getContext;
 exports.getDate = getDate;
 exports.getDefaultColumns = getDefaultColumns;
 exports.getDefaultConfig = getDefaultConfig;
+exports.getEffectivePriceOpen = getEffectivePriceOpen;
 exports.getExchangeSchema = getExchangeSchema;
 exports.getFrameSchema = getFrameSchema;
 exports.getMode = getMode;
 exports.getNextCandles = getNextCandles;
 exports.getOrderBook = getOrderBook;
+exports.getPendingSignal = getPendingSignal;
 exports.getRawCandles = getRawCandles;
 exports.getRiskSchema = getRiskSchema;
+exports.getScheduledSignal = getScheduledSignal;
 exports.getSizingSchema = getSizingSchema;
 exports.getStrategySchema = getStrategySchema;
 exports.getSymbol = getSymbol;
+exports.getTimestamp = getTimestamp;
+exports.getTotalClosed = getTotalClosed;
+exports.getTotalCostClosed = getTotalCostClosed;
+exports.getTotalPercentClosed = getTotalPercentClosed;
 exports.getWalkerSchema = getWalkerSchema;
 exports.hasTradeContext = hasTradeContext;
 exports.lib = backtest;
@@ -39449,6 +40253,7 @@ exports.setConfig = setConfig;
 exports.setLogger = setLogger;
 exports.shutdown = shutdown;
 exports.stopStrategy = stopStrategy;
+exports.toProfitLossDto = toProfitLossDto;
 exports.validate = validate;
 exports.waitForCandle = waitForCandle;
 exports.warmCandles = warmCandles;