backtest-kit 3.7.0 → 3.8.0

package/build/index.mjs

@@ -443,6 +443,14 @@ const GLOBAL_CONFIG = {
      * Default: true (mutex locking enabled for candle fetching)
      */
     CC_ENABLE_CANDLE_FETCH_MUTEX: true,
+    /**
+     * Enables DCA (Dollar-Cost Averaging) logic even if antirecord is not broken.
+     * Allows to commitAverageBuy if currentPrice is not the lowest price since entry, but still lower than priceOpen.
+     * This can help improve average entry price in cases where price has rebounded after entry but is still below priceOpen, without waiting for a new lower price.
+     *
+     * Default: true (DCA logic enabled everywhere, not just when antirecord is broken)
+     */
+    CC_ENABLE_DCA_EVERYWHERE: false,
 };
 const DEFAULT_CONFIG = Object.freeze({ ...GLOBAL_CONFIG });
 
@@ -3174,75 +3182,90 @@ class ExchangeConnectionService {
     }
 }
 
+const COST_BASIS_PER_ENTRY$3 = 100;
 /**
  * Returns the effective entry price for price calculations.
  *
- * When the _entry array exists and has at least one element, returns
- * the simple arithmetic mean of all entry prices (DCA average).
- * Otherwise returns the original signal.priceOpen.
+ * Uses harmonic mean (correct for fixed-dollar DCA: $100 per entry).
  *
- * This mirrors the _trailingPriceStopLoss pattern: original price is preserved
- * in signal.priceOpen (for identity/tracking), while calculations use the
- * effective averaged price returned by this function.
+ * When partial closes exist, replays the partial sequence to reconstruct
+ * the running cost basis at each partial — no extra stored fields needed.
  *
- * @param signal - Signal row (ISignalRow or IScheduledSignalRow)
- * @returns Effective entry price for distance and PNL calculations
+ * Cost basis replay:
+ *   costBasis starts at 0
+ *   for each partial[i]:
+ *     newEntries = entryCountAtClose[i] - entryCountAtClose[i-1]  (or entryCountAtClose[0] for i=0)
+ *     costBasis += newEntries × $100          ← add DCA entries up to this partial
+ *     positionCostBasisAtClose[i] = costBasis ← snapshot BEFORE close
+ *     costBasis × = (1 - percent[i] / 100)    ← reduce after close
+ *
+ * @param signal - Signal row
+ * @returns Effective entry price for PNL calculations
  */
 const getEffectivePriceOpen = (signal) => {
-    if (signal._entry && signal._entry.length > 0) {
-        return signal._entry.reduce((sum, e) => sum + e.price, 0) / signal._entry.length;
-    }
-    return signal.priceOpen;
+    if (!signal._entry || signal._entry.length === 0)
+        return signal.priceOpen;
+    const entries = signal._entry;
+    const partials = signal._partial ?? [];
+    // No partial exits — pure harmonic mean of all entries
+    if (partials.length === 0) {
+        return harmonicMean(entries.map((e) => e.price));
+    }
+    // Replay cost basis through all partials to get snapshot at the last one
+    let costBasis = 0;
+    for (let i = 0; i < partials.length; i++) {
+        const prevCount = i === 0 ? 0 : partials[i - 1].entryCountAtClose;
+        const newEntryCount = partials[i].entryCountAtClose - prevCount;
+        costBasis += newEntryCount * COST_BASIS_PER_ENTRY$3;
+        // costBasis is now positionCostBasisAtClose for partials[i]
+        if (i < partials.length - 1) {
+            costBasis *= 1 - partials[i].percent / 100;
+        }
+    }
+    const lastPartial = partials[partials.length - 1];
+    // Dollar cost basis remaining after the last partial close
+    const remainingCostBasis = costBasis * (1 - lastPartial.percent / 100);
+    // Coins remaining from the old position
+    const oldCoins = remainingCostBasis / lastPartial.effectivePrice;
+    // New DCA entries added AFTER the last partial close
+    const newEntries = entries.slice(lastPartial.entryCountAtClose);
+    // Coins from new DCA entries (each costs $100)
+    const newCoins = newEntries.reduce((sum, e) => sum + 100 / e.price, 0);
+    const totalCoins = oldCoins + newCoins;
+    if (totalCoins === 0)
+        return lastPartial.effectivePrice;
+    const totalCost = remainingCostBasis + newEntries.length * 100;
+    return totalCost / totalCoins;
+};
+const harmonicMean = (prices) => {
+    if (prices.length === 0)
+        return 0;
+    return prices.length / prices.reduce((sum, p) => sum + 1 / p, 0);
 };
 
