backtest-kit 1.10.4 → 1.11.2

package/build/index.cjs

@@ -9,6 +9,25 @@ var crypto = require('crypto');
 var os = require('os');
 var fs$1 = require('fs');
 
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
+
 const { init, inject, provide } = diKit.createActivator("backtest");
 
 /**
@@ -102,6 +121,17 @@ const markdownServices$1 = {
     outlineMarkdownService: Symbol('outlineMarkdownService'),
     riskMarkdownService: Symbol('riskMarkdownService'),
 };
+const reportServices$1 = {
+    backtestReportService: Symbol('backtestReportService'),
+    liveReportService: Symbol('liveReportService'),
+    scheduleReportService: Symbol('scheduleReportService'),
+    performanceReportService: Symbol('performanceReportService'),
+    walkerReportService: Symbol('walkerReportService'),
+    heatReportService: Symbol('heatReportService'),
+    partialReportService: Symbol('partialReportService'),
+    breakevenReportService: Symbol('breakevenReportService'),
+    riskReportService: Symbol('riskReportService'),
+};
 const validationServices$1 = {
     exchangeValidationService: Symbol('exchangeValidationService'),
     strategyValidationService: Symbol('strategyValidationService'),
@@ -127,6 +157,7 @@ const TYPES = {
     ...logicPrivateServices$1,
     ...logicPublicServices$1,
     ...markdownServices$1,
+    ...reportServices$1,
     ...validationServices$1,
     ...templateServices$1,
 };
@@ -327,6 +358,12 @@ const GLOBAL_CONFIG = {
      * Default: 5000 ms (5 seconds)
      */
     CC_GET_CANDLES_RETRY_DELAY_MS: 5000,
+    /**
+     * Maximum number of candles to request per single API call.
+     * If a request exceeds this limit, data will be fetched using pagination.
+     * Default: 1000 candles per request
+     */
+    CC_MAX_CANDLES_PER_REQUEST: 1000,
     /**
      * Maximum allowed deviation factor for price anomaly detection.
      * Price should not be more than this factor lower than reference price.
@@ -694,11 +731,29 @@ class ClientExchange {
             throw new Error(`ClientExchange unknown time adjust for interval=${interval}`);
         }
         const since = new Date(this.params.execution.context.when.getTime() - adjust * 60 * 1000);
-        const data = await GET_CANDLES_FN({ symbol, interval, limit }, since, this);
+        let allData = [];
+        // If limit exceeds CC_MAX_CANDLES_PER_REQUEST, fetch data in chunks
+        if (limit > GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST) {
+            let remaining = limit;
+            let currentSince = new Date(since.getTime());
+            while (remaining > 0) {
+                const chunkLimit = Math.min(remaining, GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST);
+                const chunkData = await GET_CANDLES_FN({ symbol, interval, limit: chunkLimit }, currentSince, this);
+                allData.push(...chunkData);
+                remaining -= chunkLimit;
+                if (remaining > 0) {
+                    // Move currentSince forward by the number of candles fetched
+                    currentSince = new Date(currentSince.getTime() + chunkLimit * step * 60 * 1000);
+                }
+            }
+        }
+        else {
+            allData = await GET_CANDLES_FN({ symbol, interval, limit }, since, this);
+        }
         // Filter candles to strictly match the requested range
         const whenTimestamp = this.params.execution.context.when.getTime();
         const sinceTimestamp = since.getTime();
-        const filteredData = data.filter((candle) => candle.timestamp >= sinceTimestamp && candle.timestamp <= whenTimestamp);
+        const filteredData = allData.filter((candle) => candle.timestamp >= sinceTimestamp && candle.timestamp <= whenTimestamp);
         if (filteredData.length < limit) {
             this.params.logger.warn(`ClientExchange Expected ${limit} candles, got ${filteredData.length}`);
         }
@@ -730,10 +785,28 @@ class ClientExchange {
         if (endTime > now) {
             return [];
         }
-        const data = await GET_CANDLES_FN({ symbol, interval, limit }, since, this);
+        let allData = [];
+        // If limit exceeds CC_MAX_CANDLES_PER_REQUEST, fetch data in chunks
+        if (limit > GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST) {
+            let remaining = limit;
+            let currentSince = new Date(since.getTime());
+            while (remaining > 0) {
+                const chunkLimit = Math.min(remaining, GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST);
+                const chunkData = await GET_CANDLES_FN({ symbol, interval, limit: chunkLimit }, currentSince, this);
+                allData.push(...chunkData);
+                remaining -= chunkLimit;
+                if (remaining > 0) {
+                    // Move currentSince forward by the number of candles fetched
+                    currentSince = new Date(currentSince.getTime() + chunkLimit * step * 60 * 1000);
+                }
+            }
+        }
+        else {
+            allData = await GET_CANDLES_FN({ symbol, interval, limit }, since, this);
+        }
         // Filter candles to strictly match the requested range
         const sinceTimestamp = since.getTime();
-        const filteredData = data.filter((candle) => candle.timestamp >= sinceTimestamp && candle.timestamp <= endTime);
+        const filteredData = allData.filter((candle) => candle.timestamp >= sinceTimestamp && candle.timestamp <= endTime);
         if (filteredData.length < limit) {
             this.params.logger.warn(`ClientExchange getNextCandles: Expected ${limit} candles, got ${filteredData.length}`);
         }
@@ -1211,20 +1284,33 @@ async function writeFileAtomic(file, data, options = {}) {
     }
 }
 
-var _a;
+var _a$2;
 const BASE_WAIT_FOR_INIT_SYMBOL = Symbol("wait-for-init");
 const PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_PERSIST_SIGNAL_ADAPTER = "PersistSignalUtils.usePersistSignalAdapter";
 const PERSIST_SIGNAL_UTILS_METHOD_NAME_READ_DATA = "PersistSignalUtils.readSignalData";
 const PERSIST_SIGNAL_UTILS_METHOD_NAME_WRITE_DATA = "PersistSignalUtils.writeSignalData";
+const PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_JSON = "PersistSignalUtils.useJson";
+const PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_DUMMY = "PersistSignalUtils.useDummy";
 const PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_PERSIST_SCHEDULE_ADAPTER = "PersistScheduleUtils.usePersistScheduleAdapter";
 const PERSIST_SCHEDULE_UTILS_METHOD_NAME_READ_DATA = "PersistScheduleUtils.readScheduleData";
 const PERSIST_SCHEDULE_UTILS_METHOD_NAME_WRITE_DATA = "PersistScheduleUtils.writeScheduleData";
+const PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_JSON = "PersistScheduleUtils.useJson";
+const PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_DUMMY = "PersistScheduleUtils.useDummy";
 const PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_PERSIST_PARTIAL_ADAPTER = "PersistPartialUtils.usePersistPartialAdapter";
 const PERSIST_PARTIAL_UTILS_METHOD_NAME_READ_DATA = "PersistPartialUtils.readPartialData";
 const PERSIST_PARTIAL_UTILS_METHOD_NAME_WRITE_DATA = "PersistPartialUtils.writePartialData";
+const PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_JSON = "PersistPartialUtils.useJson";
+const PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_DUMMY = "PersistPartialUtils.useDummy";
 const PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_PERSIST_BREAKEVEN_ADAPTER = "PersistBreakevenUtils.usePersistBreakevenAdapter";
 const PERSIST_BREAKEVEN_UTILS_METHOD_NAME_READ_DATA = "PersistBreakevenUtils.readBreakevenData";
 const PERSIST_BREAKEVEN_UTILS_METHOD_NAME_WRITE_DATA = "PersistBreakevenUtils.writeBreakevenData";
+const PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_JSON = "PersistBreakevenUtils.useJson";
+const PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_DUMMY = "PersistBreakevenUtils.useDummy";
+const PERSIST_RISK_UTILS_METHOD_NAME_USE_PERSIST_RISK_ADAPTER = "PersistRiskUtils.usePersistRiskAdapter";
+const PERSIST_RISK_UTILS_METHOD_NAME_READ_DATA = "PersistRiskUtils.readPositionData";
+const PERSIST_RISK_UTILS_METHOD_NAME_WRITE_DATA = "PersistRiskUtils.writePositionData";
+const PERSIST_RISK_UTILS_METHOD_NAME_USE_JSON = "PersistRiskUtils.useJson";
+const PERSIST_RISK_UTILS_METHOD_NAME_USE_DUMMY = "PersistRiskUtils.useDummy";
 const PERSIST_BASE_METHOD_NAME_CTOR = "PersistBase.CTOR";
 const PERSIST_BASE_METHOD_NAME_WAIT_FOR_INIT = "PersistBase.waitForInit";
 const PERSIST_BASE_METHOD_NAME_READ_VALUE = "PersistBase.readValue";
@@ -1295,7 +1381,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
     constructor(entityName, baseDir = path.join(process.cwd(), "logs/data")) {
         this.entityName = entityName;
         this.baseDir = baseDir;
-        this[_a] = functoolsKit.singleshot(async () => await BASE_WAIT_FOR_INIT_FN(this));
+        this[_a$2] = functoolsKit.singleshot(async () => await BASE_WAIT_FOR_INIT_FN(this));
         bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_CTOR, {
             entityName: this.entityName,
             baseDir,
@@ -1483,7 +1569,7 @@ const PersistBase = functoolsKit.makeExtendable(class {
      *
      * @returns AsyncIterableIterator yielding entities
      */
-    async *[(_a = BASE_WAIT_FOR_INIT_SYMBOL, Symbol.asyncIterator)]() {
+    async *[(_a$2 = BASE_WAIT_FOR_INIT_SYMBOL, Symbol.asyncIterator)]() {
         for await (const entity of this.values()) {
             yield entity;
         }
@@ -1533,6 +1619,44 @@ const PersistBase = functoolsKit.makeExtendable(class {
         }
     }
 });
+/**
+ * Dummy persist adapter that discards all writes.
+ * Used for disabling persistence.
+ */
+class PersistDummy {
+    /**
+     * No-op initialization function.
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit() {
+    }
+    /**
+     * No-op read function.
+     * @returns Promise that resolves with empty object
+     */
+    async readValue() {
+        return {};
+    }
+    /**
+     * No-op has value check.
+     * @returns Promise that resolves to false
+     */
+    async hasValue() {
+        return false;
+    }
+    /**
+     * No-op write function.
+     * @returns Promise that resolves immediately
+     */
+    async writeValue() {
+    }
+    /**
+     * No-op keys generator.
+     * @returns Empty async generator
+     */
+    async *keys() {
+    }
+}
 /**
  * Utility class for managing signal persistence.
  *
@@ -1612,6 +1736,22 @@ class PersistSignalUtils {
         bt.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_PERSIST_SIGNAL_ADAPTER);
         this.PersistSignalFactory = Ctor;
     }
+    /**
+     * Switches to the default JSON persist adapter.
+     * All future persistence writes will use JSON storage.
+     */
+    useJson() {
+        bt.loggerService.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_JSON);
+        this.usePersistSignalAdapter(PersistBase);
+    }
+    /**
+     * Switches to a dummy persist adapter that discards all writes.
+     * All future persistence writes will be no-ops.
+     */
+    useDummy() {
+        bt.loggerService.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_DUMMY);
+        this.usePersistSignalAdapter(PersistDummy);
+    }
 }
 /**
  * Global singleton instance of PersistSignalUtils.
@@ -1630,9 +1770,6 @@ class PersistSignalUtils {
  * ```
  */
 const PersistSignalAdapter = new PersistSignalUtils();
-const PERSIST_RISK_UTILS_METHOD_NAME_USE_PERSIST_RISK_ADAPTER = "PersistRiskUtils.usePersistRiskAdapter";
-const PERSIST_RISK_UTILS_METHOD_NAME_READ_DATA = "PersistRiskUtils.readPositionData";
-const PERSIST_RISK_UTILS_METHOD_NAME_WRITE_DATA = "PersistRiskUtils.writePositionData";
 /**
  * Utility class for managing risk active positions persistence.
  *
@@ -1712,6 +1849,22 @@ class PersistRiskUtils {
         bt.loggerService.info(PERSIST_RISK_UTILS_METHOD_NAME_USE_PERSIST_RISK_ADAPTER);
         this.PersistRiskFactory = Ctor;
     }
+    /**
+     * Switches to the default JSON persist adapter.
+     * All future persistence writes will use JSON storage.
+     */
+    useJson() {
+        bt.loggerService.log(PERSIST_RISK_UTILS_METHOD_NAME_USE_JSON);
+        this.usePersistRiskAdapter(PersistBase);
+    }
+    /**
+     * Switches to a dummy persist adapter that discards all writes.
+     * All future persistence writes will be no-ops.
+     */
+    useDummy() {
+        bt.loggerService.log(PERSIST_RISK_UTILS_METHOD_NAME_USE_DUMMY);
+        this.usePersistRiskAdapter(PersistDummy);
+    }
 }
 /**
  * Global singleton instance of PersistRiskUtils.
@@ -1809,6 +1962,22 @@ class PersistScheduleUtils {
         bt.loggerService.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_PERSIST_SCHEDULE_ADAPTER);
         this.PersistScheduleFactory = Ctor;
     }
+    /**
+     * Switches to the default JSON persist adapter.
+     * All future persistence writes will use JSON storage.
+     */
+    useJson() {
+        bt.loggerService.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_JSON);
+        this.usePersistScheduleAdapter(PersistBase);
+    }
+    /**
+     * Switches to a dummy persist adapter that discards all writes.
+     * All future persistence writes will be no-ops.
+     */
+    useDummy() {
+        bt.loggerService.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_DUMMY);
+        this.usePersistScheduleAdapter(PersistDummy);
+    }
 }
 /**
  * Global singleton instance of PersistScheduleUtils.
@@ -1908,6 +2077,22 @@ class PersistPartialUtils {
         bt.loggerService.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_PERSIST_PARTIAL_ADAPTER);
         this.PersistPartialFactory = Ctor;
     }
+    /**
+     * Switches to the default JSON persist adapter.
+     * All future persistence writes will use JSON storage.
+     */
+    useJson() {
+        bt.loggerService.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_JSON);
+        this.usePersistPartialAdapter(PersistBase);
+    }
+    /**
+     * Switches to a dummy persist adapter that discards all writes.
+     * All future persistence writes will be no-ops.
+     */
+    useDummy() {
+        bt.loggerService.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_DUMMY);
+        this.usePersistPartialAdapter(PersistDummy);
+    }
 }
 /**
  * Global singleton instance of PersistPartialUtils.
@@ -2042,6 +2227,22 @@ class PersistBreakevenUtils {
         bt.loggerService.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_PERSIST_BREAKEVEN_ADAPTER);
         this.PersistBreakevenFactory = Ctor;
     }
+    /**
+     * Switches to the default JSON persist adapter.
+     * All future persistence writes will use JSON storage.
+     */
+    useJson() {
+        bt.loggerService.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_JSON);
+        this.usePersistBreakevenAdapter(PersistBase);
+    }
+    /**
+     * Switches to a dummy persist adapter that discards all writes.
+     * All future persistence writes will be no-ops.
+     */
+    useDummy() {
+        bt.loggerService.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_DUMMY);
+        this.usePersistBreakevenAdapter(PersistDummy);
+    }
 }
 /**
  * Global singleton instance of PersistBreakevenUtils.
@@ -2165,14 +2366,18 @@ const TIMEOUT_SYMBOL = Symbol('timeout');
  * ```
  */
 const TO_PUBLIC_SIGNAL = (signal) => {
-    const hasTrailingSL = signal._trailingPriceStopLoss !== undefined;
-    const hasTrailingTP = signal._trailingPriceTakeProfit !== undefined;
+    const hasTrailingSL = "_trailingPriceStopLoss" in signal && signal._trailingPriceStopLoss !== undefined;
+    const hasTrailingTP = "_trailingPriceTakeProfit" in signal && signal._trailingPriceTakeProfit !== undefined;
+    const totalExecuted = ("_partial" in signal && Array.isArray(signal._partial))
+        ? signal._partial.reduce((sum, partial) => sum + partial.percent, 0)
+        : 0;
     return {
         ...structuredClone(signal),
         priceStopLoss: hasTrailingSL ? signal._trailingPriceStopLoss : signal.priceStopLoss,
         priceTakeProfit: hasTrailingTP ? signal._trailingPriceTakeProfit : signal.priceTakeProfit,
         originalPriceStopLoss: signal.priceStopLoss,
         originalPriceTakeProfit: signal.priceTakeProfit,
+        totalExecuted,
     };
 };
 const VALIDATE_SIGNAL_FN = (signal, currentPrice, isScheduled) => {
@@ -2623,7 +2828,7 @@ const PARTIAL_PROFIT_FN = (self, signal, percentToClose, currentPrice) => {
             percentToClose,
             newTotalClosed,
         });
-        return;
+        return false;
     }
     // Add new partial close entry
     signal._partial.push({
@@ -2638,6 +2843,7 @@ const PARTIAL_PROFIT_FN = (self, signal, percentToClose, currentPrice) => {
         currentPrice,
         tpClosed: tpClosed + percentToClose,
     });
+    return true;
 };
 const PARTIAL_LOSS_FN = (self, signal, percentToClose, currentPrice) => {
     // Initialize partial array if not present
@@ -2660,7 +2866,7 @@ const PARTIAL_LOSS_FN = (self, signal, percentToClose, currentPrice) => {
             percentToClose,
             newTotalClosed,
         });
