backtest-kit 3.7.0 → 3.8.0

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
+                ? partial.currentPrice * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100)
+                : partial.currentPrice * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
             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.
@@ -3710,8 +3804,8 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, timestamp) => {
 const TO_PUBLIC_SIGNAL = (signal) => {
     const hasTrailingSL = "_trailingPriceStopLoss" in signal && signal._trailingPriceStopLoss !== undefined;
     const hasTrailingTP = "_trailingPriceTakeProfit" in signal && signal._trailingPriceTakeProfit !== undefined;
-    const partialExecuted = ("_partial" in signal && Array.isArray(signal._partial))
-        ? signal._partial.reduce((sum, partial) => sum + partial.percent, 0)
+    const partialExecuted = "_partial" in signal
+        ? getTotalClosed(signal).totalClosedPercent
         : 0;
     const totalEntries = ("_entry" in signal && Array.isArray(signal._entry))
         ? signal._entry.length
@@ -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,
-        price: currentPrice,
+        entryCountAtClose,
+        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,
+        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,183 @@ 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;
+    }
+    /**
+     * Returns the effective (DCA-averaged) entry price for the current pending signal.
+     *
+     * This is the harmonic mean of all _entry prices, which is the correct
+     * cost-basis price used in all PNL calculations.
+     * With no DCA entries, equals the original priceOpen.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to effective entry price or null
+     */
+    async getPositionAveragePrice(symbol) {
+        this.params.logger.debug("ClientStrategy getPositionAveragePrice", { symbol });
+        if (!this._pendingSignal) {
+            return null;
+        }
+        return getEffectivePriceOpen(this._pendingSignal);
+    }
+    /**
+     * Returns the number of DCA entries made for the current pending signal.
+     *
+     * 1 = original entry only (no DCA).
+     * Increases by 1 with each successful commitAverageBuy().
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to entry count or null
+     */
+    async getPositionInvestedCount(symbol) {
+        this.params.logger.debug("ClientStrategy getPositionInvestedCount", { symbol });
+        if (!this._pendingSignal) {
+            return null;
+        }
+        return this._pendingSignal._entry?.length ?? 1;
+    }
+    /**
+     * Returns the total invested cost basis in dollars for the current pending signal.
+     *
+     * Equal to entryCount × $100 (COST_BASIS_PER_ENTRY).
+     * 1 entry = $100, 2 entries = $200, etc.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to total invested cost in dollars or null
+     */
+    async getPositionInvestedCost(symbol) {
+        this.params.logger.debug("ClientStrategy getPositionInvestedCost", { symbol });
+        if (!this._pendingSignal) {
+            return null;
+        }
+        return (this._pendingSignal._entry?.length ?? 1) * COST_BASIS_PER_ENTRY;
+    }
+    /**
+     * Returns the unrealized PNL percentage for the current pending signal at currentPrice.
+     *
+     * Accounts for partial closes, DCA entries, slippage and fees
+     * (delegates to toProfitLossDto).
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Current market price
+     * @returns Promise resolving to pnlPercentage or null
+     */
+    async getPositionPnlPercent(symbol, currentPrice) {
+        this.params.logger.debug("ClientStrategy getPositionPnlPercent", { symbol, currentPrice });
+        if (!this._pendingSignal) {
+            return null;
+        }
+        const pnl = toProfitLossDto(this._pendingSignal, currentPrice);
+        return pnl.pnlPercentage;
+    }
+    /**
+     * Returns the unrealized PNL in dollars for the current pending signal at currentPrice.
+     *
+     * Calculated as: pnlPercentage / 100 × totalInvestedCost
+     * Accounts for partial closes, DCA entries, slippage and fees.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Current market price
+     * @returns Promise resolving to pnl in dollars or null
+     */
+    async getPositionPnlCost(symbol, currentPrice) {
+        this.params.logger.debug("ClientStrategy getPositionPnlCost", { symbol, currentPrice });
+        if (!this._pendingSignal) {
+            return null;
+        }
+        const totalInvested = (this._pendingSignal._entry?.length ?? 1) * COST_BASIS_PER_ENTRY;
+        const pnl = toProfitLossDto(this._pendingSignal, currentPrice);
+        return (pnl.pnlPercentage / 100) * totalInvested;
+    }
+    /**
+     * Returns the list of DCA entry prices for the current pending signal.
+     *
+     * The first element is always the original priceOpen (initial entry).
+     * Each subsequent element is a price added by commitAverageBuy().
+     *
+     * Returns null if no pending signal exists.
+     * Returns a single-element array [priceOpen] if no DCA entries were made.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to array of entry prices or null
+     *
+     * @example
+     * // No DCA: [43000]
+     * // One DCA: [43000, 42000]
+     * // Two DCA: [43000, 42000, 41500]
+     */
+    async getPositionLevels(symbol) {
+        this.params.logger.debug("ClientStrategy getPositionLevels", { symbol });
+        if (!this._pendingSignal) {
+            return null;
+        }
+        const entries = this._pendingSignal._entry;
+        if (!entries || entries.length === 0) {
+            return [this._pendingSignal.priceOpen];
+        }
+        return entries.map((e) => e.price);
+    }
+    async getPositionPartials(symbol) {
+        this.params.logger.debug("ClientStrategy getPositionPartials", { symbol });
+        if (!this._pendingSignal) {
+            return null;
+        }
+        return this._pendingSignal._partial ?? [];
+    }
     /**
      * Performs a single tick of strategy execution.
      *
@@ -7586,14 +7861,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 +8539,108 @@ 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);
+        };
+        this.getPositionAveragePrice = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getPositionAveragePrice", {
+                symbol,
+                context,
+                backtest,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return await strategy.getPositionAveragePrice(symbol);
+        };
+        this.getPositionInvestedCount = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getPositionInvestedCount", {
+                symbol,
+                context,
+                backtest,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return await strategy.getPositionInvestedCount(symbol);
+        };
+        this.getPositionInvestedCost = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getPositionInvestedCost", {
+                symbol,
+                context,
+                backtest,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return await strategy.getPositionInvestedCost(symbol);
+        };
+        this.getPositionPnlPercent = async (backtest, symbol, currentPrice, context) => {
+            this.loggerService.log("strategyConnectionService getPositionPnlPercent", {
+                symbol,
+                currentPrice,
+                context,
+                backtest,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return await strategy.getPositionPnlPercent(symbol, currentPrice);
+        };
+        this.getPositionPnlCost = async (backtest, symbol, currentPrice, context) => {
+            this.loggerService.log("strategyConnectionService getPositionPnlCost", {
+                symbol,
+                currentPrice,
+                context,
+                backtest,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return await strategy.getPositionPnlCost(symbol, currentPrice);
+        };
+        this.getPositionLevels = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getPositionLevels", {
+                symbol,
+                context,
+                backtest,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return await strategy.getPositionLevels(symbol);
+        };
+        this.getPositionPartials = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getPositionPartials", {
+                symbol,
+                context,
+                backtest,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return await strategy.getPositionPartials(symbol);
+        };
         /**
          * Retrieves the currently active scheduled signal for the strategy.
          * If no scheduled signal exists, returns null.
@@ -11675,6 +12044,99 @@ 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);
+        };
+        this.getPositionAveragePrice = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getPositionAveragePrice", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getPositionAveragePrice(backtest, symbol, context);
+        };
+        this.getPositionInvestedCount = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getPositionInvestedCount", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getPositionInvestedCount(backtest, symbol, context);
+        };
+        this.getPositionInvestedCost = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getPositionInvestedCost", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getPositionInvestedCost(backtest, symbol, context);
+        };
+        this.getPositionPnlPercent = async (backtest, symbol, currentPrice, context) => {
+            this.loggerService.log("strategyCoreService getPositionPnlPercent", {
+                symbol,
+                currentPrice,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getPositionPnlPercent(backtest, symbol, currentPrice, context);
+        };
+        this.getPositionPnlCost = async (backtest, symbol, currentPrice, context) => {
+            this.loggerService.log("strategyCoreService getPositionPnlCost", {
+                symbol,
+                currentPrice,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getPositionPnlCost(backtest, symbol, currentPrice, context);
+        };
+        this.getPositionLevels = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getPositionLevels", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getPositionLevels(backtest, symbol, context);
+        };
+        this.getPositionPartials = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getPositionPartials", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getPositionPartials(backtest, symbol, context);
+        };
         /**
          * Retrieves the currently active scheduled signal for the symbol.
          * If no scheduled signal exists, returns null.
@@ -28697,15 +29159,45 @@ async function getAggregatedTrades(symbol, limit) {
     return await bt.exchangeConnectionService.getAggregatedTrades(symbol, limit);
 }
 
+/**
+ * Convert an absolute dollar amount to a percentage of the invested position cost.
+ * Use the result as the `percent` argument to `commitPartialProfit` / `commitPartialLoss`.
+ *
+ * @param dollarAmount - Dollar value to close (e.g. 150)
+ * @param investedCost - Total invested cost from `getPositionInvestedCost` (e.g. 300)
+ * @returns Percentage of the position to close (0–100)
+ *
+ * @example
+ * const percent = investedCostToPercent(150, 300); // 50
+ * await commitPartialProfit("BTCUSDT", percent);
+ */
+const investedCostToPercent = (dollarAmount, investedCost) => {
+    return (dollarAmount / investedCost) * 100;
+};
+
 const CANCEL_SCHEDULED_METHOD_NAME = "strategy.commitCancelScheduled";
 const CLOSE_PENDING_METHOD_NAME = "strategy.commitClosePending";
 const PARTIAL_PROFIT_METHOD_NAME = "strategy.commitPartialProfit";
 const PARTIAL_LOSS_METHOD_NAME = "strategy.commitPartialLoss";
+const PARTIAL_PROFIT_COST_METHOD_NAME = "strategy.commitPartialProfitCost";
+const PARTIAL_LOSS_COST_METHOD_NAME = "strategy.commitPartialLossCost";
 const TRAILING_STOP_METHOD_NAME = "strategy.commitTrailingStop";
 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";
+const GET_POSITION_AVERAGE_PRICE_METHOD_NAME = "strategy.getPositionAveragePrice";
+const GET_POSITION_INVESTED_COUNT_METHOD_NAME = "strategy.getPositionInvestedCount";
+const GET_POSITION_INVESTED_COST_METHOD_NAME = "strategy.getPositionInvestedCost";
+const GET_POSITION_PNL_PERCENT_METHOD_NAME = "strategy.getPositionPnlPercent";
+const GET_POSITION_PNL_COST_METHOD_NAME = "strategy.getPositionPnlCost";
+const GET_POSITION_LEVELS_METHOD_NAME = "strategy.getPositionLevels";
+const GET_POSITION_PARTIALS_METHOD_NAME = "strategy.getPositionPartials";
 /**
  * Cancels the scheduled signal without stopping the strategy.
  *
@@ -29097,6 +29589,372 @@ 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 });
+}
+async function getPositionAveragePrice(symbol) {
+    bt.loggerService.info(GET_POSITION_AVERAGE_PRICE_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getPositionAveragePrice requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getPositionAveragePrice requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    return await bt.strategyCoreService.getPositionAveragePrice(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
+async function getPositionInvestedCount(symbol) {
+    bt.loggerService.info(GET_POSITION_INVESTED_COUNT_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getPositionInvestedCount requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getPositionInvestedCount requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    return await bt.strategyCoreService.getPositionInvestedCount(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
+async function getPositionInvestedCost(symbol) {
+    bt.loggerService.info(GET_POSITION_INVESTED_COST_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getPositionInvestedCost requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getPositionInvestedCost requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    return await bt.strategyCoreService.getPositionInvestedCost(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
+async function getPositionPnlPercent(symbol) {
+    bt.loggerService.info(GET_POSITION_PNL_PERCENT_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getPositionPnlPercent requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getPositionPnlPercent requires a method context");
+    }
+    const currentPrice = await getAveragePrice(symbol);
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    return await bt.strategyCoreService.getPositionPnlPercent(isBacktest, symbol, currentPrice, { exchangeName, frameName, strategyName });
+}
+/**
+ * Executes partial close at profit level by absolute dollar amount (moving toward TP).
+ *
+ * Convenience wrapper around commitPartialProfit that converts a dollar amount
+ * to a percentage of the invested position cost automatically.
+ * Price must be moving toward take profit (in profit direction).
+ *
+ * Automatically detects backtest/live mode from execution context.
+ * Automatically fetches current price via getAveragePrice.
+ *
+ * @param symbol - Trading pair symbol
+ * @param dollarAmount - Dollar value of position to close (e.g. 150 closes $150 worth)
+ * @returns Promise<boolean> - true if partial close executed, false if skipped or no position
+ *
+ * @throws Error if currentPrice is not in profit direction:
+ *   - LONG: currentPrice must be > priceOpen
+ *   - SHORT: currentPrice must be < priceOpen
+ *
+ * @example
+ * ```typescript
+ * import { commitPartialProfitCost } from "backtest-kit";
+ *
+ * // Close $150 of a $300 position (50%) at profit
+ * const success = await commitPartialProfitCost("BTCUSDT", 150);
+ * if (success) {
+ *   console.log('Partial profit executed');
+ * }
+ * ```
+ */
+async function commitPartialProfitCost(symbol, dollarAmount) {
+    bt.loggerService.info(PARTIAL_PROFIT_COST_METHOD_NAME, { symbol, dollarAmount });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("commitPartialProfitCost requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("commitPartialProfitCost requires a method context");
+    }
+    const currentPrice = await getAveragePrice(symbol);
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    const investedCost = await bt.strategyCoreService.getPositionInvestedCost(isBacktest, symbol, { exchangeName, frameName, strategyName });
+    if (investedCost === null)
+        return false;
+    const percentToClose = investedCostToPercent(dollarAmount, investedCost);
+    return await bt.strategyCoreService.partialProfit(isBacktest, symbol, percentToClose, currentPrice, { exchangeName, frameName, strategyName });
+}
+/**
+ * Executes partial close at loss level by absolute dollar amount (moving toward SL).
+ *
+ * Convenience wrapper around commitPartialLoss that converts a dollar amount
+ * to a percentage of the invested position cost automatically.
+ * Price must be moving toward stop loss (in loss direction).
+ *
+ * Automatically detects backtest/live mode from execution context.
+ * Automatically fetches current price via getAveragePrice.
+ *
+ * @param symbol - Trading pair symbol
+ * @param dollarAmount - Dollar value of position to close (e.g. 100 closes $100 worth)
+ * @returns Promise<boolean> - true if partial close executed, false if skipped or no position
+ *
+ * @throws Error if currentPrice is not in loss direction:
+ *   - LONG: currentPrice must be < priceOpen
+ *   - SHORT: currentPrice must be > priceOpen
+ *
+ * @example
+ * ```typescript
+ * import { commitPartialLossCost } from "backtest-kit";
+ *
+ * // Close $100 of a $300 position (~33%) at loss
+ * const success = await commitPartialLossCost("BTCUSDT", 100);
+ * if (success) {
+ *   console.log('Partial loss executed');
+ * }
+ * ```
+ */
+async function commitPartialLossCost(symbol, dollarAmount) {
+    bt.loggerService.info(PARTIAL_LOSS_COST_METHOD_NAME, { symbol, dollarAmount });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("commitPartialLossCost requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("commitPartialLossCost requires a method context");
+    }
+    const currentPrice = await getAveragePrice(symbol);
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    const investedCost = await bt.strategyCoreService.getPositionInvestedCost(isBacktest, symbol, { exchangeName, frameName, strategyName });
+    if (investedCost === null)
+        return false;
+    const percentToClose = investedCostToPercent(dollarAmount, investedCost);
+    return await bt.strategyCoreService.partialLoss(isBacktest, symbol, percentToClose, currentPrice, { exchangeName, frameName, strategyName });
+}
+async function getPositionPnlCost(symbol) {
+    bt.loggerService.info(GET_POSITION_PNL_COST_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getPositionPnlCost requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getPositionPnlCost requires a method context");
+    }
+    const currentPrice = await getAveragePrice(symbol);
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    return await bt.strategyCoreService.getPositionPnlCost(isBacktest, symbol, currentPrice, { exchangeName, frameName, strategyName });
+}
+/**
+ * Returns the list of DCA entry prices for the current pending signal.
+ *
+ * The first element is always the original priceOpen (initial entry).
+ * Each subsequent element is a price added by commitAverageBuy().
+ *
+ * Returns null if no pending signal exists.
+ * Returns a single-element array [priceOpen] if no DCA entries were made.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to array of entry prices or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionLevels } from "backtest-kit";
+ *
+ * const levels = await getPositionLevels("BTCUSDT");
+ * // No DCA: [43000]
+ * // One DCA: [43000, 42000]
+ * ```
+ */
+async function getPositionLevels(symbol) {
+    bt.loggerService.info(GET_POSITION_LEVELS_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getPositionLevels requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getPositionLevels requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    return await bt.strategyCoreService.getPositionLevels(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
+async function getPositionPartials(symbol) {
+    bt.loggerService.info(GET_POSITION_PARTIALS_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getPositionPartials requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getPositionPartials requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    return await bt.strategyCoreService.getPositionPartials(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
 
 const STOP_STRATEGY_METHOD_NAME = "control.stopStrategy";
 /**
@@ -30284,13 +31142,24 @@ 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_GET_POSITION_AVERAGE_PRICE = "BacktestUtils.getPositionAveragePrice";
+const BACKTEST_METHOD_NAME_GET_POSITION_INVESTED_COUNT = "BacktestUtils.getPositionInvestedCount";
+const BACKTEST_METHOD_NAME_GET_POSITION_INVESTED_COST = "BacktestUtils.getPositionInvestedCost";
+const BACKTEST_METHOD_NAME_GET_POSITION_PNL_PERCENT = "BacktestUtils.getPositionPnlPercent";
+const BACKTEST_METHOD_NAME_GET_POSITION_PNL_COST = "BacktestUtils.getPositionPnlCost";
+const BACKTEST_METHOD_NAME_GET_POSITION_LEVELS = "BacktestUtils.getPositionLevels";
+const BACKTEST_METHOD_NAME_GET_POSITION_PARTIALS = "BacktestUtils.getPositionPartials";
 const BACKTEST_METHOD_NAME_BREAKEVEN = "Backtest.commitBreakeven";
 const BACKTEST_METHOD_NAME_CANCEL_SCHEDULED = "Backtest.commitCancelScheduled";
 const BACKTEST_METHOD_NAME_CLOSE_PENDING = "Backtest.commitClosePending";
 const BACKTEST_METHOD_NAME_PARTIAL_PROFIT = "BacktestUtils.commitPartialProfit";
 const BACKTEST_METHOD_NAME_PARTIAL_LOSS = "BacktestUtils.commitPartialLoss";
+const BACKTEST_METHOD_NAME_PARTIAL_PROFIT_COST = "BacktestUtils.commitPartialProfitCost";
+const BACKTEST_METHOD_NAME_PARTIAL_LOSS_COST = "BacktestUtils.commitPartialLossCost";
 const BACKTEST_METHOD_NAME_TRAILING_STOP = "BacktestUtils.commitTrailingStop";
 const BACKTEST_METHOD_NAME_TRAILING_PROFIT = "BacktestUtils.commitTrailingTake";
 const BACKTEST_METHOD_NAME_ACTIVATE_SCHEDULED = "Backtest.commitActivateScheduled";
@@ -30685,6 +31554,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.
@@ -30762,6 +31696,134 @@ class BacktestUtils {
             }
             return await bt.strategyCoreService.getBreakeven(true, symbol, currentPrice, context);
         };
+        this.getPositionAveragePrice = async (symbol, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_AVERAGE_PRICE, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_POSITION_AVERAGE_PRICE);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_POSITION_AVERAGE_PRICE);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_AVERAGE_PRICE);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_AVERAGE_PRICE));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_POSITION_AVERAGE_PRICE));
+            }
+            return await bt.strategyCoreService.getPositionAveragePrice(true, symbol, context);
+        };
+        this.getPositionInvestedCount = async (symbol, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_INVESTED_COUNT, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_POSITION_INVESTED_COUNT);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_POSITION_INVESTED_COUNT);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_INVESTED_COUNT);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_INVESTED_COUNT));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_POSITION_INVESTED_COUNT));
+            }
+            return await bt.strategyCoreService.getPositionInvestedCount(true, symbol, context);
+        };
+        this.getPositionInvestedCost = async (symbol, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_INVESTED_COST, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_POSITION_INVESTED_COST);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_POSITION_INVESTED_COST);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_INVESTED_COST);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_INVESTED_COST));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_POSITION_INVESTED_COST));
+            }
+            return await bt.strategyCoreService.getPositionInvestedCost(true, symbol, context);
+        };
+        this.getPositionPnlPercent = async (symbol, currentPrice, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_PNL_PERCENT, {
+                symbol,
+                currentPrice,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_POSITION_PNL_PERCENT);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_POSITION_PNL_PERCENT);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_PNL_PERCENT);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_PNL_PERCENT));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_POSITION_PNL_PERCENT));
+            }
+            return await bt.strategyCoreService.getPositionPnlPercent(true, symbol, currentPrice, context);
+        };
+        this.getPositionPnlCost = async (symbol, currentPrice, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_PNL_COST, {
+                symbol,
+                currentPrice,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_POSITION_PNL_COST);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_POSITION_PNL_COST);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_PNL_COST);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_PNL_COST));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_POSITION_PNL_COST));
+            }
+            return await bt.strategyCoreService.getPositionPnlCost(true, symbol, currentPrice, context);
+        };
+        this.getPositionLevels = async (symbol, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_LEVELS, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_POSITION_LEVELS);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_POSITION_LEVELS);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_LEVELS);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_LEVELS));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_POSITION_LEVELS));
+            }
+            return await bt.strategyCoreService.getPositionLevels(true, symbol, context);
+        };
+        this.getPositionPartials = async (symbol, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_PARTIALS, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_POSITION_PARTIALS);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_POSITION_PARTIALS);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_PARTIALS);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_PARTIALS));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_POSITION_PARTIALS));
+            }
+            return await bt.strategyCoreService.getPositionPartials(true, symbol, context);
+        };
         /**
          * Stops the strategy from generating new signals.
          *
@@ -30983,6 +32045,114 @@ class BacktestUtils {
             }
             return await bt.strategyCoreService.partialLoss(true, symbol, percentToClose, currentPrice, context);
         };
+        /**
+         * Executes partial close at profit level by absolute dollar amount (moving toward TP).
+         *
+         * Convenience wrapper around commitPartialProfit that converts a dollar amount
+         * to a percentage of the invested position cost automatically.
+         * Price must be moving toward take profit (in profit direction).
+         *
+         * @param symbol - Trading pair symbol
+         * @param dollarAmount - Dollar value of position to close (e.g. 150 closes $150 worth)
+         * @param currentPrice - Current market price for this partial close
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns Promise<boolean> - true if partial close executed, false if skipped or no position
+         *
+         * @throws Error if currentPrice is not in profit direction:
+         *   - LONG: currentPrice must be > priceOpen
+         *   - SHORT: currentPrice must be < priceOpen
+         *
+         * @example
+         * ```typescript
+         * // Close $150 of a $300 position (50%) at profit
+         * const success = await Backtest.commitPartialProfitCost("BTCUSDT", 150, 45000, {
+         *   exchangeName: "binance",
+         *   frameName: "frame1",
+         *   strategyName: "my-strategy"
+         * });
+         * if (success) {
+         *   console.log('Partial profit executed');
+         * }
+         * ```
+         */
+        this.commitPartialProfitCost = async (symbol, dollarAmount, currentPrice, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_PARTIAL_PROFIT_COST, {
+                symbol,
+                dollarAmount,
+                currentPrice,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_PARTIAL_PROFIT_COST);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_PARTIAL_PROFIT_COST);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_PARTIAL_PROFIT_COST);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_PARTIAL_PROFIT_COST));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_PARTIAL_PROFIT_COST));
+            }
+            const investedCost = await bt.strategyCoreService.getPositionInvestedCost(true, symbol, context);
+            if (investedCost === null)
+                return false;
+            const percentToClose = (dollarAmount / investedCost) * 100;
+            return await bt.strategyCoreService.partialProfit(true, symbol, percentToClose, currentPrice, context);
+        };
+        /**
+         * Executes partial close at loss level by absolute dollar amount (moving toward SL).
+         *
+         * Convenience wrapper around commitPartialLoss that converts a dollar amount
+         * to a percentage of the invested position cost automatically.
+         * Price must be moving toward stop loss (in loss direction).
+         *
+         * @param symbol - Trading pair symbol
+         * @param dollarAmount - Dollar value of position to close (e.g. 100 closes $100 worth)
+         * @param currentPrice - Current market price for this partial close
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns Promise<boolean> - true if partial close executed, false if skipped or no position
+         *
+         * @throws Error if currentPrice is not in loss direction:
+         *   - LONG: currentPrice must be < priceOpen
+         *   - SHORT: currentPrice must be > priceOpen
+         *
+         * @example
+         * ```typescript
+         * // Close $100 of a $300 position (~33%) at loss
+         * const success = await Backtest.commitPartialLossCost("BTCUSDT", 100, 38000, {
+         *   exchangeName: "binance",
+         *   frameName: "frame1",
+         *   strategyName: "my-strategy"
+         * });
+         * if (success) {
+         *   console.log('Partial loss executed');
+         * }
+         * ```
+         */
+        this.commitPartialLossCost = async (symbol, dollarAmount, currentPrice, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_PARTIAL_LOSS_COST, {
+                symbol,
+                dollarAmount,
+                currentPrice,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_PARTIAL_LOSS_COST);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_PARTIAL_LOSS_COST);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_PARTIAL_LOSS_COST);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_PARTIAL_LOSS_COST));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_PARTIAL_LOSS_COST));
+            }
+            const investedCost = await bt.strategyCoreService.getPositionInvestedCost(true, symbol, context);
+            if (investedCost === null)
+                return false;
+            const percentToClose = (dollarAmount / investedCost) * 100;
+            return await bt.strategyCoreService.partialLoss(true, symbol, percentToClose, currentPrice, context);
+        };
         /**
          * Adjusts the trailing stop-loss distance for an active pending signal.
          *
@@ -31400,13 +32570,24 @@ 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_GET_POSITION_AVERAGE_PRICE = "LiveUtils.getPositionAveragePrice";
+const LIVE_METHOD_NAME_GET_POSITION_INVESTED_COUNT = "LiveUtils.getPositionInvestedCount";
+const LIVE_METHOD_NAME_GET_POSITION_INVESTED_COST = "LiveUtils.getPositionInvestedCost";
+const LIVE_METHOD_NAME_GET_POSITION_PNL_PERCENT = "LiveUtils.getPositionPnlPercent";
+const LIVE_METHOD_NAME_GET_POSITION_PNL_COST = "LiveUtils.getPositionPnlCost";
+const LIVE_METHOD_NAME_GET_POSITION_LEVELS = "LiveUtils.getPositionLevels";
+const LIVE_METHOD_NAME_GET_POSITION_PARTIALS = "LiveUtils.getPositionPartials";
 const LIVE_METHOD_NAME_BREAKEVEN = "Live.commitBreakeven";
 const LIVE_METHOD_NAME_CANCEL_SCHEDULED = "Live.cancelScheduled";
 const LIVE_METHOD_NAME_CLOSE_PENDING = "Live.closePending";
 const LIVE_METHOD_NAME_PARTIAL_PROFIT = "LiveUtils.commitPartialProfit";
 const LIVE_METHOD_NAME_PARTIAL_LOSS = "LiveUtils.commitPartialLoss";
+const LIVE_METHOD_NAME_PARTIAL_PROFIT_COST = "LiveUtils.commitPartialProfitCost";
+const LIVE_METHOD_NAME_PARTIAL_LOSS_COST = "LiveUtils.commitPartialLossCost";
 const LIVE_METHOD_NAME_TRAILING_STOP = "LiveUtils.commitTrailingStop";
 const LIVE_METHOD_NAME_TRAILING_PROFIT = "LiveUtils.commitTrailingTake";
 const LIVE_METHOD_NAME_ACTIVATE_SCHEDULED = "Live.commitActivateScheduled";
@@ -31770,6 +32951,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.
@@ -31848,6 +33096,118 @@ class LiveUtils {
                 frameName: "",
             });
         };
+        this.getPositionAveragePrice = async (symbol, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_AVERAGE_PRICE, { symbol, context });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_AVERAGE_PRICE);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_AVERAGE_PRICE);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_AVERAGE_PRICE);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_AVERAGE_PRICE));
+                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_AVERAGE_PRICE));
+            }
+            return await bt.strategyCoreService.getPositionAveragePrice(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
+        this.getPositionInvestedCount = async (symbol, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_INVESTED_COUNT, { symbol, context });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_INVESTED_COUNT);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_INVESTED_COUNT);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_INVESTED_COUNT);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_INVESTED_COUNT));
+                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_INVESTED_COUNT));
+            }
+            return await bt.strategyCoreService.getPositionInvestedCount(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
+        this.getPositionInvestedCost = async (symbol, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_INVESTED_COST, { symbol, context });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_INVESTED_COST);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_INVESTED_COST);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_INVESTED_COST);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_INVESTED_COST));
+                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_INVESTED_COST));
+            }
+            return await bt.strategyCoreService.getPositionInvestedCost(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
+        this.getPositionPnlPercent = async (symbol, currentPrice, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_PNL_PERCENT, { symbol, currentPrice, context });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_PNL_PERCENT);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_PNL_PERCENT);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_PNL_PERCENT);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_PNL_PERCENT));
+                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_PNL_PERCENT));
+            }
+            return await bt.strategyCoreService.getPositionPnlPercent(false, symbol, currentPrice, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
+        this.getPositionPnlCost = async (symbol, currentPrice, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_PNL_COST, { symbol, currentPrice, context });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_PNL_COST);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_PNL_COST);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_PNL_COST);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_PNL_COST));
+                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_PNL_COST));
+            }
+            return await bt.strategyCoreService.getPositionPnlCost(false, symbol, currentPrice, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
+        this.getPositionLevels = async (symbol, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_LEVELS, { symbol, context });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_LEVELS);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_LEVELS);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_LEVELS);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_LEVELS));
+                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_LEVELS));
+            }
+            return await bt.strategyCoreService.getPositionLevels(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
+        this.getPositionPartials = async (symbol, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_PARTIALS, { symbol, context });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_PARTIALS);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_PARTIALS);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_PARTIALS);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_PARTIALS));
+                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_PARTIALS));
+            }
+            return await bt.strategyCoreService.getPositionPartials(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
         /**
          * Stops the strategy from generating new signals.
          *
@@ -32066,6 +33426,112 @@ class LiveUtils {
                 frameName: "",
             });
         };
+        /**
+         * Executes partial close at profit level by absolute dollar amount (moving toward TP).
+         *
+         * Convenience wrapper around commitPartialProfit that converts a dollar amount
+         * to a percentage of the invested position cost automatically.
+         * Price must be moving toward take profit (in profit direction).
+         *
+         * @param symbol - Trading pair symbol
+         * @param dollarAmount - Dollar value of position to close (e.g. 150 closes $150 worth)
+         * @param currentPrice - Current market price for this partial close
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns Promise<boolean> - true if partial close executed, false if skipped or no position
+         *
+         * @throws Error if currentPrice is not in profit direction:
+         *   - LONG: currentPrice must be > priceOpen
+         *   - SHORT: currentPrice must be < priceOpen
+         *
+         * @example
+         * ```typescript
+         * // Close $150 of a $300 position (50%) at profit
+         * const success = await Live.commitPartialProfitCost("BTCUSDT", 150, 45000, {
+         *   exchangeName: "binance",
+         *   strategyName: "my-strategy"
+         * });
+         * if (success) {
+         *   console.log('Partial profit executed');
+         * }
+         * ```
+         */
+        this.commitPartialProfitCost = async (symbol, dollarAmount, currentPrice, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_PARTIAL_PROFIT_COST, { symbol, dollarAmount, currentPrice, context });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_PARTIAL_PROFIT_COST);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_PARTIAL_PROFIT_COST);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_PARTIAL_PROFIT_COST);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_PARTIAL_PROFIT_COST));
+                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_PARTIAL_PROFIT_COST));
+            }
+            const investedCost = await bt.strategyCoreService.getPositionInvestedCost(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+            if (investedCost === null)
+                return false;
+            const percentToClose = (dollarAmount / investedCost) * 100;
+            return await bt.strategyCoreService.partialProfit(false, symbol, percentToClose, currentPrice, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
+        /**
+         * Executes partial close at loss level by absolute dollar amount (moving toward SL).
+         *
+         * Convenience wrapper around commitPartialLoss that converts a dollar amount
+         * to a percentage of the invested position cost automatically.
+         * Price must be moving toward stop loss (in loss direction).
+         *
+         * @param symbol - Trading pair symbol
+         * @param dollarAmount - Dollar value of position to close (e.g. 100 closes $100 worth)
+         * @param currentPrice - Current market price for this partial close
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns Promise<boolean> - true if partial close executed, false if skipped or no position
+         *
+         * @throws Error if currentPrice is not in loss direction:
+         *   - LONG: currentPrice must be < priceOpen
+         *   - SHORT: currentPrice must be > priceOpen
+         *
+         * @example
+         * ```typescript
+         * // Close $100 of a $300 position (~33%) at loss
+         * const success = await Live.commitPartialLossCost("BTCUSDT", 100, 38000, {
+         *   exchangeName: "binance",
+         *   strategyName: "my-strategy"
+         * });
+         * if (success) {
+         *   console.log('Partial loss executed');
+         * }
+         * ```
+         */
+        this.commitPartialLossCost = async (symbol, dollarAmount, currentPrice, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_PARTIAL_LOSS_COST, { symbol, dollarAmount, currentPrice, context });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_PARTIAL_LOSS_COST);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_PARTIAL_LOSS_COST);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_PARTIAL_LOSS_COST);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_PARTIAL_LOSS_COST));
+                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_PARTIAL_LOSS_COST));
+            }
+            const investedCost = await bt.strategyCoreService.getPositionInvestedCost(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+            if (investedCost === null)
+                return false;
+            const percentToClose = (dollarAmount / investedCost) * 100;
+            return await bt.strategyCoreService.partialLoss(false, symbol, percentToClose, currentPrice, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
         /**
          * Adjusts the trailing stop-loss distance for an active pending signal.
          *
@@ -39586,6 +41052,27 @@ const set = (object, path, value) => {
     }
 };
 
+/**
+ * Calculate the percentage difference between two numbers.
+ * @param {number} a - The first number.
+ * @param {number} b - The second number.
+ * @returns {number} The percentage difference between the two numbers.
+ */
+const percentDiff = (a = 1, b = 2) => {
+    const result = 100 / (Math.min(a, b) / Math.max(a, b)) - 100;
+    return Number.isFinite(result) ? result : 100;
+};
+
+/**
+ * Calculate the percentage change from yesterday's value to today's value.
+ * @param {number} yesterdayValue - The value from yesterday.
+ * @param {number} todayValue - The value from today.
+ * @returns {number} The percentage change from yesterday to today.
+ */
+const percentValue = (yesterdayValue, todayValue) => {
+    return yesterdayValue / todayValue - 1;
+};
+
 exports.ActionBase = ActionBase;
 exports.Backtest = Backtest;
 exports.Breakeven = Breakeven;
@@ -39641,7 +41128,9 @@ exports.commitBreakeven = commitBreakeven;
 exports.commitCancelScheduled = commitCancelScheduled;
 exports.commitClosePending = commitClosePending;
 exports.commitPartialLoss = commitPartialLoss;
+exports.commitPartialLossCost = commitPartialLossCost;
 exports.commitPartialProfit = commitPartialProfit;
+exports.commitPartialProfitCost = commitPartialProfitCost;
 exports.commitTrailingStop = commitTrailingStop;
 exports.commitTrailingTake = commitTrailingTake;
 exports.dumpMessages = dumpMessages;
@@ -39653,6 +41142,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,19 +41150,33 @@ 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.getPositionAveragePrice = getPositionAveragePrice;
+exports.getPositionInvestedCost = getPositionInvestedCost;
+exports.getPositionInvestedCount = getPositionInvestedCount;
+exports.getPositionLevels = getPositionLevels;
+exports.getPositionPartials = getPositionPartials;
+exports.getPositionPnlCost = getPositionPnlCost;
+exports.getPositionPnlPercent = getPositionPnlPercent;
 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.investedCostToPercent = investedCostToPercent;
 exports.lib = backtest;
 exports.listExchangeSchema = listExchangeSchema;
 exports.listFrameSchema = listFrameSchema;
@@ -39723,6 +41227,8 @@ exports.overrideSizingSchema = overrideSizingSchema;
 exports.overrideStrategySchema = overrideStrategySchema;
 exports.overrideWalkerSchema = overrideWalkerSchema;
 exports.parseArgs = parseArgs;
+exports.percentDiff = percentDiff;
+exports.percentValue = percentValue;
 exports.roundTicks = roundTicks;
 exports.set = set;
 exports.setColumns = setColumns;
@@ -39730,6 +41236,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;