+const COST_BASIS_PER_ENTRY$2 = 100;
 /**
  * Calculates profit/loss for a closed signal with slippage and fees.
  *
  * For signals with partial closes:
- * - Calculates weighted PNL: Σ(percent_i × pnl_i) for each partial + (remaining% × final_pnl)
- * - Each partial close has its own slippage
- * - Open fee is charged once; close fees are proportional to each partial's size
- * - Total fees = CC_PERCENT_FEE (open) + Σ CC_PERCENT_FEE × (partial% / 100) × (closeWithSlip / openWithSlip)
- *
- * Formula breakdown:
- * 1. Apply slippage to open/close prices (worse execution)
- *    - LONG: buy higher (+slippage), sell lower (-slippage)
- *    - SHORT: sell lower (-slippage), buy higher (+slippage)
- * 2. Calculate raw PNL percentage
- *    - LONG: ((closePrice - openPrice) / openPrice) * 100
- *    - SHORT: ((openPrice - closePrice) / openPrice) * 100
- * 3. Subtract total fees: open fee + close fee adjusted for slippage-affected execution price
+ * - Weights are calculated by ACTUAL DOLLAR VALUE of each partial relative to total invested.
+ *   This correctly handles DCA entries that occur before or after partial closes.
+ *
+ * Cost basis is reconstructed by replaying the partial sequence via entryCountAtClose + percent:
+ *   costBasis = 0
+ *   for each partial[i]:
+ *     costBasis += (entryCountAtClose[i] - entryCountAtClose[i-1]) × $100
+ *     partialDollarValue[i] = (percent[i] / 100) × costBasis
+ *     weight[i]             = partialDollarValue[i] / totalInvested
+ *     costBasis            *= (1 - percent[i] / 100)
+ *
+ * Fee structure:
+ *   - Open fee:  CC_PERCENT_FEE (charged once)
+ *   - Close fee: CC_PERCENT_FEE × weight × (closeWithSlip / openWithSlip) per partial/remaining
  *
  * @param signal - Closed signal with position details and optional partial history
  * @param priceClose - Actual close price at final exit
  * @returns PNL data with percentage and prices
- *
- * @example
- * ```typescript
- * // Signal without partial closes
- * const pnl = toProfitLossDto(
- *   {
- *     position: "long",
- *     priceOpen: 100,
- *   },
- *   110 // close at +10%
- * );
- * console.log(pnl.pnlPercentage); // ~9.6% (after slippage and fees)
- *
- * // Signal with partial closes
- * const pnlPartial = toProfitLossDto(
- *   {
- *     position: "long",
- *     priceOpen: 100,
- *     _partial: [
- *       { type: "profit", percent: 30, price: 120 }, // +20% on 30%
- *       { type: "profit", percent: 40, price: 115 }, // +15% on 40%
- *     ],
- *   },
- *   105 // final close at +5% for remaining 30%
- * );
- * // Weighted PNL = 30% × 20% + 40% × 15% + 30% × 5% = 6% + 6% + 1.5% = 13.5% (before fees)
- * ```
  */
 const toProfitLossDto = (signal, priceClose) => {
     const priceOpen = getEffectivePriceOpen(signal);
@@ -3251,47 +3274,65 @@ const toProfitLossDto = (signal, priceClose) => {
         let totalWeightedPnl = 0;
         // Open fee is paid once for the whole position
         let totalFees = GLOBAL_CONFIG.CC_PERCENT_FEE;
-        // priceOpenWithSlippage is the same for all partials — compute once
-        const priceOpenWithSlippage = signal.position === "long"
-            ? priceOpen * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100)
-            : priceOpen * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+        // Total invested capital = number of DCA entries × $100 per entry
+        const totalInvested = signal._entry ? signal._entry.length * 100 : 100;
+        let closedDollarValue = 0;
+        // Running cost basis — replayed from entryCountAtClose + percent
+        let costBasis = 0;
         // Calculate PNL for each partial close
-        for (const partial of signal._partial) {
-            const partialPercent = partial.percent;
+        for (let i = 0; i < signal._partial.length; i++) {
+            const partial = signal._partial[i];
+            // Add DCA entries that existed at this partial but not at the previous one
+            const prevCount = i === 0 ? 0 : signal._partial[i - 1].entryCountAtClose;
+            const newEntryCount = partial.entryCountAtClose - prevCount;
+            costBasis += newEntryCount * COST_BASIS_PER_ENTRY$2;
+            // Real dollar value sold in this partial
+            const partialDollarValue = (partial.percent / 100) * costBasis;
+            // Weight relative to total invested capital
+            const weight = partialDollarValue / totalInvested;
+            closedDollarValue += partialDollarValue;
+            // Reduce cost basis after close
+            costBasis *= 1 - partial.percent / 100;
+            // Use the effective entry price snapshot captured at the time of this partial close
+            const priceOpenWithSlippage = signal.position === "long"
+                ? partial.effectivePrice * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100)
+                : partial.effectivePrice * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
             const priceCloseWithSlippage = signal.position === "long"
-                ? partial.price * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100)
-                : partial.price * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
-            // Calculate PNL for this partial
+                ? 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,
@@ -3303,33 +3344,24 @@ const toProfitLossDto = (signal, priceClose) => {
     let priceOpenWithSlippage;
     let priceCloseWithSlippage;
     if (signal.position === "long") {
-        // LONG: покупаем дороже, продаем дешевле
         priceOpenWithSlippage = priceOpen * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
         priceCloseWithSlippage = priceClose * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
     }
     else {
-        // SHORT: продаем дешевле, покупаем дороже
         priceOpenWithSlippage = priceOpen * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
         priceCloseWithSlippage = priceClose * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
     }
-    // Открытие: комиссия от цены входа; закрытие: комиссия от фактической цены выхода (с учётом slippage)
-    const totalFee = GLOBAL_CONFIG.CC_PERCENT_FEE * (1 + priceCloseWithSlippage / priceOpenWithSlippage);
+    const totalFee = GLOBAL_CONFIG.CC_PERCENT_FEE *
+        (1 + priceCloseWithSlippage / priceOpenWithSlippage);
     let pnlPercentage;
     if (signal.position === "long") {
-        // LONG: прибыль при росте цены
         pnlPercentage =
-            ((priceCloseWithSlippage - priceOpenWithSlippage) /
-                priceOpenWithSlippage) *
-                100;
+            ((priceCloseWithSlippage - priceOpenWithSlippage) / priceOpenWithSlippage) * 100;
     }
     else {
-        // SHORT: прибыль при падении цены
         pnlPercentage =
-            ((priceOpenWithSlippage - priceCloseWithSlippage) /
-                priceOpenWithSlippage) *
-                100;
+            ((priceOpenWithSlippage - priceCloseWithSlippage) / priceOpenWithSlippage) * 100;
     }
-    // Вычитаем комиссии
     pnlPercentage -= totalFee;
     return {
         pnlPercentage,
@@ -3385,6 +3417,54 @@ const toPlainString = (content) => {
     return text.trim();
 };
 
+const COST_BASIS_PER_ENTRY$1 = 100;
+/**
+ * Returns the total closed state of a position using cost-basis replay.
+ *
+ * Correctly accounts for DCA entries added between partial closes via averageBuy().
+ * Simple percent summation (sum of _partial[i].percent) is INCORRECT when averageBuy()
+ * is called between partials — this function uses the same cost-basis replay as
+ * toProfitLossDto to compute the true dollar-weighted closed fraction.
+ *
+ * Cost-basis replay:
+ *   costBasis = 0
+ *   for each partial[i]:
+ *     costBasis += (entryCountAtClose[i] - entryCountAtClose[i-1]) × $100
+ *     closedDollar += (percent[i] / 100) × costBasis
+ *     costBasis ×= (1 - percent[i] / 100)
+ *   // then add entries added AFTER the last partial
+ *   costBasis += (currentEntryCount - lastPartialEntryCount) × $100
+ *
+ * @param signal - Signal row with _partial and _entry arrays
+ * @returns Object with totalClosedPercent (0–100+) and remainingCostBasis (dollar value still open)
+ */
+const getTotalClosed = (signal) => {
+    const partials = signal._partial ?? [];
+    const currentEntryCount = signal._entry?.length ?? 1;
+    const totalInvested = currentEntryCount * COST_BASIS_PER_ENTRY$1;
+    if (partials.length === 0) {
+        return {
+            totalClosedPercent: 0,
+            remainingCostBasis: totalInvested,
+        };
+    }
+    let costBasis = 0;
+    let closedDollarValue = 0;
+    for (let i = 0; i < partials.length; i++) {
+        const prevCount = i === 0 ? 0 : partials[i - 1].entryCountAtClose;
+        costBasis += (partials[i].entryCountAtClose - prevCount) * COST_BASIS_PER_ENTRY$1;
+        closedDollarValue += (partials[i].percent / 100) * costBasis;
+        costBasis *= 1 - partials[i].percent / 100;
+    }
+    // Add entries added AFTER the last partial (not yet accounted for in the loop)
+    const lastEntryCount = partials[partials.length - 1].entryCountAtClose;
+    costBasis += (currentEntryCount - lastEntryCount) * COST_BASIS_PER_ENTRY$1;
+    return {
+        totalClosedPercent: totalInvested > 0 ? (closedDollarValue / totalInvested) * 100 : 0,
+        remainingCostBasis: costBasis,
+    };
+};
+
 /**
  * Wraps a function to execute it outside of the current execution context if one exists.
  *
@@ -3427,6 +3507,19 @@ const beginTime = (run) => (...args) => {
     return fn();
 };
 
+/**
+ * Retrieves the current timestamp for debugging purposes.
+ * If an execution context is active (e.g., during a backtest), it returns the timestamp from the context to ensure consistency with the simulated time.
+ * Can be empty (undefined) if not called from strategy async context, as it's intended for debugging and not critical for logic.
+ * @return {number | undefined} The current timestamp in milliseconds from the execution context, or undefined if not available.
+ */
+const getDebugTimestamp = () => {
+    if (ExecutionContextService.hasContext()) {
+        return bt.executionContextService.context.when.getTime();
+    }
+    return undefined;
+};
+
 const INTERVAL_MINUTES$6 = {
     "1m": 1,
     "3m": 3,
@@ -3435,6 +3528,7 @@ const INTERVAL_MINUTES$6 = {
     "30m": 30,
     "1h": 60,
 };
+const COST_BASIS_PER_ENTRY = 100;
 /**
  * Mock value for scheduled signal pendingAt timestamp.
  * Used to indicate that the actual pendingAt will be set upon activation.
@@ -3690,8 +3784,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
@@ -4036,7 +4130,7 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
                 scheduledAt: currentTime,
                 pendingAt: currentTime, // Для immediate signal оба времени одинаковые
                 _isScheduled: false,
-                _entry: [{ price: signal.priceOpen }],
+                _entry: [{ price: signal.priceOpen, debugTimestamp: currentTime }],
             };
             // Валидируем сигнал перед возвратом
             VALIDATE_SIGNAL_FN(signalRow, currentPrice, false);
@@ -4058,7 +4152,7 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
             scheduledAt: currentTime,
             pendingAt: SCHEDULED_SIGNAL_PENDING_MOCK, // Временно, обновится при активации
             _isScheduled: true,
-            _entry: [{ price: signal.priceOpen }],
+            _entry: [{ price: signal.priceOpen, debugTimestamp: currentTime }],
         };
         // Валидируем сигнал перед возвратом
         VALIDATE_SIGNAL_FN(scheduledSignalRow, currentPrice, true);
@@ -4076,7 +4170,7 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
         scheduledAt: currentTime,
         pendingAt: currentTime, // Для immediate signal оба времени одинаковые
         _isScheduled: false,
-        _entry: [{ price: currentPrice }],
+        _entry: [{ price: currentPrice, debugTimestamp: currentTime }],
     };
     // Валидируем сигнал перед возвратом
     VALIDATE_SIGNAL_FN(signalRow, currentPrice, false);
@@ -4150,37 +4244,39 @@ const PARTIAL_PROFIT_FN = (self, signal, percentToClose, currentPrice) => {
     // Initialize partial array if not present
     if (!signal._partial)
         signal._partial = [];
-    // Calculate current totals (computed values)
-    const tpClosed = signal._partial
-        .filter((p) => p.type === "profit")
-        .reduce((sum, p) => sum + p.percent, 0);
-    const slClosed = signal._partial
-        .filter((p) => p.type === "loss")
-        .reduce((sum, p) => sum + p.percent, 0);
-    const totalClosed = tpClosed + slClosed;
-    // Check if would exceed 100% total closed
-    const newTotalClosed = totalClosed + percentToClose;
-    if (newTotalClosed > 100) {
-        self.params.logger.warn("PARTIAL_PROFIT_FN: would exceed 100% closed, skipping", {
+    // Check if would exceed 100% total closed (dollar-basis, DCA-aware)
+    const { totalClosedPercent, remainingCostBasis } = getTotalClosed(signal);
+    const totalInvested = (signal._entry?.length ?? 1) * COST_BASIS_PER_ENTRY;
+    const newPartialDollar = (percentToClose / 100) * remainingCostBasis;
+    const newTotalClosedDollar = (totalClosedPercent / 100) * totalInvested + newPartialDollar;
+    if (newTotalClosedDollar > totalInvested) {
+        self.params.logger.warn("PARTIAL_PROFIT_FN: would exceed 100% closed (dollar basis), skipping", {
             signalId: signal.id,
-            currentTotalClosed: totalClosed,
+            totalClosedPercent,
+            remainingCostBasis,
             percentToClose,
-            newTotalClosed,
+            newPartialDollar,
+            totalInvested,
         });
         return false;
     }
+    // Capture effective entry price at the moment of partial close (for DCA-aware PNL)
+    const effectivePrice = getEffectivePriceOpen(signal);
+    const entryCountAtClose = signal._entry ? signal._entry.length : 1;
     // Add new partial close entry
     signal._partial.push({
         type: "profit",
         percent: percentToClose,
-        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;
 };
@@ -4188,37 +4284,39 @@ const PARTIAL_LOSS_FN = (self, signal, percentToClose, currentPrice) => {
     // Initialize partial array if not present
     if (!signal._partial)
         signal._partial = [];
-    // Calculate current totals (computed values)
-    const tpClosed = signal._partial
-        .filter((p) => p.type === "profit")
-        .reduce((sum, p) => sum + p.percent, 0);
-    const slClosed = signal._partial
-        .filter((p) => p.type === "loss")
-        .reduce((sum, p) => sum + p.percent, 0);
-    const totalClosed = tpClosed + slClosed;
-    // Check if would exceed 100% total closed
-    const newTotalClosed = totalClosed + percentToClose;
-    if (newTotalClosed > 100) {
-        self.params.logger.warn("PARTIAL_LOSS_FN: would exceed 100% closed, skipping", {
+    // Check if would exceed 100% total closed (dollar-basis, DCA-aware)
+    const { totalClosedPercent, remainingCostBasis } = getTotalClosed(signal);
+    const totalInvested = (signal._entry?.length ?? 1) * COST_BASIS_PER_ENTRY;
+    const newPartialDollar = (percentToClose / 100) * remainingCostBasis;
+    const newTotalClosedDollar = (totalClosedPercent / 100) * totalInvested + newPartialDollar;
+    if (newTotalClosedDollar > totalInvested) {
+        self.params.logger.warn("PARTIAL_LOSS_FN: would exceed 100% closed (dollar basis), skipping", {
             signalId: signal.id,
-            currentTotalClosed: totalClosed,
+            totalClosedPercent,
+            remainingCostBasis,
             percentToClose,
-            newTotalClosed,
+            newPartialDollar,
+            totalInvested,
         });
         return false;
     }
+    // Capture effective entry price at the moment of partial close (for DCA-aware PNL)
+    const effectivePrice = getEffectivePriceOpen(signal);
+    const entryCountAtClose = signal._entry ? signal._entry.length : 1;
     // Add new partial close entry
     signal._partial.push({
         type: "loss",
         percent: percentToClose,
-        price: currentPrice,
+        currentPrice,
+        entryCountAtClose,
+        effectivePrice,
+        debugTimestamp: getDebugTimestamp(),
     });
     self.params.logger.warn("PARTIAL_LOSS_FN executed", {
         signalId: signal.id,
         percentClosed: percentToClose,
-        totalClosed: newTotalClosed,
+        totalClosedPercent: totalClosedPercent + (newPartialDollar / totalInvested) * 100,
         currentPrice,
-        slClosed: slClosed + percentToClose,
     });
     return true;
 };
@@ -4612,12 +4710,12 @@ const BREAKEVEN_FN = (self, signal, currentPrice) => {
 const AVERAGE_BUY_FN = (self, signal, currentPrice) => {
     // Ensure _entry is initialized (handles signals loaded from disk without _entry)
     if (!signal._entry || signal._entry.length === 0) {
-        signal._entry = [{ price: signal.priceOpen }];
+        signal._entry = [{ price: signal.priceOpen, debugTimestamp: getDebugTimestamp() }];
     }
     const lastEntry = signal._entry[signal._entry.length - 1];
     if (signal.position === "long") {
         // LONG: averaging down = currentPrice must be strictly lower than last entry
-        if (currentPrice >= lastEntry.price) {
+        if (!GLOBAL_CONFIG.CC_ENABLE_DCA_EVERYWHERE && currentPrice >= lastEntry.price) {
             self.params.logger.debug("AVERAGE_BUY_FN: rejected — currentPrice >= last entry (LONG)", {
                 signalId: signal.id,
                 position: signal.position,
@@ -4630,7 +4728,7 @@ const AVERAGE_BUY_FN = (self, signal, currentPrice) => {
     }
     else {
         // SHORT: averaging down = currentPrice must be strictly higher than last entry
-        if (currentPrice <= lastEntry.price) {
+        if (!GLOBAL_CONFIG.CC_ENABLE_DCA_EVERYWHERE && currentPrice <= lastEntry.price) {
             self.params.logger.debug("AVERAGE_BUY_FN: rejected — currentPrice <= last entry (SHORT)", {
                 signalId: signal.id,
                 position: signal.position,
@@ -4641,7 +4739,7 @@ const AVERAGE_BUY_FN = (self, signal, currentPrice) => {
             return false;
         }
     }
-    signal._entry.push({ price: currentPrice });
+    signal._entry.push({ price: currentPrice, debugTimestamp: getDebugTimestamp() });
     self.params.logger.info("AVERAGE_BUY_FN executed", {
         signalId: signal.id,
         position: signal.position,
@@ -6106,6 +6204,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.
      *
@@ -7566,14 +7841,6 @@ class ClientStrategy {
         if (typeof currentPrice !== "number" || !isFinite(currentPrice) || currentPrice <= 0) {
             throw new Error(`ClientStrategy averageBuy: currentPrice must be a positive finite number, got ${currentPrice}`);
         }
-        // Reject if any partial closes have already been executed
-        if (this._pendingSignal._partial && this._pendingSignal._partial.length > 0) {
-            this.params.logger.debug("ClientStrategy averageBuy: rejected — partial closes already executed", {
-                symbol,
-                partialCount: this._pendingSignal._partial.length,
-            });
-            return false;
-        }
         // Execute averaging logic
         const result = AVERAGE_BUY_FN(this, this._pendingSignal, currentPrice);
         if (!result) {
@@ -8252,6 +8519,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.
@@ -11655,6 +12024,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.
@@ -28677,15 +29139,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.
  *
@@ -29077,6 +29569,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";
 /**
@@ -30264,13 +31122,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";
@@ -30665,6 +31534,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.
@@ -30742,6 +31676,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.
          *
@@ -30963,6 +32025,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.
          *
@@ -31380,13 +32550,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";
@@ -31750,6 +32931,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.
@@ -31828,6 +33076,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.
          *
@@ -32046,6 +33406,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.
          *
@@ -39566,4 +41032,25 @@ const set = (object, path, value) => {
     }
 };
 
-export { ActionBase, Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Log, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistLogAdapter, PersistMeasureAdapter, PersistNotificationAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Storage, StorageBacktest, StorageLive, Strategy, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialProfit, commitTrailingStop, commitTrailingTake, dumpMessages, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getRawCandles, getRiskSchema, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getWalkerSchema, hasTradeContext, backtest as lib, listExchangeSchema, listFrameSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, roundTicks, set, setColumns, setConfig, setLogger, shutdown, stopStrategy, validate, waitForCandle, warmCandles };
+/**
+ * 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;
+};
+
+export { ActionBase, Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Log, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistLogAdapter, PersistMeasureAdapter, PersistNotificationAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Storage, StorageBacktest, StorageLive, Strategy, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitTrailingStop, commitTrailingTake, dumpMessages, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionAveragePrice, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getRawCandles, getRiskSchema, getScheduledSignal, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasTradeContext, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentValue, roundTicks, set, setColumns, setConfig, setLogger, shutdown, stopStrategy, toProfitLossDto, validate, waitForCandle, warmCandles };