-        return;
+        return false;
     }
     // Add new partial close entry
     signal._partial.push({
@@ -2675,6 +2881,7 @@ const PARTIAL_LOSS_FN = (self, signal, percentToClose, currentPrice) => {
         currentPrice,
         slClosed: slClosed + percentToClose,
     });
+    return true;
 };
 const TRAILING_STOP_LOSS_FN = (self, signal, percentShift) => {
     // CRITICAL: Always calculate from ORIGINAL SL, not from current trailing SL
@@ -3467,11 +3674,12 @@ const CALL_PARTIAL_CLEAR_FN = functoolsKit.trycatch(async (self, symbol, signal,
 const CALL_RISK_CHECK_SIGNAL_FN = functoolsKit.trycatch(async (self, symbol, pendingSignal, currentPrice, timestamp, backtest) => {
     return await ExecutionContextService.runInContext(async () => {
         return await self.params.risk.checkSignal({
-            pendingSignal,
+            pendingSignal: TO_PUBLIC_SIGNAL(pendingSignal),
             symbol: symbol,
             strategyName: self.params.method.context.strategyName,
             exchangeName: self.params.method.context.exchangeName,
             frameName: self.params.method.context.frameName,
+            riskName: self.params.riskName,
             currentPrice,
             timestamp,
         });
@@ -3589,6 +3797,7 @@ const CALL_BREAKEVEN_CLEAR_FN = functoolsKit.trycatch(async (self, symbol, signa
 const RETURN_SCHEDULED_SIGNAL_ACTIVE_FN = async (self, scheduled, currentPrice) => {
     const currentTime = self.params.execution.context.when.getTime();
     await CALL_PING_CALLBACKS_FN(self, self.params.execution.context.symbol, scheduled, currentTime, self.params.execution.context.backtest);
+    const pnl = toProfitLossDto(scheduled, currentPrice);
     const result = {
         action: "active",
         signal: TO_PUBLIC_SIGNAL(scheduled),
@@ -3599,6 +3808,7 @@ const RETURN_SCHEDULED_SIGNAL_ACTIVE_FN = async (self, scheduled, currentPrice)
         symbol: self.params.execution.context.symbol,
         percentTp: 0,
         percentSl: 0,
+        pnl,
         backtest: self.params.execution.context.backtest,
     };
     await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, currentTime, self.params.execution.context.backtest);
@@ -3767,6 +3977,7 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
             }
         }
     }
+    const pnl = toProfitLossDto(signal, currentPrice);
     const result = {
         action: "active",
         signal: TO_PUBLIC_SIGNAL(signal),
@@ -3777,6 +3988,7 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
         symbol: self.params.execution.context.symbol,
         percentTp,
         percentSl,
+        pnl,
         backtest: self.params.execution.context.backtest,
     };
     await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, currentTime, self.params.execution.context.backtest);
@@ -4566,12 +4778,14 @@ class ClientStrategy {
                     // Don't cancel - just return last active state
                     // In real backtest flow this won't happen as we process all candles at once,
                     // but this is correct behavior if someone calls backtest() with partial data
+                    const pnl = toProfitLossDto(scheduled, lastPrice);
                     const result = {
                         action: "active",
                         signal: TO_PUBLIC_SIGNAL(scheduled),
                         currentPrice: lastPrice,
                         percentSl: 0,
                         percentTp: 0,
+                        pnl,
                         strategyName: this.params.method.context.strategyName,
                         exchangeName: this.params.method.context.exchangeName,
                         frameName: this.params.method.context.frameName,
@@ -4696,7 +4910,8 @@ class ClientStrategy {
      * Behavior:
      * - Adds entry to signal's `_partial` array with type "profit"
      * - Validates percentToClose is in range (0, 100]
-     * - Silently skips if total closed would exceed 100%
+     * - Returns false if total closed would exceed 100%
+     * - Returns false if currentPrice already crossed TP level
      * - Persists updated signal state (backtest and live modes)
      * - Calls onWrite callback for persistence testing
      *
@@ -4713,17 +4928,21 @@ class ClientStrategy {
      * @param percentToClose - Percentage of position to close (0-100, absolute value)
      * @param currentPrice - Current market price for this partial close (must be in profit direction)
      * @param backtest - Whether running in backtest mode (controls persistence)
-     * @returns Promise that resolves when state is updated and persisted
+     * @returns Promise<boolean> - true if partial close was executed, false if skipped
      *
      * @example
      * ```typescript
      * // Close 30% of position at profit (moving toward TP)
-     * await strategy.partialProfit("BTCUSDT", 30, 45000, false);
+     * const success1 = await strategy.partialProfit("BTCUSDT", 30, 45000, false);
+     * // success1 = true (executed)
      *
      * // Later close another 20%
-     * await strategy.partialProfit("BTCUSDT", 20, 46000, false);
+     * const success2 = await strategy.partialProfit("BTCUSDT", 20, 46000, false);
+     * // success2 = true (executed, total 50% closed)
      *
-     * // Final close will calculate weighted PNL from all partials
+     * // Try to close 60% more (would exceed 100%)
+     * const success3 = await strategy.partialProfit("BTCUSDT", 60, 47000, false);
+     * // success3 = false (skipped, would exceed 100%)
      * ```
      */
     async partialProfit(symbol, percentToClose, currentPrice, backtest) {
@@ -4774,7 +4993,7 @@ class ClientStrategy {
                 effectiveTakeProfit,
                 reason: "currentPrice >= effectiveTakeProfit (LONG position)"
             });
-            return;
+            return false;
         }
         if (this._pendingSignal.position === "short" && currentPrice <= effectiveTakeProfit) {
             this.params.logger.debug("ClientStrategy partialProfit: price already at/below TP, skipping partial close", {
@@ -4784,10 +5003,14 @@ class ClientStrategy {
                 effectiveTakeProfit,
                 reason: "currentPrice <= effectiveTakeProfit (SHORT position)"
             });
-            return;
+            return false;
         }
         // Execute partial close logic
-        PARTIAL_PROFIT_FN(this, this._pendingSignal, percentToClose, currentPrice);
+        const wasExecuted = PARTIAL_PROFIT_FN(this, this._pendingSignal, percentToClose, currentPrice);
+        // If partial was not executed (exceeded 100%), return false without persistence
+        if (!wasExecuted) {
+            return false;
+        }
         // Persist updated signal state (inline setPendingSignal content)
         // Note: this._pendingSignal already mutated by PARTIAL_PROFIT_FN, no reassignment needed
         this.params.logger.debug("ClientStrategy setPendingSignal (inline)", {
@@ -4800,6 +5023,7 @@ class ClientStrategy {
         if (!backtest) {
             await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.execution.context.symbol, this.params.strategyName, this.params.exchangeName);
         }
+        return true;
     }
     /**
      * Executes partial close at loss level (moving toward SL).
@@ -4810,7 +5034,8 @@ class ClientStrategy {
      * Behavior:
      * - Adds entry to signal's `_partial` array with type "loss"
      * - Validates percentToClose is in range (0, 100]
-     * - Silently skips if total closed would exceed 100%
+     * - Returns false if total closed would exceed 100%
+     * - Returns false if currentPrice already crossed SL level
      * - Persists updated signal state (backtest and live modes)
      * - Calls onWrite callback for persistence testing
      *
@@ -4827,17 +5052,21 @@ class ClientStrategy {
      * @param percentToClose - Percentage of position to close (0-100, absolute value)
      * @param currentPrice - Current market price for this partial close (must be in loss direction)
      * @param backtest - Whether running in backtest mode (controls persistence)
-     * @returns Promise that resolves when state is updated and persisted
+     * @returns Promise<boolean> - true if partial close was executed, false if skipped
      *
      * @example
      * ```typescript
      * // Close 40% of position at loss (moving toward SL)
-     * await strategy.partialLoss("BTCUSDT", 40, 38000, false);
+     * const success1 = await strategy.partialLoss("BTCUSDT", 40, 38000, false);
+     * // success1 = true (executed)
      *
      * // Later close another 30%
-     * await strategy.partialLoss("BTCUSDT", 30, 37000, false);
+     * const success2 = await strategy.partialLoss("BTCUSDT", 30, 37000, false);
+     * // success2 = true (executed, total 70% closed)
      *
-     * // Final close will calculate weighted PNL from all partials
+     * // Try to close 40% more (would exceed 100%)
+     * const success3 = await strategy.partialLoss("BTCUSDT", 40, 36000, false);
+     * // success3 = false (skipped, would exceed 100%)
      * ```
      */
     async partialLoss(symbol, percentToClose, currentPrice, backtest) {
@@ -4888,7 +5117,7 @@ class ClientStrategy {
                 effectiveStopLoss,
                 reason: "currentPrice <= effectiveStopLoss (LONG position)"
             });
-            return;
+            return false;
         }
         if (this._pendingSignal.position === "short" && currentPrice >= effectiveStopLoss) {
             this.params.logger.debug("ClientStrategy partialLoss: price already at/above SL, skipping partial close", {
@@ -4898,10 +5127,14 @@ class ClientStrategy {
                 effectiveStopLoss,
                 reason: "currentPrice >= effectiveStopLoss (SHORT position)"
             });
-            return;
+            return false;
         }
         // Execute partial close logic
-        PARTIAL_LOSS_FN(this, this._pendingSignal, percentToClose, currentPrice);
+        const wasExecuted = PARTIAL_LOSS_FN(this, this._pendingSignal, percentToClose, currentPrice);
+        // If partial was not executed (exceeded 100%), return false without persistence
+        if (!wasExecuted) {
+            return false;
+        }
         // Persist updated signal state (inline setPendingSignal content)
         // Note: this._pendingSignal already mutated by PARTIAL_LOSS_FN, no reassignment needed
         this.params.logger.debug("ClientStrategy setPendingSignal (inline)", {
@@ -4914,6 +5147,7 @@ class ClientStrategy {
         if (!backtest) {
             await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.execution.context.symbol, this.params.strategyName, this.params.exchangeName);
         }
+        return true;
     }
     /**
      * Moves stop-loss to breakeven (entry price) when price reaches threshold.
@@ -5398,7 +5632,10 @@ const RISK_METHOD_NAME_DUMP = "RiskUtils.dump";
  * // Combine multiple risk profiles
  * const maxPositionsRisk = new MaxPositionsRisk(3);
  * const correlationRisk = new CorrelationRisk(0.7);
- * const mergedRisk = new MergeRisk([maxPositionsRisk, correlationRisk]);
+ * const mergedRisk = new MergeRisk({
+ *   "max-positions": maxPositionsRisk,
+ *   "correlation": correlationRisk
+ * });
  *
  * // Check if signal passes all risks
  * const canTrade = await mergedRisk.checkSignal({
@@ -5416,10 +5653,10 @@ class MergeRisk {
     /**
      * Creates a merged risk profile from multiple risk instances.
      *
-     * @param _riskList - Array of IRisk instances to combine
+     * @param _riskMap - Object mapping RiskName to IRisk instances to combine
      */
-    constructor(_riskList) {
-        this._riskList = _riskList;
+    constructor(_riskMap) {
+        this._riskMap = _riskMap;
     }
     /**
      * Checks if signal passes all combined risk profiles.
@@ -5434,8 +5671,11 @@ class MergeRisk {
         bt.loggerService.info("MergeRisk checkSignal", {
             params,
         });
-        for (const risk of this._riskList) {
-            if (await functoolsKit.not(risk.checkSignal(params))) {
+        for (const [riskName, risk] of Object.entries(this._riskMap)) {
+            if (await functoolsKit.not(risk.checkSignal({
+                ...params,
+                riskName,
+            }))) {
                 return false;
             }
         }
@@ -5456,7 +5696,7 @@ class MergeRisk {
             symbol,
             context,
         });
-        await Promise.all(this._riskList.map(async (risk) => await risk.addSignal(symbol, context, positionData)));
+        await Promise.all(Object.entries(this._riskMap).map(async ([riskName, risk]) => await risk.addSignal(symbol, { ...context, riskName }, positionData)));
     }
     /**
      * Removes a signal from all child risk profiles.
@@ -5473,7 +5713,7 @@ class MergeRisk {
             symbol,
             context,
         });
-        await Promise.all(this._riskList.map(async (risk) => await risk.removeSignal(symbol, context)));
+        await Promise.all(Object.entries(this._riskMap).map(async ([riskName, risk]) => await risk.removeSignal(symbol, { ...context, riskName })));
     }
 }
 /**
@@ -5711,13 +5951,22 @@ const GET_RISK_FN = (dto, backtest, exchangeName, frameName, self) => {
     }
     // Есть только riskList (без riskName)
     if (!hasRiskName && hasRiskList) {
-        return new MergeRisk(dto.riskList.map((riskName) => self.riskConnectionService.getRisk(riskName, exchangeName, frameName, backtest)));
+        return new MergeRisk(dto.riskList.reduce((acc, riskName) => {
+            acc[riskName] = self.riskConnectionService.getRisk(riskName, exchangeName, frameName, backtest);
+            return acc;
+        }, {}));
     }
     // Есть и riskName, и riskList - объединяем (riskName в начало)
-    return new MergeRisk([
-        self.riskConnectionService.getRisk(dto.riskName, exchangeName, frameName, backtest),
-        ...dto.riskList.map((riskName) => self.riskConnectionService.getRisk(riskName, exchangeName, frameName, backtest)),
-    ]);
+    return new MergeRisk({
+        [dto.riskName]: self.riskConnectionService.getRisk(dto.riskName, exchangeName, frameName, backtest),
+        ...dto.riskList.reduce((acc, riskName) => {
+            if (riskName === dto.riskName) {
+                return acc;
+            }
+            acc[riskName] = self.riskConnectionService.getRisk(riskName, exchangeName, frameName, backtest);
+            return acc;
+        }, {})
+    });
 };
 /**
  * Creates a unique key for memoizing ClientStrategy instances.
@@ -6063,18 +6312,21 @@ class StrategyConnectionService {
          * @param context - Execution context with strategyName, exchangeName, frameName
          * @param percentToClose - Percentage of position to close (0-100, absolute value)
          * @param currentPrice - Current market price for this partial close
-         * @returns Promise that resolves when state is updated and persisted
+         * @returns Promise<boolean> - true if partial close executed, false if skipped
          *
          * @example
          * ```typescript
          * // Close 30% of position at profit
-         * await strategyConnectionService.partialProfit(
+         * const success = await strategyConnectionService.partialProfit(
          *   false,
          *   "BTCUSDT",
          *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" },
          *   30,
          *   45000
          * );
+         * if (success) {
+         *   console.log('Partial profit executed');
+         * }
          * ```
          */
         this.partialProfit = async (backtest, symbol, percentToClose, currentPrice, context) => {
@@ -6086,7 +6338,7 @@ class StrategyConnectionService {
                 backtest,
             });
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
-            await strategy.partialProfit(symbol, percentToClose, currentPrice, backtest);
+            return await strategy.partialProfit(symbol, percentToClose, currentPrice, backtest);
         };
         /**
          * Executes partial close at loss level (moving toward SL).
@@ -6101,18 +6353,21 @@ class StrategyConnectionService {
          * @param context - Execution context with strategyName, exchangeName, frameName
          * @param percentToClose - Percentage of position to close (0-100, absolute value)
          * @param currentPrice - Current market price for this partial close
-         * @returns Promise that resolves when state is updated and persisted
+         * @returns Promise<boolean> - true if partial close executed, false if skipped
          *
          * @example
          * ```typescript
          * // Close 40% of position at loss
-         * await strategyConnectionService.partialLoss(
+         * const success = await strategyConnectionService.partialLoss(
          *   false,
          *   "BTCUSDT",
          *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" },
          *   40,
          *   38000
          * );
+         * if (success) {
+         *   console.log('Partial loss executed');
+         * }
          * ```
          */
         this.partialLoss = async (backtest, symbol, percentToClose, currentPrice, context) => {
@@ -6124,7 +6379,7 @@ class StrategyConnectionService {
                 backtest,
             });
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
-            await strategy.partialLoss(symbol, percentToClose, currentPrice, backtest);
+            return await strategy.partialLoss(symbol, percentToClose, currentPrice, backtest);
         };
         /**
          * Adjusts the trailing stop-loss distance for an active pending signal.
@@ -6704,6 +6959,9 @@ const POSITION_NEED_FETCH = Symbol("risk-need-fetch");
 const TO_RISK_SIGNAL = (signal, currentPrice) => {
     const hasTrailingSL = "_trailingPriceStopLoss" in signal && signal._trailingPriceStopLoss !== undefined;
     const hasTrailingTP = "_trailingPriceTakeProfit" in signal && signal._trailingPriceTakeProfit !== undefined;
+    const totalExecuted = ("_partial" in signal && Array.isArray(signal._partial))
+        ? signal._partial.reduce((sum, partial) => sum + partial.percent, 0)
+        : 0;
     return {
         ...structuredClone(signal),
         priceOpen: signal.priceOpen ?? currentPrice,
@@ -6711,6 +6969,7 @@ const TO_RISK_SIGNAL = (signal, currentPrice) => {
         priceTakeProfit: hasTrailingTP ? signal._trailingPriceTakeProfit : signal.priceTakeProfit,
         originalPriceStopLoss: signal.priceStopLoss,
         originalPriceTakeProfit: signal.priceTakeProfit,
+        totalExecuted,
     };
 };
 /** Key generator for active position map */
@@ -7554,18 +7813,21 @@ class StrategyCoreService {
          * @param percentToClose - Percentage of position to close (0-100, absolute value)
          * @param currentPrice - Current market price for this partial close (must be in profit direction)
          * @param context - Execution context with strategyName, exchangeName, frameName
-         * @returns Promise that resolves when state is updated and persisted
+         * @returns Promise<boolean> - true if partial close executed, false if skipped
          *
          * @example
          * ```typescript
          * // Close 30% of position at profit
-         * await strategyCoreService.partialProfit(
+         * const success = await strategyCoreService.partialProfit(
          *   false,
          *   "BTCUSDT",
          *   30,
          *   45000,
          *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
          * );
+         * if (success) {
+         *   console.log('Partial profit executed');
+         * }
          * ```
          */
         this.partialProfit = async (backtest, symbol, percentToClose, currentPrice, context) => {
@@ -7592,18 +7854,21 @@ class StrategyCoreService {
          * @param percentToClose - Percentage of position to close (0-100, absolute value)
          * @param currentPrice - Current market price for this partial close (must be in loss direction)
          * @param context - Execution context with strategyName, exchangeName, frameName
-         * @returns Promise that resolves when state is updated and persisted
+         * @returns Promise<boolean> - true if partial close executed, false if skipped
          *
          * @example
          * ```typescript
          * // Close 40% of position at loss
-         * await strategyCoreService.partialLoss(
+         * const success = await strategyCoreService.partialLoss(
          *   false,
          *   "BTCUSDT",
          *   40,
          *   38000,
          *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
          * );
+         * if (success) {
+         *   console.log('Partial loss executed');
+         * }
          * ```
          */
         this.partialLoss = async (backtest, symbol, percentToClose, currentPrice, context) => {
@@ -9038,6 +9303,9 @@ class WalkerLogicPrivateService {
                 stoppedCount: stoppedStrategies.size,
             });
         });
+        // Ensure BacktestMarkdownService is subscribed
+        // to enable statistics collection
+        this.backtestMarkdownService.subscribe();
         try {
             // Run backtest for each strategy
             for (const strategyName of strategies) {
@@ -9530,6 +9798,18 @@ const backtest_columns = [
         format: (data) => `${data.signal.priceStopLoss.toFixed(8)} USD`,
         isVisible: () => true,
     },
+    {
+        key: "originalPriceTakeProfit",
+        label: "Original TP",
+        format: (data) => `${data.signal.originalPriceTakeProfit.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "originalPriceStopLoss",
+        label: "Original SL",
+        format: (data) => `${data.signal.originalPriceStopLoss.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
     {
         key: "pnl",
         label: "PNL (net)",
@@ -9539,6 +9819,12 @@ const backtest_columns = [
         },
         isVisible: () => true,
     },
+    {
+        key: "totalExecuted",
+        label: "Total Executed",
+        format: (data) => `${data.signal.totalExecuted.toFixed(1)}%`,
+        isVisible: () => true,
+    },
     {
         key: "partialCloses",
         label: "Partial Closes",
@@ -9793,6 +10079,28 @@ const live_columns = [
         format: (data) => data.stopLoss !== undefined ? `${data.stopLoss.toFixed(8)} USD` : "N/A",
         isVisible: () => true,
     },
+    {
+        key: "originalPriceTakeProfit",
+        label: "Original TP",
+        format: (data) => data.originalPriceTakeProfit !== undefined
+            ? `${data.originalPriceTakeProfit.toFixed(8)} USD`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "originalPriceStopLoss",
+        label: "Original SL",
+        format: (data) => data.originalPriceStopLoss !== undefined
+            ? `${data.originalPriceStopLoss.toFixed(8)} USD`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "totalExecuted",
+        label: "Total Executed",
+        format: (data) => data.totalExecuted !== undefined ? `${data.totalExecuted.toFixed(1)}%` : "N/A",
+        isVisible: () => true,
+    },
     {
         key: "percentTp",
         label: "% to TP",
@@ -10225,6 +10533,30 @@ const risk_columns = [
             : "N/A",
         isVisible: () => true,
     },
+    {
+        key: "originalPriceTakeProfit",
+        label: "Original TP",
+        format: (data) => data.pendingSignal.originalPriceTakeProfit !== undefined
+            ? `${data.pendingSignal.originalPriceTakeProfit.toFixed(8)} USD`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "originalPriceStopLoss",
+        label: "Original SL",
+        format: (data) => data.pendingSignal.originalPriceStopLoss !== undefined
+            ? `${data.pendingSignal.originalPriceStopLoss.toFixed(8)} USD`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "totalExecuted",
+        label: "Total Executed",
+        format: (data) => data.pendingSignal.totalExecuted !== undefined
+            ? `${data.pendingSignal.totalExecuted.toFixed(1)}%`
+            : "N/A",
+        isVisible: () => true,
+    },
     {
         key: "currentPrice",
         label: "Current Price",
@@ -10359,6 +10691,28 @@ const schedule_columns = [
         format: (data) => `${data.stopLoss.toFixed(8)} USD`,
         isVisible: () => true,
     },
+    {
+        key: "originalPriceTakeProfit",
+        label: "Original TP",
+        format: (data) => data.originalPriceTakeProfit !== undefined
+            ? `${data.originalPriceTakeProfit.toFixed(8)} USD`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "originalPriceStopLoss",
+        label: "Original SL",
+        format: (data) => data.originalPriceStopLoss !== undefined
+            ? `${data.originalPriceStopLoss.toFixed(8)} USD`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "totalExecuted",
+        label: "Total Executed",
+        format: (data) => data.totalExecuted !== undefined ? `${data.totalExecuted.toFixed(1)}%` : "N/A",
+        isVisible: () => true,
+    },
     {
         key: "duration",
         label: "Wait Time (min)",
@@ -10604,77 +10958,482 @@ const COLUMN_CONFIG = {
  */
 const DEFAULT_COLUMNS = Object.freeze({ ...COLUMN_CONFIG });
 
-/**
- * Creates a unique key for memoizing ReportStorage instances.
- * Key format: "symbol:strategyName:exchangeName:frameName:backtest" or "symbol:strategyName:exchangeName:live"
- * @param symbol - Trading pair symbol
- * @param strategyName - Name of the strategy
- * @param exchangeName - Exchange name
- * @param frameName - Frame name
- * @param backtest - Whether running in backtest mode
- * @returns Unique string key for memoization
- */
-const CREATE_KEY_FN$b = (symbol, strategyName, exchangeName, frameName, backtest) => {
-    const parts = [symbol, strategyName, exchangeName];
-    if (frameName)
-        parts.push(frameName);
-    parts.push(backtest ? "backtest" : "live");
-    return parts.join(":");
+var _a$1, _b$1, _c$1;
+const MARKDOWN_METHOD_NAME_ENABLE = "MarkdownUtils.enable";
+const MARKDOWN_METHOD_NAME_USE_ADAPTER = "MarkdownAdapter.useMarkdownAdapter";
+const WAIT_FOR_INIT_SYMBOL$1 = Symbol("wait-for-init");
+const WRITE_SAFE_SYMBOL$1 = Symbol("write-safe");
+/**
+ * Default configuration that enables all markdown services.
+ * Used when no specific configuration is provided to `enable()`.
+ */
+const WILDCARD_TARGET$1 = {
+    backtest: true,
+    breakeven: true,
+    heat: true,
+    live: true,
+    partial: true,
+    performance: true,
+    risk: true,
+    schedule: true,
+    walker: true,
 };
 /**
- * Checks if a value is unsafe for display (not a number, NaN, or Infinity).
+ * JSONL-based markdown adapter with append-only writes.
  *
- * @param value - Value to check
- * @returns true if value is unsafe, false otherwise
+ * Features:
+ * - Writes markdown reports as JSONL entries to a single file per markdown type
+ * - Stream-based writes with backpressure handling
+ * - 15-second timeout protection for write operations
+ * - Automatic directory creation
+ * - Error handling via exitEmitter
+ * - Search metadata for filtering (symbol, strategy, exchange, frame, signalId)
+ *
+ * File format: ./dump/markdown/{markdownName}.jsonl
+ * Each line contains: markdownName, data, symbol, strategyName, exchangeName, frameName, signalId, timestamp
+ *
+ * Use this adapter for centralized logging and post-processing with JSONL tools.
+ */
+const MarkdownFileBase = functoolsKit.makeExtendable((_c$1 = class {
+        /**
+         * Creates a new JSONL markdown adapter instance.
+         *
+         * @param markdownName - Type of markdown report (backtest, live, walker, etc.)
+         */
+        constructor(markdownName) {
+            this.markdownName = markdownName;
+            /** WriteStream instance for append-only writes, null until initialized */
+            this._stream = null;
+            /** Base directory for all JSONL markdown files */
+            this._baseDir = path.join(process.cwd(), "./dump/markdown");
+            /**
+             * Singleshot initialization function that creates directory and stream.
+             * Protected by singleshot to ensure one-time execution.
+             * Sets up error handler that emits to exitEmitter.
+             */
+            this[_a$1] = functoolsKit.singleshot(async () => {
+                await fs__namespace.mkdir(this._baseDir, { recursive: true });
+                this._stream = fs$1.createWriteStream(this._filePath, { flags: "a" });
+                this._stream.on('error', (err) => {
+                    exitEmitter.next(new Error(`MarkdownFileAdapter stream error for markdownName=${this.markdownName} message=${functoolsKit.getErrorMessage(err)}`));
+                });
+            });
+            /**
+             * Timeout-protected write function with backpressure handling.
+             * Waits for drain event if write buffer is full.
+             * Times out after 15 seconds and returns TIMEOUT_SYMBOL.
+             */
+            this[_b$1] = functoolsKit.timeout(async (line) => {
+                if (!this._stream.write(line)) {
+                    await new Promise((resolve) => {
+                        this._stream.once('drain', resolve);
+                    });
+                }
+            }, 15000);
+            this._filePath = path.join(this._baseDir, `${markdownName}.jsonl`);
+        }
+        /**
+         * Initializes the JSONL file and write stream.
+         * Safe to call multiple times - singleshot ensures one-time execution.
+         *
+         * @returns Promise that resolves when initialization is complete
+         */
+        async waitForInit() {
+            await this[WAIT_FOR_INIT_SYMBOL$1]();
+        }
+        /**
+         * Writes markdown content to JSONL file with metadata.
+         * Appends a single line with JSON object containing:
+         * - markdownName: Type of report
+         * - data: Markdown content
+         * - Search flags: symbol, strategyName, exchangeName, frameName, signalId
+         * - timestamp: Current timestamp in milliseconds
+         *
+         * @param data - Markdown content to write
+         * @param options - Path and metadata options
+         * @throws Error if stream not initialized or write timeout exceeded
+         */
+        async dump(data, options) {
+            bt.loggerService.debug("MarkdownFileAdapter.dump", {
+                markdownName: this.markdownName,
+                options,
+            });
+            if (!this._stream) {
+                throw new Error(`Stream not initialized for markdown ${this.markdownName}. Call waitForInit() first.`);
+            }
+            const searchFlags = {};
+            {
+                if (options.symbol) {
+                    searchFlags.symbol = options.symbol;
+                }
+                if (options.strategyName) {
+                    searchFlags.strategyName = options.strategyName;
+                }
+                if (options.exchangeName) {
+                    searchFlags.exchangeName = options.exchangeName;
+                }
+                if (options.frameName) {
+                    searchFlags.frameName = options.frameName;
+                }
+                if (options.signalId) {
+                    searchFlags.signalId = options.signalId;
+                }
+            }
+            const line = JSON.stringify({
+                markdownName: this.markdownName,
+                data,
+                ...searchFlags,
+                timestamp: Date.now(),
+            }) + "\n";
+            const status = await this[WRITE_SAFE_SYMBOL$1](line);
+            if (status === functoolsKit.TIMEOUT_SYMBOL) {
+                throw new Error(`Timeout writing to markdown ${this.markdownName}`);
+            }
+        }
+    },
+    _a$1 = WAIT_FOR_INIT_SYMBOL$1,
+    _b$1 = WRITE_SAFE_SYMBOL$1,
+    _c$1));
+/**
+ * Folder-based markdown adapter with separate files per report.
+ *
+ * Features:
+ * - Writes each markdown report as a separate .md file
+ * - File path based on options.path and options.file
+ * - Automatic directory creation
+ * - No stream management (direct writeFile)
+ * - Suitable for human-readable report directories
+ *
+ * File format: {options.path}/{options.file}
+ * Example: ./dump/backtest/BTCUSDT_my-strategy_binance_2024-Q1_backtest-1736601234567.md
+ *
+ * Use this adapter (default) for organized report directories and manual review.
  */
-function isUnsafe$3(value) {
-    if (typeof value !== "number") {
-        return true;
+const MarkdownFolderBase = functoolsKit.makeExtendable(class {
+    /**
+     * Creates a new folder-based markdown adapter instance.
+     *
+     * @param markdownName - Type of markdown report (backtest, live, walker, etc.)
+     */
+    constructor(markdownName) {
+        this.markdownName = markdownName;
     }
-    if (isNaN(value)) {
-        return true;
+    /**
+     * No-op initialization for folder adapter.
+     * This adapter doesn't need initialization since it uses direct writeFile.
+     *
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit() {
     }
-    if (!isFinite(value)) {
-        return true;
+    /**
+     * Writes markdown content to a separate file.
+     * Creates directory structure automatically.
+     * File path is determined by options.path and options.file.
+     *
+     * @param content - Markdown content to write
+     * @param options - Path and file options for the dump
+     * @throws Error if directory creation or file write fails
+     */
+    async dump(content, options) {
+        bt.loggerService.debug("MarkdownFolderAdapter.dump", {
+            markdownName: this.markdownName,
+            options,
+        });
+        // Combine into full file path
+        const filePath = path.join(process.cwd(), options.path, options.file);
+        // Extract directory from file path
+        const dir = path.dirname(filePath);
+        await fs__namespace.mkdir(dir, { recursive: true });
+        await fs__namespace.writeFile(filePath, content, "utf8");
     }
-    return false;
-}
-/** Maximum number of signals to store in backtest reports */
-const MAX_EVENTS$7 = 250;
+});
 /**
- * Storage class for accumulating closed signals per strategy.
- * Maintains a list of all closed signals and provides methods to generate reports.
+ * Dummy markdown adapter that discards all writes.
+ * Used for disabling markdown report generation.
  */
-let ReportStorage$6 = class ReportStorage {
-    constructor() {
-        /** Internal list of all closed signals for this strategy */
-        this._signalList = [];
-    }
+class MarkdownDummy {
     /**
-     * Adds a closed signal to the storage.
-     *
-     * @param data - Closed signal data with PNL and close reason
+     * No-op dump function.
+     * @returns Promise that resolves immediately
      */
-    addSignal(data) {
-        this._signalList.unshift(data);
-        // Trim queue if exceeded MAX_EVENTS
-        if (this._signalList.length > MAX_EVENTS$7) {
-            this._signalList.pop();
-        }
+    async dump() {
     }
     /**
-     * Calculates statistical data from closed signals (Controller).
-     * Returns null for any unsafe numeric values (NaN, Infinity, etc).
-     *
-     * @returns Statistical data (empty object if no signals)
+     * No-op initialization function.
+     * @returns Promise that resolves immediately
      */
-    async getData() {
-        if (this._signalList.length === 0) {
-            return {
-                signalList: [],
-                totalSignals: 0,
-                winCount: 0,
-                lossCount: 0,
+    async waitForInit() {
+    }
+}
+/**
+ * Utility class for managing markdown report services.
+ *
+ * Provides methods to enable/disable markdown report generation across
+ * different service types (backtest, live, walker, performance, etc.).
+ *
+ * Typically extended by MarkdownAdapter for additional functionality.
+ */
+class MarkdownUtils {
+    constructor() {
+        /**
+         * Enables markdown report services selectively.
+         *
+         * Subscribes to specified markdown services and returns a cleanup function
+         * that unsubscribes from all enabled services at once.
+         *
+         * Each enabled service will:
+         * - Start listening to relevant events
+         * - Accumulate data for reports
+         * - Generate markdown files when requested
+         *
+         * IMPORTANT: Always call the returned unsubscribe function to prevent memory leaks.
+         *
+         * @param config - Service configuration object. Defaults to enabling all services.
+         * @param config.backtest - Enable backtest result reports with full trade history
+         * @param config.breakeven - Enable breakeven event tracking (when stop loss moves to entry)
+         * @param config.partial - Enable partial profit/loss event tracking
+         * @param config.heat - Enable portfolio heatmap analysis across all symbols
+         * @param config.walker - Enable walker strategy comparison and optimization reports
+         * @param config.performance - Enable performance bottleneck analysis
+         * @param config.risk - Enable risk rejection tracking (signals blocked by risk limits)
+         * @param config.schedule - Enable scheduled signal tracking (signals waiting for trigger)
+         * @param config.live - Enable live trading event reports (all tick events)
+         *
+         * @returns Cleanup function that unsubscribes from all enabled services
+         */
+        this.enable = ({ backtest: bt$1 = false, breakeven = false, heat = false, live = false, partial = false, performance = false, risk = false, schedule = false, walker = false, } = WILDCARD_TARGET$1) => {
+            bt.loggerService.debug(MARKDOWN_METHOD_NAME_ENABLE, {
+                backtest: bt$1,
+                breakeven,
+                heat,
+                live,
+                partial,
+                performance,
+                risk,
+                schedule,
+                walker,
+            });
+            const unList = [];
+            if (bt$1) {
+                unList.push(bt.backtestMarkdownService.subscribe());
+            }
+            if (breakeven) {
+                unList.push(bt.breakevenMarkdownService.subscribe());
+            }
+            if (heat) {
+                unList.push(bt.heatMarkdownService.subscribe());
+            }
+            if (live) {
+                unList.push(bt.liveMarkdownService.subscribe());
+            }
+            if (partial) {
+                unList.push(bt.partialMarkdownService.subscribe());
+            }
+            if (performance) {
+                unList.push(bt.performanceMarkdownService.subscribe());
+            }
+            if (risk) {
+                unList.push(bt.riskMarkdownService.subscribe());
+            }
+            if (schedule) {
+                unList.push(bt.scheduleMarkdownService.subscribe());
+            }
+            if (walker) {
+                unList.push(bt.walkerMarkdownService.subscribe());
+            }
+            return functoolsKit.compose(...unList.map((un) => () => void un()));
+        };
+    }
+}
+/**
+ * Markdown adapter with pluggable storage backend and instance memoization.
+ *
+ * Features:
+ * - Adapter pattern for swappable storage implementations
+ * - Memoized storage instances (one per markdown type)
+ * - Default adapter: MarkdownFolderBase (separate files)
+ * - Alternative adapter: MarkdownFileBase (JSONL append)
+ * - Lazy initialization on first write
+ * - Convenience methods: useMd(), useJsonl()
+ */
+class MarkdownAdapter extends MarkdownUtils {
+    constructor() {
+        super(...arguments);
+        /**
+         * Current markdown storage adapter constructor.
+         * Defaults to MarkdownFolderBase for separate file storage.
+         * Can be changed via useMarkdownAdapter().
+         */
+        this.MarkdownFactory = MarkdownFolderBase;
+        /**
+         * Memoized storage instances cache.
+         * Key: markdownName (backtest, live, walker, etc.)
+         * Value: TMarkdownBase instance created with current MarkdownFactory.
+         * Ensures single instance per markdown type for the lifetime of the application.
+         */
+        this.getMarkdownStorage = functoolsKit.memoize(([markdownName]) => markdownName, (markdownName) => Reflect.construct(this.MarkdownFactory, [markdownName]));
+    }
+    /**
+     * Sets the markdown storage adapter constructor.
+     * All future markdown instances will use this adapter.
+     *
+     * @param Ctor - Constructor for markdown storage adapter
+     */
+    useMarkdownAdapter(Ctor) {
+        bt.loggerService.info(MARKDOWN_METHOD_NAME_USE_ADAPTER);
+        this.MarkdownFactory = Ctor;
+    }
+    /**
+     * Writes markdown data to storage using the configured adapter.
+     * Automatically initializes storage on first write for each markdown type.
+     *
+     * @param markdownName - Type of markdown report (backtest, live, walker, etc.)
+     * @param content - Markdown content to write
+     * @param options - Path, file, and metadata options
+     * @returns Promise that resolves when write is complete
+     * @throws Error if write fails or storage initialization fails
+     *
+     * @internal - Use service-specific dump methods instead (e.g., Backtest.dump)
+     */
+    async writeData(markdownName, content, options) {
+        bt.loggerService.debug("MarkdownAdapter.writeData", {
+            markdownName,
+            options,
+        });
+        const isInitial = !this.getMarkdownStorage.has(markdownName);
+        const markdown = this.getMarkdownStorage(markdownName);
+        await markdown.waitForInit(isInitial);
+        await markdown.dump(content, options);
+    }
+    /**
+     * Switches to folder-based markdown storage (default).
+     * Shorthand for useMarkdownAdapter(MarkdownFolderBase).
+     * Each dump creates a separate .md file.
+     */
+    useMd() {
+        bt.loggerService.debug("MarkdownAdapter.useMd");
+        this.useMarkdownAdapter(MarkdownFolderBase);
+    }
+    /**
+     * Switches to JSONL-based markdown storage.
+     * Shorthand for useMarkdownAdapter(MarkdownFileBase).
+     * All dumps append to a single .jsonl file per markdown type.
+     */
+    useJsonl() {
+        bt.loggerService.debug("MarkdownAdapter.useJsonl");
+        this.useMarkdownAdapter(MarkdownFileBase);
+    }
+    /**
+     * Switches to a dummy markdown adapter that discards all writes.
+     * All future markdown writes will be no-ops.
+     */
+    useDummy() {
+        bt.loggerService.debug("MarkdownAdapter.useDummy");
+        this.useMarkdownAdapter(MarkdownDummy);
+    }
+}
+/**
+ * Global singleton instance of MarkdownAdapter.
+ * Provides markdown report generation with pluggable storage backends.
+ */
+const Markdown = new MarkdownAdapter();
+
+/**
+ * Creates a unique key for memoizing ReportStorage instances.
+ * Key format: "symbol:strategyName:exchangeName:frameName:backtest" or "symbol:strategyName:exchangeName:live"
+ * @param symbol - Trading pair symbol
+ * @param strategyName - Name of the strategy
+ * @param exchangeName - Exchange name
+ * @param frameName - Frame name
+ * @param backtest - Whether running in backtest mode
+ * @returns Unique string key for memoization
+ */
+const CREATE_KEY_FN$b = (symbol, strategyName, exchangeName, frameName, backtest) => {
+    const parts = [symbol, strategyName, exchangeName];
+    if (frameName)
+        parts.push(frameName);
+    parts.push(backtest ? "backtest" : "live");
+    return parts.join(":");
+};
+/**
+ * Creates a filename for markdown report based on memoization key components.
+ * Filename format: "symbol_strategyName_exchangeName_frameName-timestamp.md"
+ * @param symbol - Trading pair symbol
+ * @param strategyName - Name of the strategy
+ * @param exchangeName - Exchange name
+ * @param frameName - Frame name
+ * @param timestamp - Unix timestamp in milliseconds
+ * @returns Filename string
+ */
+const CREATE_FILE_NAME_FN$8 = (symbol, strategyName, exchangeName, frameName, timestamp) => {
+    const parts = [symbol, strategyName, exchangeName];
+    if (frameName) {
+        parts.push(frameName);
+        parts.push("backtest");
+    }
+    else
+        parts.push("live");
+    return `${parts.join("_")}-${timestamp}.md`;
+};
+/**
+ * Checks if a value is unsafe for display (not a number, NaN, or Infinity).
+ *
+ * @param value - Value to check
+ * @returns true if value is unsafe, false otherwise
+ */
+function isUnsafe$3(value) {
+    if (typeof value !== "number") {
+        return true;
+    }
+    if (isNaN(value)) {
+        return true;
+    }
+    if (!isFinite(value)) {
+        return true;
+    }
+    return false;
+}
+/** Maximum number of signals to store in backtest reports */
+const MAX_EVENTS$7 = 250;
+/**
+ * Storage class for accumulating closed signals per strategy.
+ * Maintains a list of all closed signals and provides methods to generate reports.
+ */
+let ReportStorage$6 = class ReportStorage {
+    constructor(symbol, strategyName, exchangeName, frameName) {
+        this.symbol = symbol;
+        this.strategyName = strategyName;
+        this.exchangeName = exchangeName;
+        this.frameName = frameName;
+        /** Internal list of all closed signals for this strategy */
+        this._signalList = [];
+    }
+    /**
+     * Adds a closed signal to the storage.
+     *
+     * @param data - Closed signal data with PNL and close reason
+     */
+    addSignal(data) {
+        this._signalList.unshift(data);
+        // Trim queue if exceeded MAX_EVENTS
+        if (this._signalList.length > MAX_EVENTS$7) {
+            this._signalList.pop();
+        }
+    }
+    /**
+     * Calculates statistical data from closed signals (Controller).
+     * Returns null for any unsafe numeric values (NaN, Infinity, etc).
+     *
+     * @returns Statistical data (empty object if no signals)
+     */
+    async getData() {
+        if (this._signalList.length === 0) {
+            return {
+                signalList: [],
+                totalSignals: 0,
+                winCount: 0,
+                lossCount: 0,
                 winRate: null,
                 avgPnl: null,
                 totalPnl: null,
@@ -10779,19 +11538,19 @@ let ReportStorage$6 = class ReportStorage {
      * @param path - Directory path to save report (default: "./dump/backtest")
      * @param columns - Column configuration for formatting the table
      */
-    async dump(strategyName, path$1 = "./dump/backtest", columns = COLUMN_CONFIG.backtest_columns) {
+    async dump(strategyName, path = "./dump/backtest", columns = COLUMN_CONFIG.backtest_columns) {
         const markdown = await this.getReport(strategyName, columns);
-        try {
-            const dir = path.join(process.cwd(), path$1);
-            await fs.mkdir(dir, { recursive: true });
-            const filename = `${strategyName}.md`;
-            const filepath = path.join(dir, filename);
-            await fs.writeFile(filepath, markdown, "utf-8");
-            console.log(`Backtest report saved: ${filepath}`);
-        }
-        catch (error) {
-            console.error(`Failed to save markdown report:`, error);
-        }
+        const timestamp = Date.now();
+        const filename = CREATE_FILE_NAME_FN$8(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
+        await Markdown.writeData("backtest", markdown, {
+            path,
+            file: filename,
+            symbol: this.symbol,
+            strategyName: this.strategyName,
+            exchangeName: this.exchangeName,
+            frameName: this.frameName,
+            signalId: "",
+        });
     }
 };
 /**
@@ -10829,7 +11588,7 @@ class BacktestMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$b(symbol, strategyName, exchangeName, frameName, backtest), () => new ReportStorage$6());
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$b(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$6(symbol, strategyName, exchangeName, frameName));
         /**
          * Processes tick events and accumulates closed signals.
          * Should be called from IStrategyCallbacks.onTick.
@@ -10885,6 +11644,9 @@ class BacktestMarkdownService {
                 frameName,
                 backtest,
             });
+            if (!this.subscribe.hasValue()) {
+                throw new Error("BacktestMarkdownService not initialized. Call subscribe() before getting data.");
+            }
             const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             return storage.getData();
         };
@@ -10915,6 +11677,9 @@ class BacktestMarkdownService {
                 frameName,
                 backtest,
             });
+            if (!this.subscribe.hasValue()) {
+                throw new Error("BacktestMarkdownService not initialized. Call subscribe() before generating reports.");
+            }
             const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             return storage.getReport(strategyName, columns);
         };
@@ -10951,6 +11716,9 @@ class BacktestMarkdownService {
                 backtest,
                 path,
             });
+            if (!this.subscribe.hasValue()) {
+                throw new Error("BacktestMarkdownService not initialized. Call subscribe() before dumping reports.");
+            }
             const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             await storage.dump(strategyName, path, columns);
         };
@@ -10985,20 +11753,47 @@ class BacktestMarkdownService {
             }
         };
         /**
-         * Initializes the service by subscribing to backtest signal events.
-         * Uses singleshot to ensure initialization happens only once.
-         * Automatically called on first use.
+         * Subscribes to backtest signal emitter to receive tick events.
+         * Protected against multiple subscriptions.
+         * Returns an unsubscribe function to stop receiving events.
          *
          * @example
          * ```typescript
          * const service = new BacktestMarkdownService();
-         * await service.init(); // Subscribe to backtest events
+         * const unsubscribe = service.subscribe();
+         * // ... later
+         * unsubscribe();
          * ```
          */
-        this.init = functoolsKit.singleshot(async () => {
+        this.subscribe = functoolsKit.singleshot(() => {
             this.loggerService.log("backtestMarkdownService init");
-            this.unsubscribe = signalBacktestEmitter.subscribe(this.tick);
+            const unsubscribe = signalBacktestEmitter.subscribe(this.tick);
+            return () => {
+                this.subscribe.clear();
+                this.clear();
+                unsubscribe();
+            };
         });
+        /**
+         * Unsubscribes from backtest signal emitter to stop receiving tick events.
+         * Calls the unsubscribe function returned by subscribe().
+         * If not subscribed, does nothing.
+         *
+         * @example
+         * ```typescript
+         * const service = new BacktestMarkdownService();
+         * service.subscribe();
+         * // ... later
+         * service.unsubscribe();
+         * ```
+         */
+        this.unsubscribe = async () => {
+            this.loggerService.log("backtestMarkdownService unsubscribe");
+            if (this.subscribe.hasValue()) {
+                const lastSubscription = this.subscribe();
+                lastSubscription();
+            }
+        };
     }
 }
 
@@ -11019,6 +11814,26 @@ const CREATE_KEY_FN$a = (symbol, strategyName, exchangeName, frameName, backtest
     parts.push(backtest ? "backtest" : "live");
     return parts.join(":");
 };
+/**
+ * Creates a filename for markdown report based on memoization key components.
+ * Filename format: "symbol_strategyName_exchangeName_frameName-timestamp.md"
+ * @param symbol - Trading pair symbol
+ * @param strategyName - Name of the strategy
+ * @param exchangeName - Exchange name
+ * @param frameName - Frame name
+ * @param timestamp - Unix timestamp in milliseconds
+ * @returns Filename string
+ */
+const CREATE_FILE_NAME_FN$7 = (symbol, strategyName, exchangeName, frameName, timestamp) => {
+    const parts = [symbol, strategyName, exchangeName];
+    if (frameName) {
+        parts.push(frameName);
+        parts.push("backtest");
+    }
+    else
+        parts.push("live");
+    return `${parts.join("_")}-${timestamp}.md`;
+};
 /**
  * Checks if a value is unsafe for display (not a number, NaN, or Infinity).
  *
@@ -11044,7 +11859,11 @@ const MAX_EVENTS$6 = 250;
  * Maintains a chronological list of all events (idle, opened, active, closed).
  */
 let ReportStorage$5 = class ReportStorage {
-    constructor() {
+    constructor(symbol, strategyName, exchangeName, frameName) {
+        this.symbol = symbol;
+        this.strategyName = strategyName;
+        this.exchangeName = exchangeName;
+        this.frameName = frameName;
         /** Internal list of all tick events for this strategy */
         this._eventList = [];
     }
@@ -11093,6 +11912,9 @@ let ReportStorage$5 = class ReportStorage {
             openPrice: data.signal.priceOpen,
             takeProfit: data.signal.priceTakeProfit,
             stopLoss: data.signal.priceStopLoss,
+            originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
+            originalPriceStopLoss: data.signal.originalPriceStopLoss,
+            totalExecuted: data.signal.totalExecuted,
         });
         // Trim queue if exceeded MAX_EVENTS
         if (this._eventList.length > MAX_EVENTS$6) {
@@ -11117,8 +11939,12 @@ let ReportStorage$5 = class ReportStorage {
             openPrice: data.signal.priceOpen,
             takeProfit: data.signal.priceTakeProfit,
             stopLoss: data.signal.priceStopLoss,
+            originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
+            originalPriceStopLoss: data.signal.originalPriceStopLoss,
+            totalExecuted: data.signal.totalExecuted,
             percentTp: data.percentTp,
             percentSl: data.percentSl,
+            pnl: data.pnl.pnlPercentage,
         };
         // Find the last active event with the same signalId
         const lastActiveIndex = this._eventList.findLastIndex((event) => event.action === "active" && event.signalId === data.signal.id);
@@ -11153,6 +11979,9 @@ let ReportStorage$5 = class ReportStorage {
             openPrice: data.signal.priceOpen,
             takeProfit: data.signal.priceTakeProfit,
             stopLoss: data.signal.priceStopLoss,
+            originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
+            originalPriceStopLoss: data.signal.originalPriceStopLoss,
+            totalExecuted: data.signal.totalExecuted,
             pnl: data.pnl.pnlPercentage,
             closeReason: data.closeReason,
             duration: durationMin,
@@ -11295,19 +12124,19 @@ let ReportStorage$5 = class ReportStorage {
      * @param path - Directory path to save report (default: "./dump/live")
      * @param columns - Column configuration for formatting the table
      */
-    async dump(strategyName, path$1 = "./dump/live", columns = COLUMN_CONFIG.live_columns) {
+    async dump(strategyName, path = "./dump/live", columns = COLUMN_CONFIG.live_columns) {
         const markdown = await this.getReport(strategyName, columns);
-        try {
-            const dir = path.join(process.cwd(), path$1);
-            await fs.mkdir(dir, { recursive: true });
-            const filename = `${strategyName}.md`;
-            const filepath = path.join(dir, filename);
-            await fs.writeFile(filepath, markdown, "utf-8");
-            console.log(`Live trading report saved: ${filepath}`);
-        }
-        catch (error) {
-            console.error(`Failed to save markdown report:`, error);
-        }
+        const timestamp = Date.now();
+        const filename = CREATE_FILE_NAME_FN$7(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
+        await Markdown.writeData("live", markdown, {
+            path,
+            signalId: "",
+            file: filename,
+            symbol: this.symbol,
+            strategyName: this.strategyName,
+            exchangeName: this.exchangeName,
+            frameName: this.frameName
+        });
     }
 };
 /**
@@ -11348,7 +12177,49 @@ class LiveMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$a(symbol, strategyName, exchangeName, frameName, backtest), () => new ReportStorage$5());
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$a(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$5(symbol, strategyName, exchangeName, frameName));
+        /**
+         * Subscribes to live signal emitter to receive tick events.
+         * Protected against multiple subscriptions.
+         * Returns an unsubscribe function to stop receiving events.
+         *
+         * @example
+         * ```typescript
+         * const service = new LiveMarkdownService();
+         * const unsubscribe = service.subscribe();
+         * // ... later
+         * unsubscribe();
+         * ```
+         */
+        this.subscribe = functoolsKit.singleshot(() => {
+            this.loggerService.log("liveMarkdownService init");
+            const unsubscribe = signalLiveEmitter.subscribe(this.tick);
+            return () => {
+                this.subscribe.clear();
+                this.clear();
+                unsubscribe();
+            };
+        });
+        /**
+         * Unsubscribes from live signal emitter to stop receiving tick events.
+         * Calls the unsubscribe function returned by subscribe().
+         * If not subscribed, does nothing.
+         *
+         * @example
+         * ```typescript
+         * const service = new LiveMarkdownService();
+         * service.subscribe();
+         * // ... later
+         * service.unsubscribe();
+         * ```
+         */
+        this.unsubscribe = async () => {
+            this.loggerService.log("liveMarkdownService unsubscribe");
+            if (this.subscribe.hasValue()) {
+                const lastSubscription = this.subscribe();
+                lastSubscription();
+            }
+        };
         /**
          * Processes tick events and accumulates all event types.
          * Should be called from IStrategyCallbacks.onTick.
@@ -11414,6 +12285,9 @@ class LiveMarkdownService {
                 frameName,
                 backtest,
             });
+            if (!this.subscribe.hasValue()) {
+                throw new Error("LiveMarkdownService not initialized. Call subscribe() before getting data.");
+            }
             const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             return storage.getData();
         };
@@ -11444,6 +12318,9 @@ class LiveMarkdownService {
                 frameName,
                 backtest,
             });
+            if (!this.subscribe.hasValue()) {
+                throw new Error("LiveMarkdownService not initialized. Call subscribe() before generating reports.");
+            }
             const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             return storage.getReport(strategyName, columns);
         };
@@ -11480,6 +12357,9 @@ class LiveMarkdownService {
                 backtest,
                 path,
             });
+            if (!this.subscribe.hasValue()) {
+                throw new Error("LiveMarkdownService not initialized. Call subscribe() before dumping reports.");
+            }
             const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             await storage.dump(strategyName, path, columns);
         };
@@ -11513,21 +12393,6 @@ class LiveMarkdownService {
                 this.getStorage.clear();
             }
         };
-        /**
-         * Initializes the service by subscribing to live signal events.
-         * Uses singleshot to ensure initialization happens only once.
-         * Automatically called on first use.
-         *
-         * @example
-         * ```typescript
-         * const service = new LiveMarkdownService();
-         * await service.init(); // Subscribe to live events
-         * ```
-         */
-        this.init = functoolsKit.singleshot(async () => {
-            this.loggerService.log("liveMarkdownService init");
-            this.unsubscribe = signalLiveEmitter.subscribe(this.tick);
-        });
     }
 }
 
@@ -11548,6 +12413,26 @@ const CREATE_KEY_FN$9 = (symbol, strategyName, exchangeName, frameName, backtest
     parts.push(backtest ? "backtest" : "live");
     return parts.join(":");
 };
+/**
+ * Creates a filename for markdown report based on memoization key components.
+ * Filename format: "symbol_strategyName_exchangeName_frameName-timestamp.md"
+ * @param symbol - Trading pair symbol
+ * @param strategyName - Name of the strategy
+ * @param exchangeName - Exchange name
+ * @param frameName - Frame name
+ * @param timestamp - Unix timestamp in milliseconds
+ * @returns Filename string
+ */
+const CREATE_FILE_NAME_FN$6 = (symbol, strategyName, exchangeName, frameName, timestamp) => {
+    const parts = [symbol, strategyName, exchangeName];
+    if (frameName) {
+        parts.push(frameName);
+        parts.push("backtest");
+    }
+    else
+        parts.push("live");
+    return `${parts.join("_")}-${timestamp}.md`;
+};
 /** Maximum number of events to store in schedule reports */
 const MAX_EVENTS$5 = 250;
 /**
@@ -11555,7 +12440,11 @@ const MAX_EVENTS$5 = 250;
  * Maintains a chronological list of scheduled and cancelled events.
  */
 let ReportStorage$4 = class ReportStorage {
-    constructor() {
+    constructor(symbol, strategyName, exchangeName, frameName) {
+        this.symbol = symbol;
+        this.strategyName = strategyName;
+        this.exchangeName = exchangeName;
+        this.frameName = frameName;
         /** Internal list of all scheduled events for this strategy */
         this._eventList = [];
     }
@@ -11576,6 +12465,9 @@ let ReportStorage$4 = class ReportStorage {
             priceOpen: data.signal.priceOpen,
             takeProfit: data.signal.priceTakeProfit,
             stopLoss: data.signal.priceStopLoss,
+            originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
+            originalPriceStopLoss: data.signal.originalPriceStopLoss,
+            totalExecuted: data.signal.totalExecuted,
         });
         // Trim queue if exceeded MAX_EVENTS
         if (this._eventList.length > MAX_EVENTS$5) {
@@ -11601,6 +12493,9 @@ let ReportStorage$4 = class ReportStorage {
             priceOpen: data.signal.priceOpen,
             takeProfit: data.signal.priceTakeProfit,
             stopLoss: data.signal.priceStopLoss,
+            originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
+            originalPriceStopLoss: data.signal.originalPriceStopLoss,
+            totalExecuted: data.signal.totalExecuted,
             duration: durationMin,
         };
         this._eventList.unshift(newEvent);
@@ -11628,6 +12523,9 @@ let ReportStorage$4 = class ReportStorage {
             priceOpen: data.signal.priceOpen,
             takeProfit: data.signal.priceTakeProfit,
             stopLoss: data.signal.priceStopLoss,
+            originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
+            originalPriceStopLoss: data.signal.originalPriceStopLoss,
+            totalExecuted: data.signal.totalExecuted,
             closeTimestamp: data.closeTimestamp,
             duration: durationMin,
             cancelReason: data.reason,
@@ -11739,19 +12637,19 @@ let ReportStorage$4 = class ReportStorage {
      * @param path - Directory path to save report (default: "./dump/schedule")
      * @param columns - Column configuration for formatting the table
      */
-    async dump(strategyName, path$1 = "./dump/schedule", columns = COLUMN_CONFIG.schedule_columns) {
+    async dump(strategyName, path = "./dump/schedule", columns = COLUMN_CONFIG.schedule_columns) {
         const markdown = await this.getReport(strategyName, columns);
-        try {
-            const dir = path.join(process.cwd(), path$1);
-            await fs.mkdir(dir, { recursive: true });
-            const filename = `${strategyName}.md`;
-            const filepath = path.join(dir, filename);
-            await fs.writeFile(filepath, markdown, "utf-8");
-            console.log(`Scheduled signals report saved: ${filepath}`);
-        }
-        catch (error) {
-            console.error(`Failed to save markdown report:`, error);
-        }
+        const timestamp = Date.now();
+        const filename = CREATE_FILE_NAME_FN$6(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
+        await Markdown.writeData("schedule", markdown, {
+            path,
+            file: filename,
+            symbol: this.symbol,
+            signalId: "",
+            strategyName: this.strategyName,
+            exchangeName: this.exchangeName,
+            frameName: this.frameName
+        });
     }
 };
 /**
@@ -11783,28 +12681,70 @@ class ScheduleMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$9(symbol, strategyName, exchangeName, frameName, backtest), () => new ReportStorage$4());
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$9(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$4(symbol, strategyName, exchangeName, frameName));
         /**
-         * Processes tick events and accumulates scheduled/opened/cancelled events.
-         * Should be called from signalEmitter subscription.
-         *
-         * Processes only scheduled, opened and cancelled event types.
-         *
-         * @param data - Tick result from strategy execution with frameName wrapper
+         * Subscribes to signal emitter to receive scheduled signal events.
+         * Protected against multiple subscriptions.
+         * Returns an unsubscribe function to stop receiving events.
          *
          * @example
          * ```typescript
          * const service = new ScheduleMarkdownService();
-         * // Service automatically subscribes in init()
+         * const unsubscribe = service.subscribe();
+         * // ... later
+         * unsubscribe();
          * ```
          */
-        this.tick = async (data) => {
-            this.loggerService.log("scheduleMarkdownService tick", {
-                data,
-            });
-            const storage = this.getStorage(data.symbol, data.strategyName, data.exchangeName, data.frameName, data.backtest);
-            if (data.action === "scheduled") {
-                storage.addScheduledEvent(data);
+        this.subscribe = functoolsKit.singleshot(() => {
+            this.loggerService.log("scheduleMarkdownService init");
+            const unsubscribe = signalEmitter.subscribe(this.tick);
+            return () => {
+                this.subscribe.clear();
+                this.clear();
+                unsubscribe();
+            };
+        });
+        /**
+         * Unsubscribes from signal emitter to stop receiving scheduled signal events.
+         * Calls the unsubscribe function returned by subscribe().
+         * If not subscribed, does nothing.
+         *
+         * @example
+         * ```typescript
+         * const service = new ScheduleMarkdownService();
+         * service.subscribe();
+         * // ... later
+         * service.unsubscribe();
+         * ```
+         */
+        this.unsubscribe = async () => {
+            this.loggerService.log("scheduleMarkdownService unsubscribe");
+            if (this.subscribe.hasValue()) {
+                const lastSubscription = this.subscribe();
+                lastSubscription();
+            }
+        };
+        /**
+         * Processes tick events and accumulates scheduled/opened/cancelled events.
+         * Should be called from signalEmitter subscription.
+         *
+         * Processes only scheduled, opened and cancelled event types.
+         *
+         * @param data - Tick result from strategy execution with frameName wrapper
+         *
+         * @example
+         * ```typescript
+         * const service = new ScheduleMarkdownService();
+         * // Service automatically subscribes in init()
+         * ```
+         */
+        this.tick = async (data) => {
+            this.loggerService.log("scheduleMarkdownService tick", {
+                data,
+            });
+            const storage = this.getStorage(data.symbol, data.strategyName, data.exchangeName, data.frameName, data.backtest);
+            if (data.action === "scheduled") {
+                storage.addScheduledEvent(data);
             }
             else if (data.action === "opened") {
                 // Check if this opened signal was previously scheduled
@@ -11843,6 +12783,9 @@ class ScheduleMarkdownService {
                 frameName,
                 backtest,
             });
+            if (!this.subscribe.hasValue()) {
+                throw new Error("ScheduleMarkdownService not initialized. Call subscribe() before getting data.");
+            }
             const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             return storage.getData();
         };
@@ -11873,6 +12816,9 @@ class ScheduleMarkdownService {
                 frameName,
                 backtest,
             });
+            if (!this.subscribe.hasValue()) {
+                throw new Error("ScheduleMarkdownService not initialized. Call subscribe() before generating reports.");
+            }
             const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             return storage.getReport(strategyName, columns);
         };
@@ -11909,6 +12855,9 @@ class ScheduleMarkdownService {
                 backtest,
                 path,
             });
+            if (!this.subscribe.hasValue()) {
+                throw new Error("ScheduleMarkdownService not initialized. Call subscribe() before dumping reports.");
+            }
             const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             await storage.dump(strategyName, path, columns);
         };
@@ -11942,21 +12891,6 @@ class ScheduleMarkdownService {
                 this.getStorage.clear();
             }
         };
-        /**
-         * Initializes the service by subscribing to live signal events.
-         * Uses singleshot to ensure initialization happens only once.
-         * Automatically called on first use.
-         *
-         * @example
-         * ```typescript
-         * const service = new ScheduleMarkdownService();
-         * await service.init(); // Subscribe to live events
-         * ```
-         */
-        this.init = functoolsKit.singleshot(async () => {
-            this.loggerService.log("scheduleMarkdownService init");
-            this.unsubscribe = signalEmitter.subscribe(this.tick);
-        });
     }
 }
 
@@ -11977,6 +12911,26 @@ const CREATE_KEY_FN$8 = (symbol, strategyName, exchangeName, frameName, backtest
     parts.push(backtest ? "backtest" : "live");
     return parts.join(":");
 };
+/**
+ * Creates a filename for markdown report based on memoization key components.
+ * Filename format: "symbol_strategyName_exchangeName_frameName-timestamp.md"
+ * @param symbol - Trading pair symbol
+ * @param strategyName - Name of the strategy
+ * @param exchangeName - Exchange name
+ * @param frameName - Frame name
+ * @param timestamp - Unix timestamp in milliseconds
+ * @returns Filename string
+ */
+const CREATE_FILE_NAME_FN$5 = (symbol, strategyName, exchangeName, frameName, timestamp) => {
+    const parts = [symbol, strategyName, exchangeName];
+    if (frameName) {
+        parts.push(frameName);
+        parts.push("backtest");
+    }
+    else
+        parts.push("live");
+    return `${parts.join("_")}-${timestamp}.md`;
+};
 /**
  * Calculates percentile value from sorted array.
  */
@@ -11993,7 +12947,11 @@ const MAX_EVENTS$4 = 10000;
  * Maintains a list of all performance events and provides aggregated statistics.
  */
 class PerformanceStorage {
-    constructor() {
+    constructor(symbol, strategyName, exchangeName, frameName) {
+        this.symbol = symbol;
+        this.strategyName = strategyName;
+        this.exchangeName = exchangeName;
+        this.frameName = frameName;
         /** Internal list of all performance events for this strategy */
         this._events = [];
     }
@@ -12144,19 +13102,19 @@ class PerformanceStorage {
      * @param path - Directory path to save report
      * @param columns - Column configuration for formatting the table
      */
-    async dump(strategyName, path$1 = "./dump/performance", columns = COLUMN_CONFIG.performance_columns) {
+    async dump(strategyName, path = "./dump/performance", columns = COLUMN_CONFIG.performance_columns) {
         const markdown = await this.getReport(strategyName, columns);
-        try {
-            const dir = path.join(process.cwd(), path$1);
-            await fs.mkdir(dir, { recursive: true });
-            const filename = `${strategyName}.md`;
-            const filepath = path.join(dir, filename);
-            await fs.writeFile(filepath, markdown, "utf-8");
-            console.log(`Performance report saved: ${filepath}`);
-        }
-        catch (error) {
-            console.error(`Failed to save performance report:`, error);
-        }
+        const timestamp = Date.now();
+        const filename = CREATE_FILE_NAME_FN$5(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
+        await Markdown.writeData("performance", markdown, {
+            path,
+            file: filename,
+            symbol: this.symbol,
+            signalId: "",
+            strategyName: this.strategyName,
+            exchangeName: this.exchangeName,
+            frameName: this.frameName
+        });
     }
 }
 /**
@@ -12194,7 +13152,49 @@ class PerformanceMarkdownService {
          * Memoized function to get or create PerformanceStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$8(symbol, strategyName, exchangeName, frameName, backtest), () => new PerformanceStorage());
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$8(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new PerformanceStorage(symbol, strategyName, exchangeName, frameName));
+        /**
+         * Subscribes to performance emitter to receive performance events.
+         * Protected against multiple subscriptions.
+         * Returns an unsubscribe function to stop receiving events.
+         *
+         * @example
+         * ```typescript
+         * const service = new PerformanceMarkdownService();
+         * const unsubscribe = service.subscribe();
+         * // ... later
+         * unsubscribe();
+         * ```
+         */
+        this.subscribe = functoolsKit.singleshot(() => {
+            this.loggerService.log("performanceMarkdownService init");
+            const unsubscribe = performanceEmitter.subscribe(this.track);
+            return () => {
+                this.subscribe.clear();
+                this.clear();
+                unsubscribe();
+            };
+        });
+        /**
+         * Unsubscribes from performance emitter to stop receiving events.
+         * Calls the unsubscribe function returned by subscribe().
+         * If not subscribed, does nothing.
+         *
+         * @example
+         * ```typescript
+         * const service = new PerformanceMarkdownService();
+         * service.subscribe();
+         * // ... later
+         * service.unsubscribe();
+         * ```
+         */
+        this.unsubscribe = async () => {
+            this.loggerService.log("performanceMarkdownService unsubscribe");
+            if (this.subscribe.hasValue()) {
+                const lastSubscription = this.subscribe();
+                lastSubscription();
+            }
+        };
         /**
          * Processes performance events and accumulates metrics.
          * Should be called from performance tracking code.
@@ -12237,6 +13237,9 @@ class PerformanceMarkdownService {
                 frameName,
                 backtest,
             });
+            if (!this.subscribe.hasValue()) {
+                throw new Error("PerformanceMarkdownService not initialized. Call subscribe() before getting data.");
+            }
             const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             return storage.getData(strategyName);
         };
@@ -12265,6 +13268,9 @@ class PerformanceMarkdownService {
                 frameName,
                 backtest,
             });
+            if (!this.subscribe.hasValue()) {
+                throw new Error("PerformanceMarkdownService not initialized. Call subscribe() before generating reports.");
+            }
             const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             return storage.getReport(strategyName, columns);
         };
@@ -12297,6 +13303,9 @@ class PerformanceMarkdownService {
                 backtest,
                 path,
             });
+            if (!this.subscribe.hasValue()) {
+                throw new Error("PerformanceMarkdownService not initialized. Call subscribe() before dumping reports.");
+            }
             const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             await storage.dump(strategyName, path, columns);
         };
@@ -12317,17 +13326,16 @@ class PerformanceMarkdownService {
                 this.getStorage.clear();
             }
         };
-        /**
-         * Initializes the service by subscribing to performance events.
-         * Uses singleshot to ensure initialization happens only once.
-         */
-        this.init = functoolsKit.singleshot(async () => {
-            this.loggerService.log("performanceMarkdownService init");
-            this.unsubscribe = performanceEmitter.subscribe(this.track);
-        });
     }
 }
 
+/**
+ * Creates a filename for markdown report based on walker name.
+ * Filename format: "walkerName-timestamp.md"
+ */
+const CREATE_FILE_NAME_FN$4 = (walkerName, timestamp) => {
+    return `${walkerName}-${timestamp}.md`;
+};
 /**
  * Checks if a value is unsafe for display (not a number, NaN, or Infinity).
  */
@@ -12545,19 +13553,19 @@ let ReportStorage$3 = class ReportStorage {
      * @param strategyColumns - Column configuration for strategy comparison table
      * @param pnlColumns - Column configuration for PNL table
      */
-    async dump(symbol, metric, context, path$1 = "./dump/walker", strategyColumns = COLUMN_CONFIG.walker_strategy_columns, pnlColumns = COLUMN_CONFIG.walker_pnl_columns) {
+    async dump(symbol, metric, context, path = "./dump/walker", strategyColumns = COLUMN_CONFIG.walker_strategy_columns, pnlColumns = COLUMN_CONFIG.walker_pnl_columns) {
         const markdown = await this.getReport(symbol, metric, context, strategyColumns, pnlColumns);
-        try {
-            const dir = path.join(process.cwd(), path$1);
-            await fs.mkdir(dir, { recursive: true });
-            const filename = `${this.walkerName}.md`;
-            const filepath = path.join(dir, filename);
-            await fs.writeFile(filepath, markdown, "utf-8");
-            console.log(`Walker report saved: ${filepath}`);
-        }
-        catch (error) {
-            console.error(`Failed to save walker report:`, error);
-        }
+        const timestamp = Date.now();
+        const filename = CREATE_FILE_NAME_FN$4(this.walkerName, timestamp);
+        await Markdown.writeData("walker", markdown, {
+            path,
+            file: filename,
+            symbol: "",
+            signalId: "",
+            strategyName: "",
+            exchangeName: "",
+            frameName: ""
+        });
     }
 };
 /**
@@ -12585,6 +13593,48 @@ class WalkerMarkdownService {
          * Each walker gets its own isolated storage instance.
          */
         this.getStorage = functoolsKit.memoize(([walkerName]) => `${walkerName}`, (walkerName) => new ReportStorage$3(walkerName));
+        /**
+         * Subscribes to walker emitter to receive walker progress events.
+         * Protected against multiple subscriptions.
+         * Returns an unsubscribe function to stop receiving events.
+         *
+         * @example
+         * ```typescript
+         * const service = new WalkerMarkdownService();
+         * const unsubscribe = service.subscribe();
+         * // ... later
+         * unsubscribe();
+         * ```
+         */
+        this.subscribe = functoolsKit.singleshot(() => {
+            this.loggerService.log("walkerMarkdownService init");
+            const unsubscribe = walkerEmitter.subscribe(this.tick);
+            return () => {
+                this.subscribe.clear();
+                this.clear();
+                unsubscribe();
+            };
+        });
+        /**
+         * Unsubscribes from walker emitter to stop receiving events.
+         * Calls the unsubscribe function returned by subscribe().
+         * If not subscribed, does nothing.
+         *
+         * @example
+         * ```typescript
+         * const service = new WalkerMarkdownService();
+         * service.subscribe();
+         * // ... later
+         * service.unsubscribe();
+         * ```
+         */
+        this.unsubscribe = async () => {
+            this.loggerService.log("walkerMarkdownService unsubscribe");
+            if (this.subscribe.hasValue()) {
+                const lastSubscription = this.subscribe();
+                lastSubscription();
+            }
+        };
         /**
          * Processes walker progress events and accumulates strategy results.
          * Should be called from walkerEmitter.
@@ -12628,6 +13678,9 @@ class WalkerMarkdownService {
                 metric,
                 context,
             });
+            if (!this.subscribe.hasValue()) {
+                throw new Error("WalkerMarkdownService not initialized. Call subscribe() before getting data.");
+            }
             const storage = this.getStorage(walkerName);
             return storage.getData(symbol, metric, context);
         };
@@ -12657,6 +13710,9 @@ class WalkerMarkdownService {
                 metric,
                 context,
             });
+            if (!this.subscribe.hasValue()) {
+                throw new Error("WalkerMarkdownService not initialized. Call subscribe() before generating reports.");
+            }
             const storage = this.getStorage(walkerName);
             return storage.getReport(symbol, metric, context, strategyColumns, pnlColumns);
         };
@@ -12692,6 +13748,9 @@ class WalkerMarkdownService {
                 context,
                 path,
             });
+            if (!this.subscribe.hasValue()) {
+                throw new Error("WalkerMarkdownService not initialized. Call subscribe() before dumping reports.");
+            }
             const storage = this.getStorage(walkerName);
             await storage.dump(symbol, metric, context, path, strategyColumns, pnlColumns);
         };
@@ -12719,21 +13778,6 @@ class WalkerMarkdownService {
             });
             this.getStorage.clear(walkerName);
         };
-        /**
-         * Initializes the service by subscribing to walker events.
-         * Uses singleshot to ensure initialization happens only once.
-         * Automatically called on first use.
-         *
-         * @example
-         * ```typescript
-         * const service = new WalkerMarkdownService();
-         * await service.init(); // Subscribe to walker events
-         * ```
-         */
-        this.init = functoolsKit.singleshot(async () => {
-            this.loggerService.log("walkerMarkdownService init");
-            this.unsubscribe = walkerEmitter.subscribe(this.tick);
-        });
     }
 }
 
@@ -12752,6 +13796,20 @@ const CREATE_KEY_FN$7 = (exchangeName, frameName, backtest) => {
     parts.push(backtest ? "backtest" : "live");
     return parts.join(":");
 };
+/**
+ * Creates a filename for markdown report based on memoization key components.
+ * Filename format: "strategyName_exchangeName_frameName-timestamp.md"
+ */
+const CREATE_FILE_NAME_FN$3 = (strategyName, exchangeName, frameName, timestamp) => {
+    const parts = [strategyName, exchangeName];
+    if (frameName) {
+        parts.push(frameName);
+        parts.push("backtest");
+    }
+    else
+        parts.push("live");
+    return `${parts.join("_")}-${timestamp}.md`;
+};
 const HEATMAP_METHOD_NAME_GET_DATA = "HeatMarkdownService.getData";
 const HEATMAP_METHOD_NAME_GET_REPORT = "HeatMarkdownService.getReport";
 const HEATMAP_METHOD_NAME_DUMP = "HeatMarkdownService.dump";
@@ -12781,7 +13839,10 @@ const MAX_EVENTS$3 = 250;
  * Maintains symbol-level statistics and provides portfolio-wide metrics.
  */
 class HeatmapStorage {
-    constructor() {
+    constructor(exchangeName, frameName, backtest) {
+        this.exchangeName = exchangeName;
+        this.frameName = frameName;
+        this.backtest = backtest;
         /** Internal storage of closed signals per symbol */
         this.symbolData = new Map();
     }
@@ -13046,19 +14107,19 @@ class HeatmapStorage {
      * @param path - Directory path to save report (default: "./dump/heatmap")
      * @param columns - Column configuration for formatting the table
      */
-    async dump(strategyName, path$1 = "./dump/heatmap", columns = COLUMN_CONFIG.heat_columns) {
+    async dump(strategyName, path = "./dump/heatmap", columns = COLUMN_CONFIG.heat_columns) {
         const markdown = await this.getReport(strategyName, columns);
-        try {
-            const dir = path.join(process.cwd(), path$1);
-            await fs.mkdir(dir, { recursive: true });
-            const filename = `${strategyName}.md`;
-            const filepath = path.join(dir, filename);
-            await fs.writeFile(filepath, markdown, "utf-8");
-            console.log(`Heatmap report saved: ${filepath}`);
-        }
-        catch (error) {
-            console.error(`Failed to save heatmap report:`, error);
-        }
+        const timestamp = Date.now();
+        const filename = CREATE_FILE_NAME_FN$3(strategyName, this.exchangeName, this.frameName, timestamp);
+        await Markdown.writeData("heat", markdown, {
+            path,
+            file: filename,
+            symbol: "",
+            strategyName: "",
+            signalId: "",
+            exchangeName: this.exchangeName,
+            frameName: this.frameName
+        });
     }
 }
 /**
@@ -13095,7 +14156,49 @@ class HeatMarkdownService {
          * Memoized function to get or create HeatmapStorage for exchange, frame and backtest mode.
          * Each exchangeName + frameName + backtest mode combination gets its own isolated heatmap storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([exchangeName, frameName, backtest]) => CREATE_KEY_FN$7(exchangeName, frameName, backtest), () => new HeatmapStorage());
+        this.getStorage = functoolsKit.memoize(([exchangeName, frameName, backtest]) => CREATE_KEY_FN$7(exchangeName, frameName, backtest), (exchangeName, frameName, backtest) => new HeatmapStorage(exchangeName, frameName, backtest));
+        /**
+         * Subscribes to signal emitter to receive tick events.
+         * Protected against multiple subscriptions.
+         * Returns an unsubscribe function to stop receiving events.
+         *
+         * @example
+         * ```typescript
+         * const service = new HeatMarkdownService();
+         * const unsubscribe = service.subscribe();
+         * // ... later
+         * unsubscribe();
+         * ```
+         */
+        this.subscribe = functoolsKit.singleshot(() => {
+            this.loggerService.log("heatMarkdownService init");
+            const unsubscribe = signalEmitter.subscribe(this.tick);
+            return () => {
+                this.subscribe.clear();
+                this.clear();
+                unsubscribe();
+            };
+        });
+        /**
+         * Unsubscribes from signal emitter to stop receiving tick events.
+         * Calls the unsubscribe function returned by subscribe().
+         * If not subscribed, does nothing.
+         *
+         * @example
+         * ```typescript
+         * const service = new HeatMarkdownService();
+         * service.subscribe();
+         * // ... later
+         * service.unsubscribe();
+         * ```
+         */
+        this.unsubscribe = async () => {
+            this.loggerService.log("heatMarkdownService unsubscribe");
+            if (this.subscribe.hasValue()) {
+                const lastSubscription = this.subscribe();
+                lastSubscription();
+            }
+        };
         /**
          * Processes tick events and accumulates closed signals.
          * Should be called from signal emitter subscription.
@@ -13141,6 +14244,9 @@ class HeatMarkdownService {
                 frameName,
                 backtest,
             });
+            if (!this.subscribe.hasValue()) {
+                throw new Error("HeatMarkdownService not initialized. Call subscribe() before getting data.");
+            }
             const storage = this.getStorage(exchangeName, frameName, backtest);
             return storage.getData();
         };
@@ -13178,6 +14284,9 @@ class HeatMarkdownService {
                 frameName,
                 backtest,
             });
+            if (!this.subscribe.hasValue()) {
+                throw new Error("HeatMarkdownService not initialized. Call subscribe() before generating reports.");
+            }
             const storage = this.getStorage(exchangeName, frameName, backtest);
             return storage.getReport(strategyName, columns);
         };
@@ -13213,6 +14322,9 @@ class HeatMarkdownService {
                 backtest,
                 path,
             });
+            if (!this.subscribe.hasValue()) {
+                throw new Error("HeatMarkdownService not initialized. Call subscribe() before dumping reports.");
+            }
             const storage = this.getStorage(exchangeName, frameName, backtest);
             await storage.dump(strategyName, path, columns);
         };
@@ -13246,21 +14358,6 @@ class HeatMarkdownService {
                 this.getStorage.clear();
             }
         };
-        /**
-         * Initializes the service by subscribing to signal events.
-         * Uses singleshot to ensure initialization happens only once.
-         * Automatically called on first use.
-         *
-         * @example
-         * ```typescript
-         * const service = new HeatMarkdownService();
-         * await service.init(); // Subscribe to signal events
-         * ```
-         */
-        this.init = functoolsKit.singleshot(async () => {
-            this.loggerService.log("heatMarkdownService init");
-            this.unsubscribe = signalEmitter.subscribe(this.tick);
-        });
     }
 }
 
@@ -15677,6 +16774,20 @@ const CREATE_KEY_FN$5 = (symbol, strategyName, exchangeName, frameName, backtest
     parts.push(backtest ? "backtest" : "live");
     return parts.join(":");
 };
+/**
+ * Creates a filename for markdown report based on memoization key components.
+ * Filename format: "symbol_strategyName_exchangeName_frameName-timestamp.md"
+ */
+const CREATE_FILE_NAME_FN$2 = (symbol, strategyName, exchangeName, frameName, timestamp) => {
+    const parts = [symbol, strategyName, exchangeName];
+    if (frameName) {
+        parts.push(frameName);
+        parts.push("backtest");
+    }
+    else
+        parts.push("live");
+    return `${parts.join("_")}-${timestamp}.md`;
+};
 /** Maximum number of events to store in partial reports */
 const MAX_EVENTS$2 = 250;
 /**
@@ -15684,7 +16795,11 @@ const MAX_EVENTS$2 = 250;
  * Maintains a chronological list of profit and loss level events.
  */
 let ReportStorage$2 = class ReportStorage {
-    constructor() {
+    constructor(symbol, strategyName, exchangeName, frameName) {
+        this.symbol = symbol;
+        this.strategyName = strategyName;
+        this.exchangeName = exchangeName;
+        this.frameName = frameName;
         /** Internal list of all partial events for this symbol */
         this._eventList = [];
     }
@@ -15807,19 +16922,19 @@ let ReportStorage$2 = class ReportStorage {
      * @param path - Directory path to save report (default: "./dump/partial")
      * @param columns - Column configuration for formatting the table
      */
-    async dump(symbol, strategyName, path$1 = "./dump/partial", columns = COLUMN_CONFIG.partial_columns) {
+    async dump(symbol, strategyName, path = "./dump/partial", columns = COLUMN_CONFIG.partial_columns) {
         const markdown = await this.getReport(symbol, strategyName, columns);
-        try {
-            const dir = path.join(process.cwd(), path$1);
-            await fs.mkdir(dir, { recursive: true });
-            const filename = `${symbol}_${strategyName}.md`;
-            const filepath = path.join(dir, filename);
-            await fs.writeFile(filepath, markdown, "utf-8");
-            console.log(`Partial profit/loss report saved: ${filepath}`);
-        }
-        catch (error) {
-            console.error(`Failed to save markdown report:`, error);
-        }
+        const timestamp = Date.now();
+        const filename = CREATE_FILE_NAME_FN$2(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
+        await Markdown.writeData("partial", markdown, {
+            path,
+            file: filename,
+            symbol: this.symbol,
+            signalId: "",
+            strategyName: this.strategyName,
+            exchangeName: this.exchangeName,
+            frameName: this.frameName
+        });
     }
 };
 /**
@@ -15851,7 +16966,51 @@ class PartialMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$5(symbol, strategyName, exchangeName, frameName, backtest), () => new ReportStorage$2());
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$5(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$2(symbol, strategyName, exchangeName, frameName));
+        /**
+         * Subscribes to partial profit/loss signal emitters to receive events.
+         * Protected against multiple subscriptions.
+         * Returns an unsubscribe function to stop receiving events.
+         *
+         * @example
+         * ```typescript
+         * const service = new PartialMarkdownService();
+         * const unsubscribe = service.subscribe();
+         * // ... later
+         * unsubscribe();
+         * ```
+         */
+        this.subscribe = functoolsKit.singleshot(() => {
+            this.loggerService.log("partialMarkdownService init");
+            const unProfit = partialProfitSubject.subscribe(this.tickProfit);
+            const unLoss = partialLossSubject.subscribe(this.tickLoss);
+            return () => {
+                this.subscribe.clear();
+                this.clear();
+                unProfit();
+                unLoss();
+            };
+        });
+        /**
+         * Unsubscribes from partial profit/loss signal emitters to stop receiving events.
+         * Calls the unsubscribe function returned by subscribe().
+         * If not subscribed, does nothing.
+         *
+         * @example
+         * ```typescript
+         * const service = new PartialMarkdownService();
+         * service.subscribe();
+         * // ... later
+         * service.unsubscribe();
+         * ```
+         */
+        this.unsubscribe = async () => {
+            this.loggerService.log("partialMarkdownService unsubscribe");
+            if (this.subscribe.hasValue()) {
+                const lastSubscription = this.subscribe();
+                lastSubscription();
+            }
+        };
         /**
          * Processes profit events and accumulates them.
          * Should be called from partialProfitSubject subscription.
@@ -15916,6 +17075,9 @@ class PartialMarkdownService {
                 frameName,
                 backtest,
             });
+            if (!this.subscribe.hasValue()) {
+                throw new Error("PartialMarkdownService not initialized. Call subscribe() before getting data.");
+            }
             const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             return storage.getData();
         };
@@ -15946,6 +17108,9 @@ class PartialMarkdownService {
                 frameName,
                 backtest,
             });
+            if (!this.subscribe.hasValue()) {
+                throw new Error("PartialMarkdownService not initialized. Call subscribe() before generating reports.");
+            }
             const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             return storage.getReport(symbol, strategyName, columns);
         };
@@ -15982,6 +17147,9 @@ class PartialMarkdownService {
                 backtest,
                 path,
             });
+            if (!this.subscribe.hasValue()) {
+                throw new Error("PartialMarkdownService not initialized. Call subscribe() before dumping reports.");
+            }
             const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             await storage.dump(symbol, strategyName, path, columns);
         };
@@ -16015,23 +17183,6 @@ class PartialMarkdownService {
                 this.getStorage.clear();
             }
         };
-        /**
-         * Initializes the service by subscribing to partial profit/loss events.
-         * Uses singleshot to ensure initialization happens only once.
-         * Automatically called on first use.
-         *
-         * @example
-         * ```typescript
-         * const service = new PartialMarkdownService();
-         * await service.init(); // Subscribe to profit/loss events
-         * ```
-         */
-        this.init = functoolsKit.singleshot(async () => {
-            this.loggerService.log("partialMarkdownService init");
-            const unProfit = partialProfitSubject.subscribe(this.tickProfit);
-            const unLoss = partialLossSubject.subscribe(this.tickLoss);
-            this.unsubscribe = functoolsKit.compose(() => unProfit(), () => unLoss());
-        });
     }
 }
 
@@ -16715,6 +17866,20 @@ const CREATE_KEY_FN$3 = (symbol, strategyName, exchangeName, frameName, backtest
     parts.push(backtest ? "backtest" : "live");
     return parts.join(":");
 };
+/**
+ * Creates a filename for markdown report based on memoization key components.
+ * Filename format: "symbol_strategyName_exchangeName_frameName-timestamp.md"
+ */
+const CREATE_FILE_NAME_FN$1 = (symbol, strategyName, exchangeName, frameName, timestamp) => {
+    const parts = [symbol, strategyName, exchangeName];
+    if (frameName) {
+        parts.push(frameName);
+        parts.push("backtest");
+    }
+    else
+        parts.push("live");
+    return `${parts.join("_")}-${timestamp}.md`;
+};
 /** Maximum number of events to store in breakeven reports */
 const MAX_EVENTS$1 = 250;
 /**
@@ -16722,7 +17887,11 @@ const MAX_EVENTS$1 = 250;
  * Maintains a chronological list of breakeven events.
  */
 let ReportStorage$1 = class ReportStorage {
-    constructor() {
+    constructor(symbol, strategyName, exchangeName, frameName) {
+        this.symbol = symbol;
+        this.strategyName = strategyName;
+        this.exchangeName = exchangeName;
+        this.frameName = frameName;
         /** Internal list of all breakeven events for this symbol */
         this._eventList = [];
     }
@@ -16811,19 +17980,19 @@ let ReportStorage$1 = class ReportStorage {
      * @param path - Directory path to save report (default: "./dump/breakeven")
      * @param columns - Column configuration for formatting the table
      */
-    async dump(symbol, strategyName, path$1 = "./dump/breakeven", columns = COLUMN_CONFIG.breakeven_columns) {
+    async dump(symbol, strategyName, path = "./dump/breakeven", columns = COLUMN_CONFIG.breakeven_columns) {
         const markdown = await this.getReport(symbol, strategyName, columns);
-        try {
-            const dir = path.join(process.cwd(), path$1);
-            await fs.mkdir(dir, { recursive: true });
-            const filename = `${symbol}_${strategyName}.md`;
-            const filepath = path.join(dir, filename);
-            await fs.writeFile(filepath, markdown, "utf-8");
-            console.log(`Breakeven report saved: ${filepath}`);
-        }
-        catch (error) {
-            console.error(`Failed to save markdown report:`, error);
-        }
+        const timestamp = Date.now();
+        const filename = CREATE_FILE_NAME_FN$1(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
+        await Markdown.writeData("breakeven", markdown, {
+            path,
+            file: filename,
+            symbol: this.symbol,
+            strategyName: this.strategyName,
+            exchangeName: this.exchangeName,
+            signalId: "",
+            frameName: this.frameName
+        });
     }
 };
 /**
@@ -16855,7 +18024,49 @@ class BreakevenMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$3(symbol, strategyName, exchangeName, frameName, backtest), () => new ReportStorage$1());
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$3(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$1(symbol, strategyName, exchangeName, frameName));
+        /**
+         * Subscribes to breakeven signal emitter to receive events.
+         * Protected against multiple subscriptions.
+         * Returns an unsubscribe function to stop receiving events.
+         *
+         * @example
+         * ```typescript
+         * const service = new BreakevenMarkdownService();
+         * const unsubscribe = service.subscribe();
+         * // ... later
+         * unsubscribe();
+         * ```
+         */
+        this.subscribe = functoolsKit.singleshot(() => {
+            this.loggerService.log("breakevenMarkdownService init");
+            const unBreakeven = breakevenSubject.subscribe(this.tickBreakeven);
+            return () => {
+                this.subscribe.clear();
+                this.clear();
+                unBreakeven();
+            };
+        });
+        /**
+         * Unsubscribes from breakeven signal emitter to stop receiving events.
+         * Calls the unsubscribe function returned by subscribe().
+         * If not subscribed, does nothing.
+         *
+         * @example
+         * ```typescript
+         * const service = new BreakevenMarkdownService();
+         * service.subscribe();
+         * // ... later
+         * service.unsubscribe();
+         * ```
+         */
+        this.unsubscribe = async () => {
+            this.loggerService.log("breakevenMarkdownService unsubscribe");
+            if (this.subscribe.hasValue()) {
+                const lastSubscription = this.subscribe();
+                lastSubscription();
+            }
+        };
         /**
          * Processes breakeven events and accumulates them.
          * Should be called from breakevenSubject subscription.
@@ -16901,6 +18112,9 @@ class BreakevenMarkdownService {
                 frameName,
                 backtest,
             });
+            if (!this.subscribe.hasValue()) {
+                throw new Error("BreakevenMarkdownService not initialized. Call subscribe() before getting data.");
+            }
             const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             return storage.getData();
         };
@@ -16931,6 +18145,9 @@ class BreakevenMarkdownService {
                 frameName,
                 backtest,
             });
+            if (!this.subscribe.hasValue()) {
+                throw new Error("BreakevenMarkdownService not initialized. Call subscribe() before generating reports.");
+            }
             const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             return storage.getReport(symbol, strategyName, columns);
         };
@@ -16967,6 +18184,9 @@ class BreakevenMarkdownService {
                 backtest,
                 path,
             });
+            if (!this.subscribe.hasValue()) {
+                throw new Error("BreakevenMarkdownService not initialized. Call subscribe() before dumping reports.");
+            }
             const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             await storage.dump(symbol, strategyName, path, columns);
         };
@@ -17000,22 +18220,6 @@ class BreakevenMarkdownService {
                 this.getStorage.clear();
             }
         };
-        /**
-         * Initializes the service by subscribing to breakeven events.
-         * Uses singleshot to ensure initialization happens only once.
-         * Automatically called on first use.
-         *
-         * @example
-         * ```typescript
-         * const service = new BreakevenMarkdownService();
-         * await service.init(); // Subscribe to breakeven events
-         * ```
-         */
-        this.init = functoolsKit.singleshot(async () => {
-            this.loggerService.log("breakevenMarkdownService init");
-            const unBreakeven = breakevenSubject.subscribe(this.tickBreakeven);
-            this.unsubscribe = functoolsKit.compose(() => unBreakeven());
-        });
     }
 }
 
@@ -17169,18 +18373,12 @@ const WARN_KB = 30;
  * @param outputDir - Output directory path (default: "./dump/strategy")
  * @returns Promise that resolves when all files are written
  */
-const DUMP_SIGNAL_FN = async (signalId, history, signal, outputDir = "./dump/strategy") => {
+const DUMP_SIGNAL_FN = async (signalId, history, signal, outputDir = "./dump/outline") => {
     // Extract system messages and system reminders from existing data
     const systemMessages = history.filter((m) => m.role === "system");
     const userMessages = history.filter((m) => m.role === "user");
     const subfolderPath = path.join(outputDir, String(signalId));
-    try {
-        await fs$1.promises.access(subfolderPath);
-        return;
-    }
-    catch {
-        await fs$1.promises.mkdir(subfolderPath, { recursive: true });
-    }
+    // Generate system prompt markdown
     {
         let summary = "# Outline Result Summary\n";
         {
@@ -17203,14 +18401,21 @@ const DUMP_SIGNAL_FN = async (signalId, history, signal, outputDir = "./dump/str
                 summary += "\n";
             });
         }
-        const summaryFile = path.join(subfolderPath, "00_system_prompt.md");
-        await fs$1.promises.writeFile(summaryFile, summary, "utf8");
+        await Markdown.writeData("outline", summary, {
+            path: subfolderPath,
+            file: "00_system_prompt.md",
+            symbol: "",
+            signalId: String(signalId),
+            strategyName: "",
+            exchangeName: "",
+            frameName: ""
+        });
     }
+    // Generate user messages
     {
         await Promise.all(Array.from(userMessages.entries()).map(async ([idx, message]) => {
             const messageNum = String(idx + 1).padStart(2, "0");
             const contentFileName = `${messageNum}_user_message.md`;
-            const contentFilePath = path.join(subfolderPath, contentFileName);
             {
                 const messageSizeBytes = Buffer.byteLength(message.content, "utf8");
                 const messageSizeKb = Math.floor(messageSizeBytes / 1024);
@@ -17222,13 +18427,21 @@ const DUMP_SIGNAL_FN = async (signalId, history, signal, outputDir = "./dump/str
             content += `**ResultId**: ${String(signalId)}\n\n`;
             content += message.content;
             content += "\n";
-            await fs$1.promises.writeFile(contentFilePath, content, "utf8");
+            await Markdown.writeData("outline", content, {
+                path: subfolderPath,
+                file: contentFileName,
+                signalId: String(signalId),
+                symbol: "",
+                strategyName: "",
+                exchangeName: "",
+                frameName: ""
+            });
         }));
     }
+    // Generate LLM output
     {
         const messageNum = String(userMessages.length + 1).padStart(2, "0");
         const contentFileName = `${messageNum}_llm_output.md`;
-        const contentFilePath = path.join(subfolderPath, contentFileName);
         let content = "# Full Outline Result\n\n";
         content += `**ResultId**: ${String(signalId)}\n\n`;
         if (signal) {
@@ -17237,7 +18450,15 @@ const DUMP_SIGNAL_FN = async (signalId, history, signal, outputDir = "./dump/str
             content += JSON.stringify(signal, null, 2);
             content += "\n```\n";
         }
-        await fs$1.promises.writeFile(contentFilePath, content, "utf8");
+        await Markdown.writeData("outline", content, {
+            path: subfolderPath,
+            file: contentFileName,
+            symbol: "",
+            signalId: String(signalId),
+            strategyName: "",
+            exchangeName: "",
+            frameName: ""
+        });
     }
 };
 /**
@@ -17303,7 +18524,7 @@ class OutlineMarkdownService {
  *   (slippage + fees) to guarantee profitable trades when TakeProfit is hit
  * - **Range constraints**: Validates MIN < MAX relationships (e.g., StopLoss distances)
  * - **Time-based parameters**: Ensures positive integer values for timeouts and lifetimes
- * - **Candle parameters**: Validates retry counts, delays, and anomaly detection thresholds
+ * - **Candle parameters**: Validates retry counts, delays, anomaly detection thresholds, and max candles per request
  *
  * @throws {Error} If any validation fails, throws with detailed breakdown of all errors
  *
@@ -17412,6 +18633,9 @@ class ConfigValidationService {
             if (!Number.isInteger(GLOBAL_CONFIG.CC_GET_CANDLES_MIN_CANDLES_FOR_MEDIAN) || GLOBAL_CONFIG.CC_GET_CANDLES_MIN_CANDLES_FOR_MEDIAN <= 0) {
                 errors.push(`CC_GET_CANDLES_MIN_CANDLES_FOR_MEDIAN must be a positive integer, got ${GLOBAL_CONFIG.CC_GET_CANDLES_MIN_CANDLES_FOR_MEDIAN}`);
             }
+            if (!Number.isInteger(GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST) || GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST <= 0) {
+                errors.push(`CC_MAX_CANDLES_PER_REQUEST must be a positive integer, got ${GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST}`);
+            }
             // Throw aggregated errors if any
             if (errors.length > 0) {
                 const errorMessage = `GLOBAL_CONFIG validation failed:\n${errors.map((e, i) => `  ${i + 1}. ${e}`).join('\n')}`;
@@ -17440,6 +18664,20 @@ const CREATE_KEY_FN$2 = (symbol, strategyName, exchangeName, frameName, backtest
     parts.push(backtest ? "backtest" : "live");
     return parts.join(":");
 };
+/**
+ * Creates a filename for markdown report based on memoization key components.
+ * Filename format: "symbol_strategyName_exchangeName_frameName-timestamp.md"
+ */
+const CREATE_FILE_NAME_FN = (symbol, strategyName, exchangeName, frameName, timestamp) => {
+    const parts = [symbol, strategyName, exchangeName];
+    if (frameName) {
+        parts.push(frameName);
+        parts.push("backtest");
+    }
+    else
+        parts.push("live");
+    return `${parts.join("_")}-${timestamp}.md`;
+};
 /** Maximum number of events to store in risk reports */
 const MAX_EVENTS = 250;
 /**
@@ -17447,7 +18685,11 @@ const MAX_EVENTS = 250;
  * Maintains a chronological list of rejected signals due to risk limits.
  */
 class ReportStorage {
-    constructor() {
+    constructor(symbol, strategyName, exchangeName, frameName) {
+        this.symbol = symbol;
+        this.strategyName = strategyName;
+        this.exchangeName = exchangeName;
+        this.frameName = frameName;
         /** Internal list of all risk rejection events for this symbol */
         this._eventList = [];
     }
@@ -17540,19 +18782,19 @@ class ReportStorage {
      * @param path - Directory path to save report (default: "./dump/risk")
      * @param columns - Column configuration for formatting the table
      */
-    async dump(symbol, strategyName, path$1 = "./dump/risk", columns = COLUMN_CONFIG.risk_columns) {
+    async dump(symbol, strategyName, path = "./dump/risk", columns = COLUMN_CONFIG.risk_columns) {
         const markdown = await this.getReport(symbol, strategyName, columns);
-        try {
-            const dir = path.join(process.cwd(), path$1);
-            await fs.mkdir(dir, { recursive: true });
-            const filename = `${symbol}_${strategyName}.md`;
-            const filepath = path.join(dir, filename);
-            await fs.writeFile(filepath, markdown, "utf-8");
-            console.log(`Risk rejection report saved: ${filepath}`);
-        }
-        catch (error) {
-            console.error(`Failed to save markdown report:`, error);
-        }
+        const timestamp = Date.now();
+        const filename = CREATE_FILE_NAME_FN(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
+        await Markdown.writeData("risk", markdown, {
+            path,
+            file: filename,
+            symbol: this.symbol,
+            signalId: "",
+            strategyName: this.strategyName,
+            exchangeName: this.exchangeName,
+            frameName: this.frameName
+        });
     }
 }
 /**
@@ -17584,7 +18826,49 @@ class RiskMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$2(symbol, strategyName, exchangeName, frameName, backtest), () => new ReportStorage());
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$2(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage(symbol, strategyName, exchangeName, frameName));
+        /**
+         * Subscribes to risk rejection emitter to receive rejection events.
+         * Protected against multiple subscriptions.
+         * Returns an unsubscribe function to stop receiving events.
+         *
+         * @example
+         * ```typescript
+         * const service = new RiskMarkdownService();
+         * const unsubscribe = service.subscribe();
+         * // ... later
+         * unsubscribe();
+         * ```
+         */
+        this.subscribe = functoolsKit.singleshot(() => {
+            this.loggerService.log("riskMarkdownService init");
+            const unsubscribe = riskSubject.subscribe(this.tickRejection);
+            return () => {
+                this.subscribe.clear();
+                this.clear();
+                unsubscribe();
+            };
+        });
+        /**
+         * Unsubscribes from risk rejection emitter to stop receiving events.
+         * Calls the unsubscribe function returned by subscribe().
+         * If not subscribed, does nothing.
+         *
+         * @example
+         * ```typescript
+         * const service = new RiskMarkdownService();
+         * service.subscribe();
+         * // ... later
+         * service.unsubscribe();
+         * ```
+         */
+        this.unsubscribe = async () => {
+            this.loggerService.log("riskMarkdownService unsubscribe");
+            if (this.subscribe.hasValue()) {
+                const lastSubscription = this.subscribe();
+                lastSubscription();
+            }
+        };
         /**
          * Processes risk rejection events and accumulates them.
          * Should be called from riskSubject subscription.
@@ -17630,6 +18914,9 @@ class RiskMarkdownService {
                 frameName,
                 backtest,
             });
+            if (!this.subscribe.hasValue()) {
+                throw new Error("RiskMarkdownService not initialized. Call subscribe() before getting data.");
+            }
             const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             return storage.getData();
         };
@@ -17660,201 +18947,1219 @@ class RiskMarkdownService {
                 frameName,
                 backtest,
             });
-            const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
-            return storage.getReport(symbol, strategyName, columns);
+            if (!this.subscribe.hasValue()) {
+                throw new Error("RiskMarkdownService not initialized. Call subscribe() before generating reports.");
+            }
+            const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
+            return storage.getReport(symbol, strategyName, columns);
+        };
+        /**
+         * Saves symbol-strategy report to disk.
+         * Creates directory if it doesn't exist.
+         * Delegates to ReportStorage.dump().
+         *
+         * @param symbol - Trading pair symbol to save report for
+         * @param strategyName - Strategy name to save report for
+         * @param exchangeName - Exchange name
+         * @param frameName - Frame name
+         * @param backtest - True if backtest mode, false if live mode
+         * @param path - Directory path to save report (default: "./dump/risk")
+         * @param columns - Column configuration for formatting the table
+         *
+         * @example
+         * ```typescript
+         * const service = new RiskMarkdownService();
+         *
+         * // Save to default path: ./dump/risk/BTCUSDT_my-strategy.md
+         * await service.dump("BTCUSDT", "my-strategy", "binance", "1h", false);
+         *
+         * // Save to custom path: ./custom/path/BTCUSDT_my-strategy.md
+         * await service.dump("BTCUSDT", "my-strategy", "binance", "1h", false, "./custom/path");
+         * ```
+         */
+        this.dump = async (symbol, strategyName, exchangeName, frameName, backtest, path = "./dump/risk", columns = COLUMN_CONFIG.risk_columns) => {
+            this.loggerService.log("riskMarkdownService dump", {
+                symbol,
+                strategyName,
+                exchangeName,
+                frameName,
+                backtest,
+                path,
+            });
+            if (!this.subscribe.hasValue()) {
+                throw new Error("RiskMarkdownService not initialized. Call subscribe() before dumping reports.");
+            }
+            const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
+            await storage.dump(symbol, strategyName, path, columns);
+        };
+        /**
+         * Clears accumulated event data from storage.
+         * If payload is provided, clears only that specific symbol-strategy-exchange-frame-backtest combination's data.
+         * If nothing is provided, clears all data.
+         *
+         * @param payload - Optional payload with symbol, strategyName, exchangeName, frameName, backtest
+         *
+         * @example
+         * ```typescript
+         * const service = new RiskMarkdownService();
+         *
+         * // Clear specific combination
+         * await service.clear({ symbol: "BTCUSDT", strategyName: "my-strategy", exchangeName: "binance", frameName: "1h", backtest: false });
+         *
+         * // Clear all data
+         * await service.clear();
+         * ```
+         */
+        this.clear = async (payload) => {
+            this.loggerService.log("riskMarkdownService clear", {
+                payload,
+            });
+            if (payload) {
+                const key = CREATE_KEY_FN$2(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                this.getStorage.clear(key);
+            }
+            else {
+                this.getStorage.clear();
+            }
+        };
+    }
+}
+
+/**
+ * Service for validating column configurations to ensure consistency with ColumnModel interface
+ * and prevent invalid column definitions.
+ *
+ * Performs comprehensive validation on all column definitions in COLUMN_CONFIG:
+ * - **Required fields**: All columns must have key, label, format, and isVisible properties
+ * - **Unique keys**: All key values must be unique within each column collection
+ * - **Function validation**: format and isVisible must be callable functions
+ * - **Data types**: key and label must be non-empty strings
+ *
+ * @throws {Error} If any validation fails, throws with detailed breakdown of all errors
+ *
+ * @example
+ * ```typescript
+ * const validator = new ColumnValidationService();
+ * validator.validate(); // Throws if column configuration is invalid
+ * ```
+ *
+ * @example Validation failure output:
+ * ```
+ * Column configuration validation failed:
+ *   1. backtest_columns[0]: Missing required field "format"
+ *   2. heat_columns: Duplicate key "symbol" at indexes 1, 5
+ *   3. live_columns[3].isVisible must be a function, got "boolean"
+ * ```
+ */
+class ColumnValidationService {
+    constructor() {
+        /**
+         * @private
+         * @readonly
+         * Injected logger service instance
+         */
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Validates all column configurations in COLUMN_CONFIG for structural correctness.
+         *
+         * Checks:
+         * 1. All required fields (key, label, format, isVisible) are present in each column
+         * 2. key and label are non-empty strings
+         * 3. format and isVisible are functions (not other types)
+         * 4. All keys are unique within each column collection
+         *
+         * @throws Error if configuration is invalid
+         */
+        this.validate = () => {
+            this.loggerService.log("columnValidationService validate");
+            const errors = [];
+            // Iterate through all column collections in COLUMN_CONFIG
+            for (const [configKey, columns] of Object.entries(COLUMN_CONFIG)) {
+                if (!Array.isArray(columns)) {
+                    errors.push(`${configKey} is not an array, got ${typeof columns}`);
+                    continue;
+                }
+                // Track keys for uniqueness check
+                const keyMap = new Map();
+                // Validate each column in the collection
+                columns.forEach((column, index) => {
+                    if (!column || typeof column !== "object") {
+                        errors.push(`${configKey}[${index}]: Column must be an object, got ${typeof column}`);
+                        return;
+                    }
+                    // Check for all required fields
+                    const requiredFields = ["key", "label", "format", "isVisible"];
+                    for (const field of requiredFields) {
+                        if (!(field in column)) {
+                            errors.push(`${configKey}[${index}]: Missing required field "${field}"`);
+                        }
+                    }
+                    // Validate key and label are non-empty strings
+                    if (typeof column.key !== "string" || column.key.trim() === "") {
+                        errors.push(`${configKey}[${index}].key must be a non-empty string, got ${typeof column.key === "string" ? `"${column.key}"` : typeof column.key}`);
+                    }
+                    else {
+                        // Track key for uniqueness check
+                        if (!keyMap.has(column.key)) {
+                            keyMap.set(column.key, []);
+                        }
+                        keyMap.get(column.key).push(index);
+                    }
+                    if (typeof column.label !== "string" || column.label.trim() === "") {
+                        errors.push(`${configKey}[${index}].label must be a non-empty string, got ${typeof column.label === "string" ? `"${column.label}"` : typeof column.label}`);
+                    }
+                    // Validate format is a function
+                    if (typeof column.format !== "function") {
+                        errors.push(`${configKey}[${index}].format must be a function, got "${typeof column.format}"`);
+                    }
+                    // Validate isVisible is a function
+                    if (typeof column.isVisible !== "function") {
+                        errors.push(`${configKey}[${index}].isVisible must be a function, got "${typeof column.isVisible}"`);
+                    }
+                });
+                // Check for duplicate keys
+                for (const [key, indexes] of keyMap.entries()) {
+                    if (indexes.length > 1) {
+                        errors.push(`${configKey}: Duplicate key "${key}" at indexes ${indexes.join(", ")}`);
+                    }
+                }
+            }
+            // Throw aggregated errors if any
+            if (errors.length > 0) {
+                const errorMessage = `Column configuration validation failed:\n${errors
+                    .map((e, i) => `  ${i + 1}. ${e}`)
+                    .join("\n")}`;
+                this.loggerService.warn(errorMessage);
+                throw new Error(errorMessage);
+            }
+            this.loggerService.log("columnValidationService validation passed");
+        };
+    }
+}
+
+var _a, _b, _c;
+const REPORT_BASE_METHOD_NAME_CTOR = "ReportBase.CTOR";
+const REPORT_BASE_METHOD_NAME_WAIT_FOR_INIT = "ReportBase.waitForInit";
+const REPORT_BASE_METHOD_NAME_WRITE = "ReportBase.write";
+const REPORT_UTILS_METHOD_NAME_USE_REPORT_ADAPTER = "ReportUtils.useReportAdapter";
+const REPORT_UTILS_METHOD_NAME_WRITE_DATA = "ReportUtils.writeReportData";
+const REPORT_UTILS_METHOD_NAME_ENABLE = "ReportUtils.enable";
+const REPORT_UTILS_METHOD_NAME_USE_DUMMY = "ReportUtils.useDummy";
+const REPORT_UTILS_METHOD_NAME_USE_JSONL = "ReportUtils.useJsonl";
+const WAIT_FOR_INIT_SYMBOL = Symbol("wait-for-init");
+const WRITE_SAFE_SYMBOL = Symbol("write-safe");
+/**
+ * JSONL-based report adapter with append-only writes.
+ *
+ * Features:
+ * - Writes events as JSONL entries to a single file per report type
+ * - Stream-based writes with backpressure handling
+ * - 15-second timeout protection for write operations
+ * - Automatic directory creation
+ * - Error handling via exitEmitter
+ * - Search metadata for filtering (symbol, strategy, exchange, frame, signalId, walkerName)
+ *
+ * File format: ./dump/report/{reportName}.jsonl
+ * Each line contains: reportName, data, metadata, timestamp
+ *
+ * Use this adapter for event logging and post-processing analytics.
+ */
+const ReportBase = functoolsKit.makeExtendable((_c = class {
+        /**
+         * Creates a new JSONL report adapter instance.
+         *
+         * @param reportName - Type of report (backtest, live, walker, etc.)
+         * @param baseDir - Base directory for report files, defaults to ./dump/report
+         */
+        constructor(reportName, baseDir = path.join(process.cwd(), "./dump/report")) {
+            this.reportName = reportName;
+            this.baseDir = baseDir;
+            /** WriteStream instance for append-only writes, null until initialized */
+            this._stream = null;
+            /**
+             * Singleshot initialization function that creates directory and stream.
+             * Protected by singleshot to ensure one-time execution.
+             * Sets up error handler that emits to exitEmitter.
+             */
+            this[_a] = functoolsKit.singleshot(async () => {
+                await fs__namespace.mkdir(this.baseDir, { recursive: true });
+                this._stream = fs$1.createWriteStream(this._filePath, { flags: "a" });
+                this._stream.on('error', (err) => {
+                    exitEmitter.next(new Error(`ReportBase stream error for reportName=${this.reportName} message=${functoolsKit.getErrorMessage(err)}`));
+                });
+            });
+            /**
+             * Timeout-protected write function with backpressure handling.
+             * Waits for drain event if write buffer is full.
+             * Times out after 15 seconds and returns TIMEOUT_SYMBOL.
+             */
+            this[_b] = functoolsKit.timeout(async (line) => {
+                if (!this._stream.write(line)) {
+                    await new Promise((resolve) => {
+                        this._stream.once('drain', resolve);
+                    });
+                }
+            }, 15000);
+            bt.loggerService.debug(REPORT_BASE_METHOD_NAME_CTOR, {
+                reportName: this.reportName,
+                baseDir,
+            });
+            this._filePath = path.join(this.baseDir, `${this.reportName}.jsonl`);
+        }
+        /**
+         * Initializes the JSONL file and write stream.
+         * Safe to call multiple times - singleshot ensures one-time execution.
+         *
+         * @param initial - Whether this is the first initialization (informational only)
+         * @returns Promise that resolves when initialization is complete
+         */
+        async waitForInit(initial) {
+            bt.loggerService.debug(REPORT_BASE_METHOD_NAME_WAIT_FOR_INIT, {
+                reportName: this.reportName,
+                initial,
+            });
+            await this[WAIT_FOR_INIT_SYMBOL]();
+        }
+        /**
+         * Writes event data to JSONL file with metadata.
+         * Appends a single line with JSON object containing:
+         * - reportName: Type of report
+         * - data: Event data object
+         * - Search flags: symbol, strategyName, exchangeName, frameName, signalId, walkerName
+         * - timestamp: Current timestamp in milliseconds
+         *
+         * @param data - Event data object to write
+         * @param options - Metadata options for filtering and search
+         * @throws Error if stream not initialized or write timeout exceeded
+         */
+        async write(data, options) {
+            bt.loggerService.debug(REPORT_BASE_METHOD_NAME_WRITE, {
+                reportName: this.reportName,
+                options,
+            });
+            if (!this._stream) {
+                throw new Error(`Stream not initialized for report ${this.reportName}. Call waitForInit() first.`);
+            }
+            const searchFlags = {};
+            if (options.symbol) {
+                searchFlags.symbol = options.symbol;
+            }
+            if (options.strategyName) {
+                searchFlags.strategyName = options.strategyName;
+            }
+            if (options.exchangeName) {
+                searchFlags.exchangeName = options.exchangeName;
+            }
+            if (options.frameName) {
+                searchFlags.frameName = options.frameName;
+            }
+            if (options.signalId) {
+                searchFlags.signalId = options.signalId;
+            }
+            if (options.walkerName) {
+                searchFlags.walkerName = options.walkerName;
+            }
+            const line = JSON.stringify({
+                reportName: this.reportName,
+                data,
+                ...searchFlags,
+                timestamp: Date.now(),
+            }) + "\n";
+            const status = await this[WRITE_SAFE_SYMBOL](line);
+            if (status === functoolsKit.TIMEOUT_SYMBOL) {
+                throw new Error(`Timeout writing to report ${this.reportName}`);
+            }
+        }
+    },
+    _a = WAIT_FOR_INIT_SYMBOL,
+    _b = WRITE_SAFE_SYMBOL,
+    _c));
+/**
+ * Dummy report adapter that discards all writes.
+ * Used for disabling report logging.
+ */
+class ReportDummy {
+    /**
+     * No-op initialization function.
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit() {
+    }
+    /**
+     * No-op write function.
+     * @returns Promise that resolves immediately
+     */
+    async write() {
+    }
+}
+/**
+ * Default configuration that enables all report services.
+ * Used when no specific configuration is provided to enable().
+ */
+const WILDCARD_TARGET = {
+    backtest: true,
+    breakeven: true,
+    heat: true,
+    live: true,
+    partial: true,
+    performance: true,
+    risk: true,
+    schedule: true,
+    walker: true,
+};
+/**
+ * Utility class for managing report services.
+ *
+ * Provides methods to enable/disable JSONL event logging across
+ * different service types (backtest, live, walker, performance, etc.).
+ *
+ * Typically extended by ReportAdapter for additional functionality.
+ */
+class ReportUtils {
+    constructor() {
+        /**
+         * Enables report services selectively.
+         *
+         * Subscribes to specified report services and returns a cleanup function
+         * that unsubscribes from all enabled services at once.
+         *
+         * Each enabled service will:
+         * - Start listening to relevant events
+         * - Write events to JSONL files in real-time
+         * - Include metadata for filtering and analytics
+         *
+         * IMPORTANT: Always call the returned unsubscribe function to prevent memory leaks.
+         *
+         * @param config - Service configuration object. Defaults to enabling all services.
+         * @param config.backtest - Enable backtest closed signal logging
+         * @param config.breakeven - Enable breakeven event logging
+         * @param config.partial - Enable partial close event logging
+         * @param config.heat - Enable heatmap data logging
+         * @param config.walker - Enable walker iteration logging
+         * @param config.performance - Enable performance metrics logging
+         * @param config.risk - Enable risk rejection logging
+         * @param config.schedule - Enable scheduled signal logging
+         * @param config.live - Enable live trading event logging
+         *
+         * @returns Cleanup function that unsubscribes from all enabled services
+         */
+        this.enable = ({ backtest: bt$1 = false, breakeven = false, heat = false, live = false, partial = false, performance = false, risk = false, schedule = false, walker = false, } = WILDCARD_TARGET) => {
+            bt.loggerService.debug(REPORT_UTILS_METHOD_NAME_ENABLE, {
+                backtest: bt$1,
+                breakeven,
+                heat,
+                live,
+                partial,
+                performance,
+                risk,
+                schedule,
+                walker,
+            });
+            const unList = [];
+            if (bt$1) {
+                unList.push(bt.backtestReportService.subscribe());
+            }
+            if (breakeven) {
+                unList.push(bt.breakevenReportService.subscribe());
+            }
+            if (heat) {
+                unList.push(bt.heatReportService.subscribe());
+            }
+            if (live) {
+                unList.push(bt.liveReportService.subscribe());
+            }
+            if (partial) {
+                unList.push(bt.partialReportService.subscribe());
+            }
+            if (performance) {
+                unList.push(bt.performanceReportService.subscribe());
+            }
+            if (risk) {
+                unList.push(bt.riskReportService.subscribe());
+            }
+            if (schedule) {
+                unList.push(bt.scheduleReportService.subscribe());
+            }
+            if (walker) {
+                unList.push(bt.walkerReportService.subscribe());
+            }
+            return functoolsKit.compose(...unList.map((un) => () => void un()));
+        };
+    }
+}
+/**
+ * Report adapter with pluggable storage backend and instance memoization.
+ *
+ * Features:
+ * - Adapter pattern for swappable storage implementations
+ * - Memoized storage instances (one per report type)
+ * - Default adapter: ReportBase (JSONL append)
+ * - Lazy initialization on first write
+ * - Real-time event logging to JSONL files
+ *
+ * Used for structured event logging and analytics pipelines.
+ */
+class ReportAdapter extends ReportUtils {
+    constructor() {
+        super(...arguments);
+        /**
+         * Current report storage adapter constructor.
+         * Defaults to ReportBase for JSONL storage.
+         * Can be changed via useReportAdapter().
+         */
+        this.ReportFactory = ReportBase;
+        /**
+         * Memoized storage instances cache.
+         * Key: reportName (backtest, live, walker, etc.)
+         * Value: TReportBase instance created with current ReportFactory.
+         * Ensures single instance per report type for the lifetime of the application.
+         */
+        this.getReportStorage = functoolsKit.memoize(([reportName]) => reportName, (reportName) => Reflect.construct(this.ReportFactory, [reportName, "./dump/report"]));
+        /**
+         * Writes report data to storage using the configured adapter.
+         * Automatically initializes storage on first write for each report type.
+         *
+         * @param reportName - Type of report (backtest, live, walker, etc.)
+         * @param data - Event data object to write
+         * @param options - Metadata options for filtering and search
+         * @returns Promise that resolves when write is complete
+         * @throws Error if write fails or storage initialization fails
+         *
+         * @internal - Automatically called by report services, not for direct use
+         */
+        this.writeData = async (reportName, data, options) => {
+            bt.loggerService.info(REPORT_UTILS_METHOD_NAME_WRITE_DATA, {
+                reportName,
+                options,
+            });
+            const isInitial = !this.getReportStorage.has(reportName);
+            const reportStorage = this.getReportStorage(reportName);
+            await reportStorage.waitForInit(isInitial);
+            await reportStorage.write(data, options);
+        };
+    }
+    /**
+     * Sets the report storage adapter constructor.
+     * All future report instances will use this adapter.
+     *
+     * @param Ctor - Constructor for report storage adapter
+     */
+    useReportAdapter(Ctor) {
+        bt.loggerService.info(REPORT_UTILS_METHOD_NAME_USE_REPORT_ADAPTER);
+        this.ReportFactory = Ctor;
+    }
+    /**
+     * Switches to a dummy report adapter that discards all writes.
+     * All future report writes will be no-ops.
+     */
+    useDummy() {
+        bt.loggerService.log(REPORT_UTILS_METHOD_NAME_USE_DUMMY);
+        this.useReportAdapter(ReportDummy);
+    }
+    /**
+     * Switches to the default JSONL report adapter.
+     * All future report writes will use JSONL storage.
+     */
+    useJsonl() {
+        bt.loggerService.log(REPORT_UTILS_METHOD_NAME_USE_JSONL);
+        this.useReportAdapter(ReportBase);
+    }
+}
+/**
+ * Global singleton instance of ReportAdapter.
+ * Provides JSONL event logging with pluggable storage backends.
+ */
+const Report = new ReportAdapter();
+
+const BACKTEST_REPORT_METHOD_NAME_SUBSCRIBE = "BacktestReportService.subscribe";
+const BACKTEST_REPORT_METHOD_NAME_UNSUBSCRIBE = "BacktestReportService.unsubscribe";
+const BACKTEST_REPORT_METHOD_NAME_TICK = "BacktestReportService.tick";
+class BacktestReportService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.tick = async (data) => {
+            this.loggerService.log(BACKTEST_REPORT_METHOD_NAME_TICK, { data });
+            const baseEvent = {
+                timestamp: Date.now(),
+                action: data.action,
+                symbol: data.symbol,
+                strategyName: data.strategyName,
+                exchangeName: data.exchangeName,
+                frameName: data.frameName,
+                backtest: true,
+                currentPrice: data.currentPrice,
+            };
+            const searchOptions = {
+                symbol: data.symbol,
+                strategyName: data.strategyName,
+                exchangeName: data.exchangeName,
+                frameName: data.frameName,
+                signalId: data.action === "idle" ? "" : data.signal?.id,
+                walkerName: "",
+            };
+            if (data.action === "idle") {
+                await Report.writeData("backtest", baseEvent, searchOptions);
+            }
+            else if (data.action === "opened") {
+                await Report.writeData("backtest", {
+                    ...baseEvent,
+                    signalId: data.signal?.id,
+                    position: data.signal?.position,
+                    note: data.signal?.note,
+                    priceOpen: data.signal?.priceOpen,
+                    priceTakeProfit: data.signal?.priceTakeProfit,
+                    priceStopLoss: data.signal?.priceStopLoss,
+                    originalPriceTakeProfit: data.signal?.originalPriceTakeProfit,
+                    originalPriceStopLoss: data.signal?.originalPriceStopLoss,
+                    totalExecuted: data.signal?.totalExecuted,
+                    openTime: data.signal?.pendingAt,
+                    scheduledAt: data.signal?.scheduledAt,
+                    minuteEstimatedTime: data.signal?.minuteEstimatedTime,
+                }, { ...searchOptions, signalId: data.signal?.id });
+            }
+            else if (data.action === "active") {
+                await Report.writeData("backtest", {
+                    ...baseEvent,
+                    signalId: data.signal?.id,
+                    position: data.signal?.position,
+                    note: data.signal?.note,
+                    priceOpen: data.signal?.priceOpen,
+                    priceTakeProfit: data.signal?.priceTakeProfit,
+                    priceStopLoss: data.signal?.priceStopLoss,
+                    originalPriceTakeProfit: data.signal?.originalPriceTakeProfit,
+                    originalPriceStopLoss: data.signal?.originalPriceStopLoss,
+                    _partial: data.signal?._partial,
+                    totalExecuted: data.signal?.totalExecuted,
+                    openTime: data.signal?.pendingAt,
+                    scheduledAt: data.signal?.scheduledAt,
+                    minuteEstimatedTime: data.signal?.minuteEstimatedTime,
+                    percentTp: data.percentTp,
+                    percentSl: data.percentSl,
+                    pnl: data.pnl.pnlPercentage,
+                    pnlPriceOpen: data.pnl.priceOpen,
+                    pnlPriceClose: data.pnl.priceClose,
+                }, { ...searchOptions, signalId: data.signal?.id });
+            }
+            else if (data.action === "closed") {
+                const durationMs = data.closeTimestamp - data.signal?.pendingAt;
+                const durationMin = Math.round(durationMs / 60000);
+                await Report.writeData("backtest", {
+                    ...baseEvent,
+                    signalId: data.signal?.id,
+                    position: data.signal?.position,
+                    note: data.signal?.note,
+                    priceOpen: data.signal?.priceOpen,
+                    priceTakeProfit: data.signal?.priceTakeProfit,
+                    priceStopLoss: data.signal?.priceStopLoss,
+                    originalPriceTakeProfit: data.signal?.originalPriceTakeProfit,
+                    originalPriceStopLoss: data.signal?.originalPriceStopLoss,
+                    _partial: data.signal?._partial,
+                    totalExecuted: data.signal?.totalExecuted,
+                    openTime: data.signal?.pendingAt,
+                    scheduledAt: data.signal?.scheduledAt,
+                    minuteEstimatedTime: data.signal?.minuteEstimatedTime,
+                    pnl: data.pnl.pnlPercentage,
+                    pnlPriceOpen: data.pnl.priceOpen,
+                    pnlPriceClose: data.pnl.priceClose,
+                    closeReason: data.closeReason,
+                    closeTime: data.closeTimestamp,
+                    duration: durationMin,
+                }, { ...searchOptions, signalId: data.signal?.id });
+            }
+        };
+        this.subscribe = functoolsKit.singleshot(() => {
+            this.loggerService.log(BACKTEST_REPORT_METHOD_NAME_SUBSCRIBE);
+            const unsubscribe = signalBacktestEmitter.subscribe(this.tick);
+            return () => {
+                this.subscribe.clear();
+                unsubscribe();
+            };
+        });
+        this.unsubscribe = async () => {
+            this.loggerService.log(BACKTEST_REPORT_METHOD_NAME_UNSUBSCRIBE);
+            if (this.subscribe.hasValue()) {
+                const lastSubscription = this.subscribe();
+                lastSubscription();
+            }
+        };
+    }
+}
+
+const LIVE_REPORT_METHOD_NAME_SUBSCRIBE = "LiveReportService.subscribe";
+const LIVE_REPORT_METHOD_NAME_UNSUBSCRIBE = "LiveReportService.unsubscribe";
+const LIVE_REPORT_METHOD_NAME_TICK = "LiveReportService.tick";
+class LiveReportService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.tick = async (data) => {
+            this.loggerService.log(LIVE_REPORT_METHOD_NAME_TICK, { data });
+            const baseEvent = {
+                timestamp: Date.now(),
+                action: data.action,
+                symbol: data.symbol,
+                strategyName: data.strategyName,
+                exchangeName: data.exchangeName,
+                frameName: data.frameName,
+                backtest: false,
+                currentPrice: data.currentPrice,
+            };
+            const searchOptions = {
+                symbol: data.symbol,
+                strategyName: data.strategyName,
+                exchangeName: data.exchangeName,
+                frameName: data.frameName,
+                signalId: data.action === "idle" ? "" : data.signal?.id,
+                walkerName: "",
+            };
+            if (data.action === "idle") {
+                await Report.writeData("live", baseEvent, searchOptions);
+            }
+            else if (data.action === "opened") {
+                await Report.writeData("live", {
+                    ...baseEvent,
+                    signalId: data.signal?.id,
+                    position: data.signal?.position,
+                    note: data.signal?.note,
+                    priceOpen: data.signal?.priceOpen,
+                    priceTakeProfit: data.signal?.priceTakeProfit,
+                    priceStopLoss: data.signal?.priceStopLoss,
+                    originalPriceTakeProfit: data.signal?.originalPriceTakeProfit,
+                    originalPriceStopLoss: data.signal?.originalPriceStopLoss,
+                    totalExecuted: data.signal?.totalExecuted,
+                    openTime: data.signal?.pendingAt,
+                    scheduledAt: data.signal?.scheduledAt,
+                    minuteEstimatedTime: data.signal?.minuteEstimatedTime,
+                }, { ...searchOptions, signalId: data.signal?.id });
+            }
+            else if (data.action === "active") {
+                await Report.writeData("live", {
+                    ...baseEvent,
+                    signalId: data.signal?.id,
+                    position: data.signal?.position,
+                    note: data.signal?.note,
+                    priceOpen: data.signal?.priceOpen,
+                    priceTakeProfit: data.signal?.priceTakeProfit,
+                    priceStopLoss: data.signal?.priceStopLoss,
+                    originalPriceTakeProfit: data.signal?.originalPriceTakeProfit,
+                    originalPriceStopLoss: data.signal?.originalPriceStopLoss,
+                    _partial: data.signal?._partial,
+                    totalExecuted: data.signal?.totalExecuted,
+                    openTime: data.signal?.pendingAt,
+                    scheduledAt: data.signal?.scheduledAt,
+                    minuteEstimatedTime: data.signal?.minuteEstimatedTime,
+                    percentTp: data.percentTp,
+                    percentSl: data.percentSl,
+                    pnl: data.pnl.pnlPercentage,
+                    pnlPriceOpen: data.pnl.priceOpen,
+                    pnlPriceClose: data.pnl.priceClose,
+                }, { ...searchOptions, signalId: data.signal?.id });
+            }
+            else if (data.action === "closed") {
+                const durationMs = data.closeTimestamp - data.signal?.pendingAt;
+                const durationMin = Math.round(durationMs / 60000);
+                await Report.writeData("live", {
+                    ...baseEvent,
+                    signalId: data.signal?.id,
+                    position: data.signal?.position,
+                    note: data.signal?.note,
+                    priceOpen: data.signal?.priceOpen,
+                    priceTakeProfit: data.signal?.priceTakeProfit,
+                    priceStopLoss: data.signal?.priceStopLoss,
+                    originalPriceTakeProfit: data.signal?.originalPriceTakeProfit,
+                    originalPriceStopLoss: data.signal?.originalPriceStopLoss,
+                    _partial: data.signal?._partial,
+                    totalExecuted: data.signal?.totalExecuted,
+                    openTime: data.signal?.pendingAt,
+                    scheduledAt: data.signal?.scheduledAt,
+                    minuteEstimatedTime: data.signal?.minuteEstimatedTime,
+                    pnl: data.pnl.pnlPercentage,
+                    pnlPriceOpen: data.pnl.priceOpen,
+                    pnlPriceClose: data.pnl.priceClose,
+                    closeReason: data.closeReason,
+                    duration: durationMin,
+                    closeTime: data.closeTimestamp,
+                }, { ...searchOptions, signalId: data.signal?.id });
+            }
+        };
+        this.subscribe = functoolsKit.singleshot(() => {
+            this.loggerService.log(LIVE_REPORT_METHOD_NAME_SUBSCRIBE);
+            const unsubscribe = signalLiveEmitter.subscribe(this.tick);
+            return () => {
+                this.subscribe.clear();
+                unsubscribe();
+            };
+        });
+        this.unsubscribe = async () => {
+            this.loggerService.log(LIVE_REPORT_METHOD_NAME_UNSUBSCRIBE);
+            if (this.subscribe.hasValue()) {
+                const lastSubscription = this.subscribe();
+                lastSubscription();
+            }
+        };
+    }
+}
+
+const SCHEDULE_REPORT_METHOD_NAME_SUBSCRIBE = "ScheduleReportService.subscribe";
+const SCHEDULE_REPORT_METHOD_NAME_UNSUBSCRIBE = "ScheduleReportService.unsubscribe";
+const SCHEDULE_REPORT_METHOD_NAME_TICK = "ScheduleReportService.tick";
+class ScheduleReportService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.tick = async (data) => {
+            this.loggerService.log(SCHEDULE_REPORT_METHOD_NAME_TICK, { data });
+            const baseEvent = {
+                symbol: data.symbol,
+                strategyName: data.strategyName,
+                exchangeName: data.exchangeName,
+                frameName: data.frameName,
+                backtest: data.backtest,
+                currentPrice: data.currentPrice,
+            };
+            const searchOptions = {
+                symbol: data.symbol,
+                strategyName: data.strategyName,
+                exchangeName: data.exchangeName,
+                frameName: data.frameName,
+                signalId: data.signal?.id,
+                walkerName: "",
+            };
+            if (data.action === "scheduled") {
+                await Report.writeData("schedule", {
+                    timestamp: data.signal?.scheduledAt,
+                    action: "scheduled",
+                    ...baseEvent,
+                    signalId: data.signal?.id,
+                    position: data.signal?.position,
+                    note: data.signal?.note,
+                    priceOpen: data.signal?.priceOpen,
+                    priceTakeProfit: data.signal?.priceTakeProfit,
+                    priceStopLoss: data.signal?.priceStopLoss,
+                    originalPriceTakeProfit: data.signal?.originalPriceTakeProfit,
+                    originalPriceStopLoss: data.signal?.originalPriceStopLoss,
+                    totalExecuted: data.signal?.totalExecuted,
+                    pendingAt: data.signal?.pendingAt,
+                    minuteEstimatedTime: data.signal?.minuteEstimatedTime,
+                }, searchOptions);
+            }
+            else if (data.action === "opened") {
+                if (data.signal?.scheduledAt !== data.signal?.pendingAt) {
+                    const durationMs = data.signal?.pendingAt - data.signal?.scheduledAt;
+                    const durationMin = Math.round(durationMs / 60000);
+                    await Report.writeData("schedule", {
+                        timestamp: data.signal?.pendingAt,
+                        action: "opened",
+                        ...baseEvent,
+                        signalId: data.signal?.id,
+                        position: data.signal?.position,
+                        note: data.signal?.note,
+                        priceOpen: data.signal?.priceOpen,
+                        priceTakeProfit: data.signal?.priceTakeProfit,
+                        priceStopLoss: data.signal?.priceStopLoss,
+                        originalPriceTakeProfit: data.signal?.originalPriceTakeProfit,
+                        originalPriceStopLoss: data.signal?.originalPriceStopLoss,
+                        totalExecuted: data.signal?.totalExecuted,
+                        scheduledAt: data.signal?.scheduledAt,
+                        pendingAt: data.signal?.pendingAt,
+                        minuteEstimatedTime: data.signal?.minuteEstimatedTime,
+                        duration: durationMin,
+                    }, searchOptions);
+                }
+            }
+            else if (data.action === "cancelled") {
+                const durationMs = data.closeTimestamp - data.signal?.scheduledAt;
+                const durationMin = Math.round(durationMs / 60000);
+                await Report.writeData("schedule", {
+                    timestamp: data.closeTimestamp,
+                    action: "cancelled",
+                    ...baseEvent,
+                    signalId: data.signal?.id,
+                    position: data.signal?.position,
+                    note: data.signal?.note,
+                    priceOpen: data.signal?.priceOpen,
+                    priceTakeProfit: data.signal?.priceTakeProfit,
+                    priceStopLoss: data.signal?.priceStopLoss,
+                    originalPriceTakeProfit: data.signal?.originalPriceTakeProfit,
+                    originalPriceStopLoss: data.signal?.originalPriceStopLoss,
+                    totalExecuted: data.signal?.totalExecuted,
+                    scheduledAt: data.signal?.scheduledAt,
+                    pendingAt: data.signal?.pendingAt,
+                    minuteEstimatedTime: data.signal?.minuteEstimatedTime,
+                    closeTime: data.closeTimestamp,
+                    duration: durationMin,
+                    cancelReason: data.reason,
+                    cancelId: data.cancelId,
+                }, searchOptions);
+            }
+        };
+        this.subscribe = functoolsKit.singleshot(() => {
+            this.loggerService.log(SCHEDULE_REPORT_METHOD_NAME_SUBSCRIBE);
+            const unsubscribe = signalEmitter.subscribe(this.tick);
+            return () => {
+                this.subscribe.clear();
+                unsubscribe();
+            };
+        });
+        this.unsubscribe = async () => {
+            this.loggerService.log(SCHEDULE_REPORT_METHOD_NAME_UNSUBSCRIBE);
+            if (this.subscribe.hasValue()) {
+                const lastSubscription = this.subscribe();
+                lastSubscription();
+            }
+        };
+    }
+}
+
+const PERFORMANCE_REPORT_METHOD_NAME_SUBSCRIBE = "PerformanceReportService.subscribe";
+const PERFORMANCE_REPORT_METHOD_NAME_UNSUBSCRIBE = "PerformanceReportService.unsubscribe";
+const PERFORMANCE_REPORT_METHOD_NAME_TRACK = "PerformanceReportService.track";
+class PerformanceReportService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.track = async (event) => {
+            this.loggerService.log(PERFORMANCE_REPORT_METHOD_NAME_TRACK, { event });
+            await Report.writeData("performance", {
+                timestamp: event.timestamp,
+                metricType: event.metricType,
+                duration: event.duration,
+                symbol: event.symbol,
+                strategyName: event.strategyName,
+                exchangeName: event.exchangeName,
+                frameName: event.frameName,
+                backtest: event.backtest,
+                previousTimestamp: event.previousTimestamp,
+            }, {
+                symbol: event.symbol,
+                strategyName: event.strategyName,
+                exchangeName: event.exchangeName,
+                frameName: event.frameName,
+                signalId: "",
+                walkerName: "",
+            });
+        };
+        this.subscribe = functoolsKit.singleshot(() => {
+            this.loggerService.log(PERFORMANCE_REPORT_METHOD_NAME_SUBSCRIBE);
+            const unsubscribe = performanceEmitter.subscribe(this.track);
+            return () => {
+                this.subscribe.clear();
+                unsubscribe();
+            };
+        });
+        this.unsubscribe = async () => {
+            this.loggerService.log(PERFORMANCE_REPORT_METHOD_NAME_UNSUBSCRIBE);
+            if (this.subscribe.hasValue()) {
+                const lastSubscription = this.subscribe();
+                lastSubscription();
+            }
+        };
+    }
+}
+
+const WALKER_REPORT_METHOD_NAME_SUBSCRIBE = "WalkerReportService.subscribe";
+const WALKER_REPORT_METHOD_NAME_UNSUBSCRIBE = "WalkerReportService.unsubscribe";
+const WALKER_REPORT_METHOD_NAME_TICK = "WalkerReportService.tick";
+class WalkerReportService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.tick = async (data) => {
+            this.loggerService.log(WALKER_REPORT_METHOD_NAME_TICK, { data });
+            await Report.writeData("walker", {
+                timestamp: Date.now(),
+                walkerName: data.walkerName,
+                symbol: data.symbol,
+                exchangeName: data.exchangeName,
+                frameName: data.frameName,
+                strategyName: data.strategyName,
+                metric: data.metric,
+                metricValue: data.metricValue,
+                strategiesTested: data.strategiesTested,
+                totalStrategies: data.totalStrategies,
+                bestStrategy: data.bestStrategy,
+                bestMetric: data.bestMetric,
+                totalSignals: data.stats.totalSignals,
+                winCount: data.stats.winCount,
+                lossCount: data.stats.lossCount,
+                winRate: data.stats.winRate,
+                avgPnl: data.stats.avgPnl,
+                totalPnl: data.stats.totalPnl,
+                stdDev: data.stats.stdDev,
+                sharpeRatio: data.stats.sharpeRatio,
+                annualizedSharpeRatio: data.stats.annualizedSharpeRatio,
+                certaintyRatio: data.stats.certaintyRatio,
+                expectedYearlyReturns: data.stats.expectedYearlyReturns,
+            }, {
+                symbol: data.symbol,
+                strategyName: data.strategyName,
+                exchangeName: data.exchangeName,
+                frameName: data.frameName,
+                signalId: "",
+                walkerName: data.walkerName,
+            });
+        };
+        this.subscribe = functoolsKit.singleshot(() => {
+            this.loggerService.log(WALKER_REPORT_METHOD_NAME_SUBSCRIBE);
+            const unsubscribe = walkerEmitter.subscribe(this.tick);
+            return () => {
+                this.subscribe.clear();
+                unsubscribe();
+            };
+        });
+        this.unsubscribe = async () => {
+            this.loggerService.log(WALKER_REPORT_METHOD_NAME_UNSUBSCRIBE);
+            if (this.subscribe.hasValue()) {
+                const lastSubscription = this.subscribe();
+                lastSubscription();
+            }
+        };
+    }
+}
+
+const HEAT_REPORT_METHOD_NAME_SUBSCRIBE = "HeatReportService.subscribe";
+const HEAT_REPORT_METHOD_NAME_UNSUBSCRIBE = "HeatReportService.unsubscribe";
+const HEAT_REPORT_METHOD_NAME_TICK = "HeatReportService.tick";
+class HeatReportService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.tick = async (data) => {
+            this.loggerService.log(HEAT_REPORT_METHOD_NAME_TICK, { data });
+            if (data.action !== "closed") {
+                return;
+            }
+            await Report.writeData("heat", {
+                timestamp: Date.now(),
+                action: data.action,
+                symbol: data.symbol,
+                strategyName: data.strategyName,
+                exchangeName: data.exchangeName,
+                frameName: data.frameName,
+                backtest: data.backtest,
+                signalId: data.signal?.id,
+                position: data.signal?.position,
+                pnl: data.pnl.pnlPercentage,
+                closeReason: data.closeReason,
+                openTime: data.signal?.pendingAt,
+                closeTime: data.closeTimestamp,
+            }, {
+                symbol: data.symbol,
+                strategyName: data.strategyName,
+                exchangeName: data.exchangeName,
+                frameName: data.frameName,
+                signalId: data.signal?.id,
+                walkerName: "",
+            });
+        };
+        this.subscribe = functoolsKit.singleshot(() => {
+            this.loggerService.log(HEAT_REPORT_METHOD_NAME_SUBSCRIBE);
+            const unsubscribe = signalEmitter.subscribe(this.tick);
+            return () => {
+                this.subscribe.clear();
+                unsubscribe();
+            };
+        });
+        this.unsubscribe = async () => {
+            this.loggerService.log(HEAT_REPORT_METHOD_NAME_UNSUBSCRIBE);
+            if (this.subscribe.hasValue()) {
+                const lastSubscription = this.subscribe();
+                lastSubscription();
+            }
+        };
+    }
+}
+
+const PARTIAL_REPORT_METHOD_NAME_SUBSCRIBE = "PartialReportService.subscribe";
+const PARTIAL_REPORT_METHOD_NAME_UNSUBSCRIBE = "PartialReportService.unsubscribe";
+const PARTIAL_REPORT_METHOD_NAME_TICK_PROFIT = "PartialReportService.tickProfit";
+const PARTIAL_REPORT_METHOD_NAME_TICK_LOSS = "PartialReportService.tickLoss";
+class PartialReportService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.tickProfit = async (data) => {
+            this.loggerService.log(PARTIAL_REPORT_METHOD_NAME_TICK_PROFIT, { data });
+            await Report.writeData("partial", {
+                timestamp: data.timestamp,
+                action: "profit",
+                symbol: data.symbol,
+                strategyName: data.data.strategyName,
+                exchangeName: data.exchangeName,
+                frameName: data.frameName,
+                backtest: data.backtest,
+                signalId: data.data.id,
+                position: data.data.position,
+                currentPrice: data.currentPrice,
+                level: data.level,
+                priceOpen: data.data.priceOpen,
+                priceTakeProfit: data.data.priceTakeProfit,
+                priceStopLoss: data.data.priceStopLoss,
+                _partial: data.data._partial,
+                note: data.data.note,
+                pendingAt: data.data.pendingAt,
+                scheduledAt: data.data.scheduledAt,
+                minuteEstimatedTime: data.data.minuteEstimatedTime,
+            }, {
+                symbol: data.symbol,
+                strategyName: data.data.strategyName,
+                exchangeName: data.exchangeName,
+                frameName: data.frameName,
+                signalId: data.data.id,
+                walkerName: "",
+            });
         };
-        /**
-         * Saves symbol-strategy report to disk.
-         * Creates directory if it doesn't exist.
-         * Delegates to ReportStorage.dump().
-         *
-         * @param symbol - Trading pair symbol to save report for
-         * @param strategyName - Strategy name to save report for
-         * @param exchangeName - Exchange name
-         * @param frameName - Frame name
-         * @param backtest - True if backtest mode, false if live mode
-         * @param path - Directory path to save report (default: "./dump/risk")
-         * @param columns - Column configuration for formatting the table
-         *
-         * @example
-         * ```typescript
-         * const service = new RiskMarkdownService();
-         *
-         * // Save to default path: ./dump/risk/BTCUSDT_my-strategy.md
-         * await service.dump("BTCUSDT", "my-strategy", "binance", "1h", false);
-         *
-         * // Save to custom path: ./custom/path/BTCUSDT_my-strategy.md
-         * await service.dump("BTCUSDT", "my-strategy", "binance", "1h", false, "./custom/path");
-         * ```
-         */
-        this.dump = async (symbol, strategyName, exchangeName, frameName, backtest, path = "./dump/risk", columns = COLUMN_CONFIG.risk_columns) => {
-            this.loggerService.log("riskMarkdownService dump", {
-                symbol,
-                strategyName,
-                exchangeName,
-                frameName,
-                backtest,
-                path,
+        this.tickLoss = async (data) => {
+            this.loggerService.log(PARTIAL_REPORT_METHOD_NAME_TICK_LOSS, { data });
+            await Report.writeData("partial", {
+                timestamp: data.timestamp,
+                action: "loss",
+                symbol: data.symbol,
+                strategyName: data.data.strategyName,
+                exchangeName: data.exchangeName,
+                frameName: data.frameName,
+                backtest: data.backtest,
+                signalId: data.data.id,
+                position: data.data.position,
+                currentPrice: data.currentPrice,
+                level: data.level,
+                priceOpen: data.data.priceOpen,
+                priceTakeProfit: data.data.priceTakeProfit,
+                priceStopLoss: data.data.priceStopLoss,
+                _partial: data.data._partial,
+                note: data.data.note,
+                pendingAt: data.data.pendingAt,
+                scheduledAt: data.data.scheduledAt,
+                minuteEstimatedTime: data.data.minuteEstimatedTime,
+            }, {
+                symbol: data.symbol,
+                strategyName: data.data.strategyName,
+                exchangeName: data.exchangeName,
+                frameName: data.frameName,
+                signalId: data.data.id,
+                walkerName: "",
             });
-            const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
-            await storage.dump(symbol, strategyName, path, columns);
         };
-        /**
-         * Clears accumulated event data from storage.
-         * If payload is provided, clears only that specific symbol-strategy-exchange-frame-backtest combination's data.
-         * If nothing is provided, clears all data.
-         *
-         * @param payload - Optional payload with symbol, strategyName, exchangeName, frameName, backtest
-         *
-         * @example
-         * ```typescript
-         * const service = new RiskMarkdownService();
-         *
-         * // Clear specific combination
-         * await service.clear({ symbol: "BTCUSDT", strategyName: "my-strategy", exchangeName: "binance", frameName: "1h", backtest: false });
-         *
-         * // Clear all data
-         * await service.clear();
-         * ```
-         */
-        this.clear = async (payload) => {
-            this.loggerService.log("riskMarkdownService clear", {
-                payload,
-            });
-            if (payload) {
-                const key = CREATE_KEY_FN$2(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
-                this.getStorage.clear(key);
-            }
-            else {
-                this.getStorage.clear();
+        this.subscribe = functoolsKit.singleshot(() => {
+            this.loggerService.log(PARTIAL_REPORT_METHOD_NAME_SUBSCRIBE);
+            const unProfit = partialProfitSubject.subscribe(this.tickProfit);
+            const unLoss = partialLossSubject.subscribe(this.tickLoss);
+            return () => {
+                this.subscribe.clear();
+                unProfit();
+                unLoss();
+            };
+        });
+        this.unsubscribe = async () => {
+            this.loggerService.log(PARTIAL_REPORT_METHOD_NAME_UNSUBSCRIBE);
+            if (this.subscribe.hasValue()) {
+                const lastSubscription = this.subscribe();
+                lastSubscription();
             }
         };
-        /**
-         * Initializes the service by subscribing to risk rejection events.
-         * Uses singleshot to ensure initialization happens only once.
-         * Automatically called on first use.
-         *
-         * @example
-         * ```typescript
-         * const service = new RiskMarkdownService();
-         * await service.init(); // Subscribe to rejection events
-         * ```
-         */
-        this.init = functoolsKit.singleshot(async () => {
-            this.loggerService.log("riskMarkdownService init");
-            this.unsubscribe = riskSubject.subscribe(this.tickRejection);
-        });
     }
 }
 
-/**
- * Service for validating column configurations to ensure consistency with ColumnModel interface
- * and prevent invalid column definitions.
- *
- * Performs comprehensive validation on all column definitions in COLUMN_CONFIG:
- * - **Required fields**: All columns must have key, label, format, and isVisible properties
- * - **Unique keys**: All key values must be unique within each column collection
- * - **Function validation**: format and isVisible must be callable functions
- * - **Data types**: key and label must be non-empty strings
- *
- * @throws {Error} If any validation fails, throws with detailed breakdown of all errors
- *
- * @example
- * ```typescript
- * const validator = new ColumnValidationService();
- * validator.validate(); // Throws if column configuration is invalid
- * ```
- *
- * @example Validation failure output:
- * ```
- * Column configuration validation failed:
- *   1. backtest_columns[0]: Missing required field "format"
- *   2. heat_columns: Duplicate key "symbol" at indexes 1, 5
- *   3. live_columns[3].isVisible must be a function, got "boolean"
- * ```
- */
-class ColumnValidationService {
+const BREAKEVEN_REPORT_METHOD_NAME_SUBSCRIBE = "BreakevenReportService.subscribe";
+const BREAKEVEN_REPORT_METHOD_NAME_UNSUBSCRIBE = "BreakevenReportService.unsubscribe";
+const BREAKEVEN_REPORT_METHOD_NAME_TICK = "BreakevenReportService.tickBreakeven";
+class BreakevenReportService {
     constructor() {
-        /**
-         * @private
-         * @readonly
-         * Injected logger service instance
-         */
         this.loggerService = inject(TYPES.loggerService);
-        /**
-         * Validates all column configurations in COLUMN_CONFIG for structural correctness.
-         *
-         * Checks:
-         * 1. All required fields (key, label, format, isVisible) are present in each column
-         * 2. key and label are non-empty strings
-         * 3. format and isVisible are functions (not other types)
-         * 4. All keys are unique within each column collection
-         *
-         * @throws Error if configuration is invalid
-         */
-        this.validate = () => {
-            this.loggerService.log("columnValidationService validate");
-            const errors = [];
-            // Iterate through all column collections in COLUMN_CONFIG
-            for (const [configKey, columns] of Object.entries(COLUMN_CONFIG)) {
-                if (!Array.isArray(columns)) {
-                    errors.push(`${configKey} is not an array, got ${typeof columns}`);
-                    continue;
-                }
-                // Track keys for uniqueness check
-                const keyMap = new Map();
-                // Validate each column in the collection
-                columns.forEach((column, index) => {
-                    if (!column || typeof column !== "object") {
-                        errors.push(`${configKey}[${index}]: Column must be an object, got ${typeof column}`);
-                        return;
-                    }
-                    // Check for all required fields
-                    const requiredFields = ["key", "label", "format", "isVisible"];
-                    for (const field of requiredFields) {
-                        if (!(field in column)) {
-                            errors.push(`${configKey}[${index}]: Missing required field "${field}"`);
-                        }
-                    }
-                    // Validate key and label are non-empty strings
-                    if (typeof column.key !== "string" || column.key.trim() === "") {
-                        errors.push(`${configKey}[${index}].key must be a non-empty string, got ${typeof column.key === "string" ? `"${column.key}"` : typeof column.key}`);
-                    }
-                    else {
-                        // Track key for uniqueness check
-                        if (!keyMap.has(column.key)) {
-                            keyMap.set(column.key, []);
-                        }
-                        keyMap.get(column.key).push(index);
-                    }
-                    if (typeof column.label !== "string" || column.label.trim() === "") {
-                        errors.push(`${configKey}[${index}].label must be a non-empty string, got ${typeof column.label === "string" ? `"${column.label}"` : typeof column.label}`);
-                    }
-                    // Validate format is a function
-                    if (typeof column.format !== "function") {
-                        errors.push(`${configKey}[${index}].format must be a function, got "${typeof column.format}"`);
-                    }
-                    // Validate isVisible is a function
-                    if (typeof column.isVisible !== "function") {
-                        errors.push(`${configKey}[${index}].isVisible must be a function, got "${typeof column.isVisible}"`);
-                    }
-                });
-                // Check for duplicate keys
-                for (const [key, indexes] of keyMap.entries()) {
-                    if (indexes.length > 1) {
-                        errors.push(`${configKey}: Duplicate key "${key}" at indexes ${indexes.join(", ")}`);
-                    }
-                }
+        this.tickBreakeven = async (data) => {
+            this.loggerService.log(BREAKEVEN_REPORT_METHOD_NAME_TICK, { data });
+            await Report.writeData("breakeven", {
+                timestamp: data.timestamp,
+                symbol: data.symbol,
+                strategyName: data.data.strategyName,
+                exchangeName: data.exchangeName,
+                frameName: data.frameName,
+                backtest: data.backtest,
+                signalId: data.data.id,
+                position: data.data.position,
+                currentPrice: data.currentPrice,
+                priceOpen: data.data.priceOpen,
+                priceTakeProfit: data.data.priceTakeProfit,
+                priceStopLoss: data.data.priceStopLoss,
+                _partial: data.data._partial,
+                note: data.data.note,
+                pendingAt: data.data.pendingAt,
+                scheduledAt: data.data.scheduledAt,
+                minuteEstimatedTime: data.data.minuteEstimatedTime,
+            }, {
+                symbol: data.symbol,
+                strategyName: data.data.strategyName,
+                exchangeName: data.exchangeName,
+                frameName: data.frameName,
+                signalId: data.data.id,
+                walkerName: "",
+            });
+        };
+        this.subscribe = functoolsKit.singleshot(() => {
+            this.loggerService.log(BREAKEVEN_REPORT_METHOD_NAME_SUBSCRIBE);
+            const unsubscribe = breakevenSubject.subscribe(this.tickBreakeven);
+            return () => {
+                this.subscribe.clear();
+                unsubscribe();
+            };
+        });
+        this.unsubscribe = async () => {
+            this.loggerService.log(BREAKEVEN_REPORT_METHOD_NAME_UNSUBSCRIBE);
+            if (this.subscribe.hasValue()) {
+                const lastSubscription = this.subscribe();
+                lastSubscription();
             }
-            // Throw aggregated errors if any
-            if (errors.length > 0) {
-                const errorMessage = `Column configuration validation failed:\n${errors
-                    .map((e, i) => `  ${i + 1}. ${e}`)
-                    .join("\n")}`;
-                this.loggerService.warn(errorMessage);
-                throw new Error(errorMessage);
+        };
+    }
+}
+
+const RISK_REPORT_METHOD_NAME_SUBSCRIBE = "RiskReportService.subscribe";
+const RISK_REPORT_METHOD_NAME_UNSUBSCRIBE = "RiskReportService.unsubscribe";
+const RISK_REPORT_METHOD_NAME_TICK = "RiskReportService.tickRejection";
+class RiskReportService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.tickRejection = async (data) => {
+            this.loggerService.log(RISK_REPORT_METHOD_NAME_TICK, { data });
+            await Report.writeData("risk", {
+                timestamp: data.timestamp,
+                symbol: data.symbol,
+                strategyName: data.strategyName,
+                exchangeName: data.exchangeName,
+                frameName: data.frameName,
+                backtest: data.backtest,
+                currentPrice: data.currentPrice,
+                activePositionCount: data.activePositionCount,
+                rejectionId: data.rejectionId,
+                rejectionNote: data.rejectionNote,
+                pendingSignal: data.pendingSignal,
+                signalId: data.pendingSignal?.id,
+                position: data.pendingSignal?.position,
+                priceOpen: data.pendingSignal?.priceOpen,
+                priceTakeProfit: data.pendingSignal?.priceTakeProfit,
+                priceStopLoss: data.pendingSignal?.priceStopLoss,
+                originalPriceTakeProfit: data.pendingSignal?.originalPriceTakeProfit,
+                originalPriceStopLoss: data.pendingSignal?.originalPriceStopLoss,
+                totalExecuted: data.pendingSignal?.totalExecuted,
+                note: data.pendingSignal?.note,
+                minuteEstimatedTime: data.pendingSignal?.minuteEstimatedTime,
+            }, {
+                symbol: data.symbol,
+                strategyName: data.strategyName,
+                exchangeName: data.exchangeName,
+                frameName: data.frameName,
+                signalId: "",
+                walkerName: "",
+            });
+        };
+        this.subscribe = functoolsKit.singleshot(() => {
+            this.loggerService.log(RISK_REPORT_METHOD_NAME_SUBSCRIBE);
+            const unsubscribe = riskSubject.subscribe(this.tickRejection);
+            return () => {
+                this.subscribe.clear();
+                unsubscribe();
+            };
+        });
+        this.unsubscribe = async () => {
+            this.loggerService.log(RISK_REPORT_METHOD_NAME_UNSUBSCRIBE);
+            if (this.subscribe.hasValue()) {
+                const lastSubscription = this.subscribe();
+                lastSubscription();
             }
-            this.loggerService.log("columnValidationService validation passed");
         };
     }
 }
@@ -17924,6 +20229,17 @@ class ColumnValidationService {
     provide(TYPES.outlineMarkdownService, () => new OutlineMarkdownService());
     provide(TYPES.riskMarkdownService, () => new RiskMarkdownService());
 }
+{
+    provide(TYPES.backtestReportService, () => new BacktestReportService());
+    provide(TYPES.liveReportService, () => new LiveReportService());
+    provide(TYPES.scheduleReportService, () => new ScheduleReportService());
+    provide(TYPES.performanceReportService, () => new PerformanceReportService());
+    provide(TYPES.walkerReportService, () => new WalkerReportService());
+    provide(TYPES.heatReportService, () => new HeatReportService());
+    provide(TYPES.partialReportService, () => new PartialReportService());
+    provide(TYPES.breakevenReportService, () => new BreakevenReportService());
+    provide(TYPES.riskReportService, () => new RiskReportService());
+}
 {
     provide(TYPES.exchangeValidationService, () => new ExchangeValidationService());
     provide(TYPES.strategyValidationService, () => new StrategyValidationService());
@@ -18004,6 +20320,17 @@ const markdownServices = {
     outlineMarkdownService: inject(TYPES.outlineMarkdownService),
     riskMarkdownService: inject(TYPES.riskMarkdownService),
 };
+const reportServices = {
+    backtestReportService: inject(TYPES.backtestReportService),
+    liveReportService: inject(TYPES.liveReportService),
+    scheduleReportService: inject(TYPES.scheduleReportService),
+    performanceReportService: inject(TYPES.performanceReportService),
+    walkerReportService: inject(TYPES.walkerReportService),
+    heatReportService: inject(TYPES.heatReportService),
+    partialReportService: inject(TYPES.partialReportService),
+    breakevenReportService: inject(TYPES.breakevenReportService),
+    riskReportService: inject(TYPES.riskReportService),
+};
 const validationServices = {
     exchangeValidationService: inject(TYPES.exchangeValidationService),
     strategyValidationService: inject(TYPES.strategyValidationService),
@@ -18029,6 +20356,7 @@ const backtest = {
     ...logicPrivateServices,
     ...logicPublicServices,
     ...markdownServices,
+    ...reportServices,
     ...validationServices,
     ...templateServices,
 };
@@ -18496,7 +20824,7 @@ async function cancel(symbol, cancelId) {
  *
  * @param symbol - Trading pair symbol
  * @param percentToClose - Percentage of position to close (0-100, absolute value)
- * @returns Promise that resolves when state is updated
+ * @returns Promise<boolean> - true if partial close executed, false if skipped
  *
  * @throws Error if currentPrice is not in profit direction:
  *   - LONG: currentPrice must be > priceOpen
@@ -18507,7 +20835,10 @@ async function cancel(symbol, cancelId) {
  * import { partialProfit } from "backtest-kit";
  *
  * // Close 30% of LONG position at profit
- * await partialProfit("BTCUSDT", 30, 45000);
+ * const success = await partialProfit("BTCUSDT", 30);
+ * if (success) {
+ *   console.log('Partial profit executed');
+ * }
  * ```
  */
 async function partialProfit(symbol, percentToClose) {
@@ -18524,7 +20855,7 @@ async function partialProfit(symbol, percentToClose) {
     const currentPrice = await getAveragePrice(symbol);
     const { backtest: isBacktest } = bt.executionContextService.context;
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
-    await bt.strategyCoreService.partialProfit(isBacktest, symbol, percentToClose, currentPrice, { exchangeName, frameName, strategyName });
+    return await bt.strategyCoreService.partialProfit(isBacktest, symbol, percentToClose, currentPrice, { exchangeName, frameName, strategyName });
 }
 /**
  * Executes partial close at loss level (moving toward SL).
@@ -18536,7 +20867,7 @@ async function partialProfit(symbol, percentToClose) {
  *
  * @param symbol - Trading pair symbol
  * @param percentToClose - Percentage of position to close (0-100, absolute value)
- * @returns Promise that resolves when state is updated
+ * @returns Promise<boolean> - true if partial close executed, false if skipped
  *
  * @throws Error if currentPrice is not in loss direction:
  *   - LONG: currentPrice must be < priceOpen
@@ -18547,7 +20878,10 @@ async function partialProfit(symbol, percentToClose) {
  * import { partialLoss } from "backtest-kit";
  *
  * // Close 40% of LONG position at loss
- * await partialLoss("BTCUSDT", 40, 38000);
+ * const success = await partialLoss("BTCUSDT", 40);
+ * if (success) {
+ *   console.log('Partial loss executed');
+ * }
  * ```
  */
 async function partialLoss(symbol, percentToClose) {
@@ -18564,7 +20898,7 @@ async function partialLoss(symbol, percentToClose) {
     const currentPrice = await getAveragePrice(symbol);
     const { backtest: isBacktest } = bt.executionContextService.context;
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
-    await bt.strategyCoreService.partialLoss(isBacktest, symbol, percentToClose, currentPrice, { exchangeName, frameName, strategyName });
+    return await bt.strategyCoreService.partialLoss(isBacktest, symbol, percentToClose, currentPrice, { exchangeName, frameName, strategyName });
 }
 /**
  * Adjusts the trailing stop-loss distance for an active pending signal.
@@ -21167,7 +23501,7 @@ class BacktestUtils {
          * @param percentToClose - Percentage of position to close (0-100, absolute value)
          * @param currentPrice - Current market price for this partial close
          * @param context - Execution context with strategyName, exchangeName, and frameName
-         * @returns Promise that resolves when state is updated
+         * @returns Promise<boolean> - true if partial close executed, false if skipped
          *
          * @throws Error if currentPrice is not in profit direction:
          *   - LONG: currentPrice must be > priceOpen
@@ -21176,11 +23510,14 @@ class BacktestUtils {
          * @example
          * ```typescript
          * // Close 30% of LONG position at profit
-         * await Backtest.partialProfit("BTCUSDT", 30, 45000, {
+         * const success = await Backtest.partialProfit("BTCUSDT", 30, 45000, {
          *   exchangeName: "binance",
          *   frameName: "frame1",
          *   strategyName: "my-strategy"
          * });
+         * if (success) {
+         *   console.log('Partial profit executed');
+         * }
          * ```
          */
         this.partialProfit = async (symbol, percentToClose, currentPrice, context) => {
@@ -21199,7 +23536,7 @@ class BacktestUtils {
                 riskList &&
                     riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_PARTIAL_PROFIT));
             }
-            await bt.strategyCoreService.partialProfit(true, symbol, percentToClose, currentPrice, context);
+            return await bt.strategyCoreService.partialProfit(true, symbol, percentToClose, currentPrice, context);
         };
         /**
          * Executes partial close at loss level (moving toward SL).
@@ -21211,7 +23548,7 @@ class BacktestUtils {
          * @param percentToClose - Percentage of position to close (0-100, absolute value)
          * @param currentPrice - Current market price for this partial close
          * @param context - Execution context with strategyName, exchangeName, and frameName
-         * @returns Promise that resolves when state is updated
+         * @returns Promise<boolean> - true if partial close executed, false if skipped
          *
          * @throws Error if currentPrice is not in loss direction:
          *   - LONG: currentPrice must be < priceOpen
@@ -21220,11 +23557,14 @@ class BacktestUtils {
          * @example
          * ```typescript
          * // Close 40% of LONG position at loss
-         * await Backtest.partialLoss("BTCUSDT", 40, 38000, {
+         * const success = await Backtest.partialLoss("BTCUSDT", 40, 38000, {
          *   exchangeName: "binance",
          *   frameName: "frame1",
          *   strategyName: "my-strategy"
          * });
+         * if (success) {
+         *   console.log('Partial loss executed');
+         * }
          * ```
          */
         this.partialLoss = async (symbol, percentToClose, currentPrice, context) => {
@@ -21243,7 +23583,7 @@ class BacktestUtils {
                 riskList &&
                     riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_PARTIAL_LOSS));
             }
-            await bt.strategyCoreService.partialLoss(true, symbol, percentToClose, currentPrice, context);
+            return await bt.strategyCoreService.partialLoss(true, symbol, percentToClose, currentPrice, context);
         };
         /**
          * Adjusts the trailing stop-loss distance for an active pending signal.
@@ -22086,7 +24426,7 @@ class LiveUtils {
          * @param percentToClose - Percentage of position to close (0-100, absolute value)
          * @param currentPrice - Current market price for this partial close
          * @param context - Execution context with strategyName and exchangeName
-         * @returns Promise that resolves when state is updated
+         * @returns Promise<boolean> - true if partial close executed, false if skipped
          *
          * @throws Error if currentPrice is not in profit direction:
          *   - LONG: currentPrice must be > priceOpen
@@ -22095,10 +24435,13 @@ class LiveUtils {
          * @example
          * ```typescript
          * // Close 30% of LONG position at profit
-         * await Live.partialProfit("BTCUSDT", 30, 45000, {
+         * const success = await Live.partialProfit("BTCUSDT", 30, 45000, {
          *   exchangeName: "binance",
          *   strategyName: "my-strategy"
          * });
+         * if (success) {
+         *   console.log('Partial profit executed');
+         * }
          * ```
          */
         this.partialProfit = async (symbol, percentToClose, currentPrice, context) => {
@@ -22115,7 +24458,7 @@ class LiveUtils {
                 riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_PARTIAL_PROFIT);
                 riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_PARTIAL_PROFIT));
             }
-            await bt.strategyCoreService.partialProfit(false, symbol, percentToClose, currentPrice, {
+            return await bt.strategyCoreService.partialProfit(false, symbol, percentToClose, currentPrice, {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
                 frameName: "",
@@ -22131,7 +24474,7 @@ class LiveUtils {
          * @param percentToClose - Percentage of position to close (0-100, absolute value)
          * @param currentPrice - Current market price for this partial close
          * @param context - Execution context with strategyName and exchangeName
-         * @returns Promise that resolves when state is updated
+         * @returns Promise<boolean> - true if partial close executed, false if skipped
          *
          * @throws Error if currentPrice is not in loss direction:
          *   - LONG: currentPrice must be < priceOpen
@@ -22140,10 +24483,13 @@ class LiveUtils {
          * @example
          * ```typescript
          * // Close 40% of LONG position at loss
-         * await Live.partialLoss("BTCUSDT", 40, 38000, {
+         * const success = await Live.partialLoss("BTCUSDT", 40, 38000, {
          *   exchangeName: "binance",
          *   strategyName: "my-strategy"
          * });
+         * if (success) {
+         *   console.log('Partial loss executed');
+         * }
          * ```
          */
         this.partialLoss = async (symbol, percentToClose, currentPrice, context) => {
@@ -22160,7 +24506,7 @@ class LiveUtils {
                 riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_PARTIAL_LOSS);
                 riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_PARTIAL_LOSS));
             }
-            await bt.strategyCoreService.partialLoss(false, symbol, percentToClose, currentPrice, {
+            return await bt.strategyCoreService.partialLoss(false, symbol, percentToClose, currentPrice, {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
                 frameName: "",
@@ -24027,11 +26373,29 @@ class ExchangeInstance {
             }
             const when = new Date(Date.now());
             const since = new Date(when.getTime() - adjust * 60 * 1000);
-            const data = await this._schema.getCandles(symbol, interval, since, limit);
+            let allData = [];
+            // If limit exceeds CC_MAX_CANDLES_PER_REQUEST, fetch data in chunks
+            if (limit > GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST) {
+                let remaining = limit;
+                let currentSince = new Date(since.getTime());
+                while (remaining > 0) {
+                    const chunkLimit = Math.min(remaining, GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST);
+                    const chunkData = await this._schema.getCandles(symbol, interval, currentSince, chunkLimit);
+                    allData.push(...chunkData);
+                    remaining -= chunkLimit;
+                    if (remaining > 0) {
+                        // Move currentSince forward by the number of candles fetched
+                        currentSince = new Date(currentSince.getTime() + chunkLimit * step * 60 * 1000);
+                    }
+                }
+            }
+            else {
+                allData = await this._schema.getCandles(symbol, interval, since, limit);
+            }
             // Filter candles to strictly match the requested range
             const whenTimestamp = when.getTime();
             const sinceTimestamp = since.getTime();
-            const filteredData = data.filter((candle) => candle.timestamp >= sinceTimestamp && candle.timestamp <= whenTimestamp);
+            const filteredData = allData.filter((candle) => candle.timestamp >= sinceTimestamp && candle.timestamp <= whenTimestamp);
             if (filteredData.length < limit) {
                 bt.loggerService.warn(`ExchangeInstance Expected ${limit} candles, got ${filteredData.length}`);
             }
@@ -25164,6 +27528,9 @@ exports.Exchange = Exchange;
 exports.ExecutionContextService = ExecutionContextService;
 exports.Heat = Heat;
 exports.Live = Live;
+exports.Markdown = Markdown;
+exports.MarkdownFileBase = MarkdownFileBase;
+exports.MarkdownFolderBase = MarkdownFolderBase;
 exports.MethodContextService = MethodContextService;
 exports.Notification = Notification;
 exports.Optimizer = Optimizer;
@@ -25176,6 +27543,8 @@ exports.PersistRiskAdapter = PersistRiskAdapter;
 exports.PersistScheduleAdapter = PersistScheduleAdapter;
 exports.PersistSignalAdapter = PersistSignalAdapter;
 exports.PositionSize = PositionSize;
+exports.Report = Report;
+exports.ReportBase = ReportBase;
 exports.Risk = Risk;
 exports.Schedule = Schedule;
 exports.Walker = Walker;