backtest-kit 3.7.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 });
 
@@ -3194,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);
@@ -3271,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,
@@ -3323,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,
@@ -3405,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.
  *
@@ -3447,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,
@@ -3455,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.
@@ -4056,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);
@@ -4078,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);
@@ -4096,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);
@@ -4170,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;
 };
@@ -4208,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;
 };
@@ -4632,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,
@@ -4650,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,
@@ -4661,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,
@@ -6126,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.
      *
@@ -7586,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) {
@@ -8272,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.
@@ -11675,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.
@@ -28706,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.
  *
@@ -29097,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";
 /**
@@ -30284,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";
@@ -30685,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.
@@ -31400,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";
@@ -31770,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.
@@ -39653,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;
@@ -39660,17 +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;
@@ -39730,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;