backtest-kit 3.7.0 → 3.7.1

package/build/index.mjs

@@ -443,6 +443,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 });
 
@@ -3174,75 +3182,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);
@@ -3251,47 +3274,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,
@@ -3303,33 +3344,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,
@@ -3385,6 +3417,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.
  *
@@ -3427,6 +3507,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,
@@ -3435,6 +3528,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.
@@ -4036,7 +4130,7 @@ const GET_SIGNAL_FN = 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);
@@ -4058,7 +4152,7 @@ const GET_SIGNAL_FN = 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);
@@ -4076,7 +4170,7 @@ const GET_SIGNAL_FN = 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);
@@ -4150,37 +4244,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;
 };
@@ -4188,37 +4284,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;
 };
@@ -4612,12 +4710,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,
@@ -4630,7 +4728,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,
@@ -4641,7 +4739,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,
@@ -6106,6 +6204,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.
      *
@@ -7566,14 +7710,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) {
@@ -8252,6 +8388,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.
@@ -11655,6 +11828,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.
@@ -28686,6 +28894,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.
  *
@@ -29077,6 +29290,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";
 /**
@@ -30264,6 +30644,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";
@@ -30665,6 +31047,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.
@@ -31380,6 +31827,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";
@@ -31750,6 +32199,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.
@@ -39566,4 +40082,4 @@ const set = (object, path, value) => {
     }
 };
 
-export { ActionBase, Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Log, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistLogAdapter, PersistMeasureAdapter, PersistNotificationAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Storage, StorageBacktest, StorageLive, Strategy, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialProfit, commitTrailingStop, commitTrailingTake, dumpMessages, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getRawCandles, getRiskSchema, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getWalkerSchema, hasTradeContext, backtest as lib, listExchangeSchema, listFrameSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, roundTicks, set, setColumns, setConfig, setLogger, shutdown, stopStrategy, validate, waitForCandle, warmCandles };
+export { ActionBase, Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Log, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistLogAdapter, PersistMeasureAdapter, PersistNotificationAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Storage, StorageBacktest, StorageLive, Strategy, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialProfit, commitTrailingStop, commitTrailingTake, dumpMessages, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getPendingSignal, getRawCandles, getRiskSchema, getScheduledSignal, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasTradeContext, backtest as lib, listExchangeSchema, listFrameSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, roundTicks, set, setColumns, setConfig, setLogger, shutdown, stopStrategy, toProfitLossDto, validate, waitForCandle, warmCandles };