backtest-kit 1.5.2 → 1.5.4

package/build/index.cjs

@@ -1675,6 +1675,8 @@ const walkerCompleteSubject = new functoolsKit.Subject();
 /**
  * Walker stop emitter for walker cancellation events.
  * Emits when a walker comparison is stopped/cancelled.
+ *
+ * Includes walkerName to support multiple walkers running on the same symbol.
  */
 const walkerStopSubject = new functoolsKit.Subject();
 /**
@@ -2909,6 +2911,23 @@ class ClientStrategy {
         });
         return this._pendingSignal;
     }
+    /**
+     * Returns the stopped state of the strategy.
+     *
+     * Indicates whether the strategy has been explicitly stopped and should
+     * not continue processing new ticks or signals.
+     *
+     * @param symbol - Trading pair symbol
+     * @param strategyName - Name of the strategy
+     * @returns Promise resolving to true if strategy is stopped, false otherwise
+     */
+    async getStopped(symbol, strategyName) {
+        this.params.logger.debug("ClientStrategy getStopped", {
+            symbol,
+            strategyName,
+        });
+        return this._isStopped;
+    }
     /**
      * Performs a single tick of strategy execution.
      *
@@ -3151,18 +3170,24 @@ class ClientStrategy {
      * // Existing signal will continue until natural close
      * ```
      */
-    async stop(symbol, strategyName) {
+    async stop(symbol, strategyName, backtest) {
         this.params.logger.debug("ClientStrategy stop", {
             symbol,
             strategyName,
             hasPendingSignal: this._pendingSignal !== null,
             hasScheduledSignal: this._scheduledSignal !== null,
+            backtest,
         });
         this._isStopped = true;
         // Clear scheduled signal if exists
-        if (this._scheduledSignal) {
-            await this.setScheduledSignal(null);
+        if (!this._scheduledSignal) {
+            return;
+        }
+        this._scheduledSignal = null;
+        if (backtest) {
+            return;
         }
+        await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, this.params.execution.context.symbol, this.params.strategyName);
     }
 }
 
@@ -3245,6 +3270,24 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, strategyName);
             return await strategy.getPendingSignal(symbol, strategyName);
         };
+        /**
+         * Retrieves the stopped state of the strategy.
+         *
+         * Delegates to the underlying strategy instance to check if it has been
+         * marked as stopped and should cease operation.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Name of the strategy
+         * @returns Promise resolving to true if strategy is stopped, false otherwise
+         */
+        this.getStopped = async (symbol, strategyName) => {
+            this.loggerService.log("strategyConnectionService getStopped", {
+                symbol,
+                strategyName,
+            });
+            const strategy = this.getStrategy(symbol, strategyName);
+            return await strategy.getStopped(symbol, strategyName);
+        };
         /**
          * Executes live trading tick for current strategy.
          *
@@ -3312,12 +3355,12 @@ class StrategyConnectionService {
          * @param strategyName - Name of strategy to stop
          * @returns Promise that resolves when stop flag is set
          */
-        this.stop = async (ctx) => {
+        this.stop = async (ctx, backtest) => {
             this.loggerService.log("strategyConnectionService stop", {
                 ctx
             });
             const strategy = this.getStrategy(ctx.symbol, ctx.strategyName);
-            await strategy.stop(ctx.symbol, ctx.strategyName);
+            await strategy.stop(ctx.symbol, ctx.strategyName, backtest);
         };
         /**
          * Clears the memoized ClientStrategy instance from cache.
@@ -4182,6 +4225,24 @@ class StrategyGlobalService {
             await this.validate(symbol, strategyName);
             return await this.strategyConnectionService.getPendingSignal(symbol, strategyName);
         };
+        /**
+         * Checks if the strategy has been stopped.
+         *
+         * Validates strategy existence and delegates to connection service
+         * to retrieve the stopped state from the strategy instance.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Name of the strategy
+         * @returns Promise resolving to true if strategy is stopped, false otherwise
+         */
+        this.getStopped = async (symbol, strategyName) => {
+            this.loggerService.log("strategyGlobalService getStopped", {
+                symbol,
+                strategyName,
+            });
+            await this.validate(symbol, strategyName);
+            return await this.strategyConnectionService.getStopped(symbol, strategyName);
+        };
         /**
          * Checks signal status at a specific timestamp.
          *
@@ -4248,12 +4309,13 @@ class StrategyGlobalService {
          * @param strategyName - Name of strategy to stop
          * @returns Promise that resolves when stop flag is set
          */
-        this.stop = async (ctx) => {
+        this.stop = async (ctx, backtest) => {
             this.loggerService.log("strategyGlobalService stop", {
                 ctx,
+                backtest,
             });
             await this.validate(ctx.symbol, ctx.strategyName);
-            return await this.strategyConnectionService.stop(ctx);
+            return await this.strategyConnectionService.stop(ctx, backtest);
         };
         /**
          * Clears the memoized ClientStrategy instance from cache.
@@ -4945,6 +5007,16 @@ class BacktestLogicPrivateService {
                     progress: totalFrames > 0 ? i / totalFrames : 0,
                 });
             }
+            // Check if strategy should stop before processing next frame
+            if (await this.strategyGlobalService.getStopped(symbol, this.methodContextService.context.strategyName)) {
+                this.loggerService.info("backtestLogicPrivateService stopped by user request (before tick)", {
+                    symbol,
+                    when: when.toISOString(),
+                    processedFrames: i,
+                    totalFrames,
+                });
+                break;
+            }
             let result;
             try {
                 result = await this.strategyGlobalService.tick(symbol, when, true);
@@ -4960,6 +5032,16 @@ class BacktestLogicPrivateService {
                 i++;
                 continue;
             }
+            // Check if strategy should stop when idle (no active signal)
+            if (await functoolsKit.and(Promise.resolve(result.action === "idle"), this.strategyGlobalService.getStopped(symbol, this.methodContextService.context.strategyName))) {
+                this.loggerService.info("backtestLogicPrivateService stopped by user request (idle state)", {
+                    symbol,
+                    when: when.toISOString(),
+                    processedFrames: i,
+                    totalFrames,
+                });
+                break;
+            }
             // Если scheduled signal создан - обрабатываем через backtest()
             if (result.action === "scheduled") {
                 const signalStartTime = performance.now();
@@ -5052,6 +5134,16 @@ class BacktestLogicPrivateService {
                     i++;
                 }
                 yield backtestResult;
+                // Check if strategy should stop after signal is closed
+                if (await this.strategyGlobalService.getStopped(symbol, this.methodContextService.context.strategyName)) {
+                    this.loggerService.info("backtestLogicPrivateService stopped by user request (after scheduled signal closed)", {
+                        symbol,
+                        signalId: backtestResult.signal.id,
+                        processedFrames: i,
+                        totalFrames,
+                    });
+                    break;
+                }
             }
             // Если обычный сигнал открыт, вызываем backtest
             if (result.action === "opened") {
@@ -5135,6 +5227,16 @@ class BacktestLogicPrivateService {
                     i++;
                 }
                 yield backtestResult;
+                // Check if strategy should stop after signal is closed
+                if (await this.strategyGlobalService.getStopped(symbol, this.methodContextService.context.strategyName)) {
+                    this.loggerService.info("backtestLogicPrivateService stopped by user request (after signal closed)", {
+                        symbol,
+                        signalId: backtestResult.signal.id,
+                        processedFrames: i,
+                        totalFrames,
+                    });
+                    break;
+                }
             }
             // Track timeframe processing duration
             const timeframeEndTime = performance.now();
@@ -5242,7 +5344,8 @@ class LiveLogicPrivateService {
                 this.loggerService.warn("liveLogicPrivateService tick failed, retrying after sleep", {
                     symbol,
                     when: when.toISOString(),
-                    error: functoolsKit.errorData(error), message: functoolsKit.getErrorMessage(error),
+                    error: functoolsKit.errorData(error),
+                    message: functoolsKit.getErrorMessage(error),
                 });
                 await errorEmitter.next(error);
                 await functoolsKit.sleep(TICK_TTL);
@@ -5266,11 +5369,19 @@ class LiveLogicPrivateService {
                 backtest: false,
             });
             previousEventTimestamp = currentTimestamp;
-            if (result.action === "active") {
+            // Check if strategy should stop when idle (no active signal)
+            if (result.action === "idle") {
+                if (await functoolsKit.and(Promise.resolve(true), this.strategyGlobalService.getStopped(symbol, this.methodContextService.context.strategyName))) {
+                    this.loggerService.info("liveLogicPrivateService stopped by user request (idle state)", {
+                        symbol,
+                        when: when.toISOString(),
+                    });
+                    break;
+                }
                 await functoolsKit.sleep(TICK_TTL);
                 continue;
             }
-            if (result.action === "idle") {
+            if (result.action === "active") {
                 await functoolsKit.sleep(TICK_TTL);
                 continue;
             }
@@ -5280,12 +5391,21 @@ class LiveLogicPrivateService {
             }
             // Yield opened, closed results
             yield result;
+            // Check if strategy should stop after signal is closed
+            if (result.action === "closed") {
+                if (await this.strategyGlobalService.getStopped(symbol, this.methodContextService.context.strategyName)) {
+                    this.loggerService.info("liveLogicPrivateService stopped by user request (after signal closed)", {
+                        symbol,
+                        signalId: result.signal.id,
+                    });
+                    break;
+                }
+            }
             await functoolsKit.sleep(TICK_TTL);
         }
     }
 }
 
-const CANCEL_SYMBOL = Symbol("CANCEL_SYMBOL");
 /**
  * Private service for walker orchestration (strategy comparison).
  *
@@ -5343,112 +5463,121 @@ class WalkerLogicPrivateService {
         let strategiesTested = 0;
         let bestMetric = null;
         let bestStrategy = null;
-        let pendingStrategy;
-        const listenStop = walkerStopSubject
-            .filter((data) => {
-            let isOk = true;
-            isOk = isOk && data.symbol === symbol;
-            isOk = isOk && data.strategyName === pendingStrategy;
-            return isOk;
-        })
-            .map(() => CANCEL_SYMBOL)
-            .toPromise();
-        // Run backtest for each strategy
-        for (const strategyName of strategies) {
-            // Call onStrategyStart callback if provided
-            if (walkerSchema.callbacks?.onStrategyStart) {
-                walkerSchema.callbacks.onStrategyStart(strategyName, symbol);
-            }
-            this.loggerService.info("walkerLogicPrivateService testing strategy", {
-                strategyName,
+        // Track stopped strategies in Set for efficient lookup
+        const stoppedStrategies = new Set();
+        // Subscribe to stop signals and collect them in Set
+        // Filter by both symbol AND walkerName to support multiple walkers on same symbol
+        // connect() returns destructor function
+        const unsubscribe = walkerStopSubject
+            .filter((data) => data.symbol === symbol && data.walkerName === context.walkerName)
+            .connect((data) => {
+            stoppedStrategies.add(data.strategyName);
+            this.loggerService.info("walkerLogicPrivateService received stop signal for strategy", {
                 symbol,
+                walkerName: context.walkerName,
+                strategyName: data.strategyName,
+                stoppedCount: stoppedStrategies.size,
             });
-            const iterator = this.backtestLogicPublicService.run(symbol, {
-                strategyName,
-                exchangeName: context.exchangeName,
-                frameName: context.frameName,
-            });
-            pendingStrategy = strategyName;
-            let result;
-            try {
-                result = await Promise.race([
-                    await functoolsKit.resolveDocuments(iterator),
-                    listenStop,
-                ]);
-            }
-            catch (error) {
-                console.warn(`walkerLogicPrivateService backtest failed symbol=${symbol} strategyName=${strategyName} exchangeName=${context.exchangeName}`);
-                this.loggerService.warn("walkerLogicPrivateService backtest failed for strategy, skipping", {
+        });
+        try {
+            // Run backtest for each strategy
+            for (const strategyName of strategies) {
+                // Check if this strategy should be stopped before starting
+                if (stoppedStrategies.has(strategyName)) {
+                    this.loggerService.info("walkerLogicPrivateService skipping stopped strategy", {
+                        symbol,
+                        strategyName,
+                    });
+                    break;
+                }
+                // Call onStrategyStart callback if provided
+                if (walkerSchema.callbacks?.onStrategyStart) {
+                    walkerSchema.callbacks.onStrategyStart(strategyName, symbol);
+                }
+                this.loggerService.info("walkerLogicPrivateService testing strategy", {
                     strategyName,
                     symbol,
-                    error: functoolsKit.errorData(error), message: functoolsKit.getErrorMessage(error),
                 });
-                await errorEmitter.next(error);
-                // Call onStrategyError callback if provided
-                if (walkerSchema.callbacks?.onStrategyError) {
-                    walkerSchema.callbacks.onStrategyError(strategyName, symbol, error);
+                const iterator = this.backtestLogicPublicService.run(symbol, {
+                    strategyName,
+                    exchangeName: context.exchangeName,
+                    frameName: context.frameName,
+                });
+                try {
+                    await functoolsKit.resolveDocuments(iterator);
                 }
-                continue;
-            }
-            if (result === CANCEL_SYMBOL) {
-                this.loggerService.info("walkerLogicPrivateService received stop signal, cancelling walker", {
-                    context,
+                catch (error) {
+                    console.warn(`walkerLogicPrivateService backtest failed symbol=${symbol} strategyName=${strategyName} exchangeName=${context.exchangeName}`);
+                    this.loggerService.warn("walkerLogicPrivateService backtest failed for strategy, skipping", {
+                        strategyName,
+                        symbol,
+                        error: functoolsKit.errorData(error), message: functoolsKit.getErrorMessage(error),
+                    });
+                    await errorEmitter.next(error);
+                    // Call onStrategyError callback if provided
+                    if (walkerSchema.callbacks?.onStrategyError) {
+                        walkerSchema.callbacks.onStrategyError(strategyName, symbol, error);
+                    }
+                    continue;
+                }
+                this.loggerService.info("walkerLogicPrivateService backtest complete", {
+                    strategyName,
+                    symbol,
                 });
-                break;
-            }
-            this.loggerService.info("walkerLogicPrivateService backtest complete", {
-                strategyName,
-                symbol,
-            });
-            // Get statistics from BacktestMarkdownService
-            const stats = await this.backtestMarkdownService.getData(symbol, strategyName);
-            // Extract metric value
-            const value = stats[metric];
-            const metricValue = value !== null &&
-                value !== undefined &&
-                typeof value === "number" &&
-                !isNaN(value) &&
-                isFinite(value)
-                ? value
-                : null;
-            // Update best strategy if needed
-            const isBetter = bestMetric === null ||
-                (metricValue !== null && metricValue > bestMetric);
-            if (isBetter && metricValue !== null) {
-                bestMetric = metricValue;
-                bestStrategy = strategyName;
-            }
-            strategiesTested++;
-            const walkerContract = {
-                walkerName: context.walkerName,
-                exchangeName: context.exchangeName,
-                frameName: context.frameName,
-                symbol,
-                strategyName,
-                stats,
-                metricValue,
-                metric,
-                bestMetric,
-                bestStrategy,
-                strategiesTested,
-                totalStrategies: strategies.length,
-            };
-            // Emit progress event
-            await progressWalkerEmitter.next({
-                walkerName: context.walkerName,
-                exchangeName: context.exchangeName,
-                frameName: context.frameName,
-                symbol,
-                totalStrategies: strategies.length,
-                processedStrategies: strategiesTested,
-                progress: strategies.length > 0 ? strategiesTested / strategies.length : 0,
-            });
-            // Call onStrategyComplete callback if provided
-            if (walkerSchema.callbacks?.onStrategyComplete) {
-                walkerSchema.callbacks.onStrategyComplete(strategyName, symbol, stats, metricValue);
+                // Get statistics from BacktestMarkdownService
+                const stats = await this.backtestMarkdownService.getData(symbol, strategyName);
+                // Extract metric value
+                const value = stats[metric];
+                const metricValue = value !== null &&
+                    value !== undefined &&
+                    typeof value === "number" &&
+                    !isNaN(value) &&
+                    isFinite(value)
+                    ? value
+                    : null;
+                // Update best strategy if needed
+                const isBetter = bestMetric === null ||
+                    (metricValue !== null && metricValue > bestMetric);
+                if (isBetter && metricValue !== null) {
+                    bestMetric = metricValue;
+                    bestStrategy = strategyName;
+                }
+                strategiesTested++;
+                const walkerContract = {
+                    walkerName: context.walkerName,
+                    exchangeName: context.exchangeName,
+                    frameName: context.frameName,
+                    symbol,
+                    strategyName,
+                    stats,
+                    metricValue,
+                    metric,
+                    bestMetric,
+                    bestStrategy,
+                    strategiesTested,
+                    totalStrategies: strategies.length,
+                };
+                // Emit progress event
+                await progressWalkerEmitter.next({
+                    walkerName: context.walkerName,
+                    exchangeName: context.exchangeName,
+                    frameName: context.frameName,
+                    symbol,
+                    totalStrategies: strategies.length,
+                    processedStrategies: strategiesTested,
+                    progress: strategies.length > 0 ? strategiesTested / strategies.length : 0,
+                });
+                // Call onStrategyComplete callback if provided
+                if (walkerSchema.callbacks?.onStrategyComplete) {
+                    await walkerSchema.callbacks.onStrategyComplete(strategyName, symbol, stats, metricValue);
+                }
+                await walkerEmitter.next(walkerContract);
+                yield walkerContract;
             }
-            await walkerEmitter.next(walkerContract);
-            yield walkerContract;
+        }
+        finally {
+            // Unsubscribe from stop signals by calling destructor
+            unsubscribe();
         }
         const finalResults = {
             walkerName: context.walkerName,
@@ -13270,19 +13399,53 @@ async function dumpSignal(signalId, history, signal, outputDir = "./dump/strateg
 
 const BACKTEST_METHOD_NAME_RUN = "BacktestUtils.run";
 const BACKTEST_METHOD_NAME_BACKGROUND = "BacktestUtils.background";
+const BACKTEST_METHOD_NAME_STOP = "BacktestUtils.stop";
 const BACKTEST_METHOD_NAME_GET_REPORT = "BacktestUtils.getReport";
 const BACKTEST_METHOD_NAME_DUMP = "BacktestUtils.dump";
+const BACKTEST_METHOD_NAME_TASK = "BacktestUtils.task";
+const BACKTEST_METHOD_NAME_GET_STATUS = "BacktestUtils.getStatus";
 /**
- * Utility class for backtest operations.
+ * Internal task function that runs backtest and handles completion.
+ * Consumes backtest results and updates instance state flags.
  *
- * Provides simplified access to backtestCommandService.run() with logging.
- * Exported as singleton instance for convenient usage.
+ * @param symbol - Trading pair symbol
+ * @param context - Execution context with strategy, exchange, and frame names
+ * @param self - BacktestInstance reference for state management
+ * @returns Promise that resolves when backtest completes
+ *
+ * @internal
+ */
+const INSTANCE_TASK_FN$2 = async (symbol, context, self) => {
+    {
+        self._isStopped = false;
+        self._isDone = false;
+    }
+    for await (const _ of self.run(symbol, context)) {
+        if (self._isStopped) {
+            break;
+        }
+    }
+    if (!self._isDone) {
+        await doneBacktestSubject.next({
+            exchangeName: context.exchangeName,
+            strategyName: context.strategyName,
+            backtest: true,
+            symbol,
+        });
+    }
+    self._isDone = true;
+};
+/**
+ * Instance class for backtest operations on a specific symbol-strategy pair.
+ *
+ * Provides isolated backtest execution and reporting for a single symbol-strategy combination.
+ * Each instance maintains its own state and context.
  *
  * @example
  * ```typescript
- * import { Backtest } from "./classes/Backtest";
+ * const instance = new BacktestInstance("BTCUSDT", "my-strategy");
  *
- * for await (const result of Backtest.run("BTCUSDT", {
+ * for await (const result of instance.run("BTCUSDT", {
  *   strategyName: "my-strategy",
  *   exchangeName: "my-exchange",
  *   frameName: "1d-backtest"
@@ -13291,8 +13454,57 @@ const BACKTEST_METHOD_NAME_DUMP = "BacktestUtils.dump";
  * }
  * ```
  */
-class BacktestUtils {
-    constructor() {
+class BacktestInstance {
+    /**
+     * Creates a new BacktestInstance for a specific symbol-strategy pair.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param strategyName - Strategy name for this backtest instance
+     */
+    constructor(symbol, strategyName) {
+        this.symbol = symbol;
+        this.strategyName = strategyName;
+        /** Internal flag indicating if backtest was stopped manually */
+        this._isStopped = false;
+        /** Internal flag indicating if backtest task completed */
+        this._isDone = false;
+        /**
+         * Internal singlerun task that executes the backtest.
+         * Ensures only one backtest run per instance using singlerun wrapper.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategy, exchange, and frame names
+         * @returns Promise that resolves when backtest completes
+         *
+         * @internal
+         */
+        this.task = functoolsKit.singlerun(async (symbol, context) => {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_TASK, {
+                symbol,
+                context,
+            });
+            return await INSTANCE_TASK_FN$2(symbol, context, this);
+        });
+        /**
+         * Gets the current status of this backtest instance.
+         *
+         * @returns Promise resolving to status object with symbol, strategyName, and task status
+         *
+         * @example
+         * ```typescript
+         * const instance = new BacktestInstance("BTCUSDT", "my-strategy");
+         * const status = await instance.getStatus();
+         * console.log(status.status); // "idle", "running", or "done"
+         * ```
+         */
+        this.getStatus = async () => {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_GET_STATUS);
+            return {
+                symbol: this.symbol,
+                strategyName: this.strategyName,
+                status: this.task.getStatus(),
+            };
+        };
         /**
          * Runs backtest for a symbol with context propagation.
          *
@@ -13330,13 +13542,12 @@ class BacktestUtils {
          *
          * @example
          * ```typescript
-         * // Run backtest silently, only callbacks will fire
-         * await Backtest.background("BTCUSDT", {
+         * const instance = new BacktestInstance();
+         * const cancel = instance.background("BTCUSDT", {
          *   strategyName: "my-strategy",
          *   exchangeName: "my-exchange",
          *   frameName: "1d-backtest"
          * });
-         * console.log("Backtest completed");
          * ```
          */
         this.background = (symbol, context) => {
@@ -13344,34 +13555,16 @@ class BacktestUtils {
                 symbol,
                 context,
             });
-            let isStopped = false;
-            let isDone = false;
-            const task = async () => {
-                for await (const _ of this.run(symbol, context)) {
-                    if (isStopped) {
-                        break;
-                    }
-                }
-                if (!isDone) {
-                    await doneBacktestSubject.next({
-                        exchangeName: context.exchangeName,
-                        strategyName: context.strategyName,
-                        backtest: true,
-                        symbol,
-                    });
-                }
-                isDone = true;
-            };
-            task().catch((error) => exitEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
+            this.task(symbol, context).catch((error) => exitEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
             return () => {
-                backtest$1.strategyGlobalService.stop({ symbol, strategyName: context.strategyName });
+                backtest$1.strategyGlobalService.stop({ symbol, strategyName: context.strategyName }, true);
                 backtest$1.strategyGlobalService
                     .getPendingSignal(symbol, context.strategyName)
                     .then(async (pendingSignal) => {
                     if (pendingSignal) {
                         return;
                     }
-                    if (!isDone) {
+                    if (!this._isDone) {
                         await doneBacktestSubject.next({
                             exchangeName: context.exchangeName,
                             strategyName: context.strategyName,
@@ -13379,11 +13572,35 @@ class BacktestUtils {
                             symbol,
                         });
                     }
-                    isDone = true;
+                    this._isDone = true;
                 });
-                isStopped = true;
+                this._isStopped = true;
             };
         };
+        /**
+         * Stops the strategy from generating new signals.
+         *
+         * Sets internal flag to prevent strategy from opening new signals.
+         * Current active signal (if any) will complete normally.
+         * Backtest will stop at the next safe point (idle state or after signal closes).
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy name to stop
+         * @returns Promise that resolves when stop flag is set
+         *
+         * @example
+         * ```typescript
+         * const instance = new BacktestInstance();
+         * await instance.stop("BTCUSDT", "my-strategy");
+         * ```
+         */
+        this.stop = async (symbol, strategyName) => {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_STOP, {
+                symbol,
+                strategyName,
+            });
+            await backtest$1.strategyGlobalService.stop({ symbol, strategyName }, true);
+        };
         /**
          * Gets statistical data from all closed signals for a symbol-strategy pair.
          *
@@ -13393,7 +13610,8 @@ class BacktestUtils {
          *
          * @example
          * ```typescript
-         * const stats = await Backtest.getData("BTCUSDT", "my-strategy");
+         * const instance = new BacktestInstance();
+         * const stats = await instance.getData("BTCUSDT", "my-strategy");
          * console.log(stats.sharpeRatio, stats.winRate);
          * ```
          */
@@ -13413,7 +13631,8 @@ class BacktestUtils {
          *
          * @example
          * ```typescript
-         * const markdown = await Backtest.getReport("BTCUSDT", "my-strategy");
+         * const instance = new BacktestInstance();
+         * const markdown = await instance.getReport("BTCUSDT", "my-strategy");
          * console.log(markdown);
          * ```
          */
@@ -13433,11 +13652,12 @@ class BacktestUtils {
          *
          * @example
          * ```typescript
+         * const instance = new BacktestInstance();
          * // Save to default path: ./dump/backtest/my-strategy.md
-         * await Backtest.dump("BTCUSDT", "my-strategy");
+         * await instance.dump("BTCUSDT", "my-strategy");
          *
          * // Save to custom path: ./custom/path/my-strategy.md
-         * await Backtest.dump("BTCUSDT", "my-strategy", "./custom/path");
+         * await instance.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
         this.dump = async (symbol, strategyName, path) => {
@@ -13451,7 +13671,10 @@ class BacktestUtils {
     }
 }
 /**
- * Singleton instance of BacktestUtils for convenient backtest operations.
+ * Utility class for backtest operations.
+ *
+ * Provides simplified access to backtestCommandService.run() with logging.
+ * Exported as singleton instance for convenient usage.
  *
  * @example
  * ```typescript
@@ -13462,49 +13685,276 @@ class BacktestUtils {
  *   exchangeName: "my-exchange",
  *   frameName: "1d-backtest"
  * })) {
- *   if (result.action === "closed") {
- *     console.log("PNL:", result.pnl.pnlPercentage);
- *   }
+ *   console.log("Closed signal PNL:", result.pnl.pnlPercentage);
  * }
  * ```
  */
-const Backtest = new BacktestUtils();
-
-const LIVE_METHOD_NAME_RUN = "LiveUtils.run";
-const LIVE_METHOD_NAME_BACKGROUND = "LiveUtils.background";
-const LIVE_METHOD_NAME_GET_REPORT = "LiveUtils.getReport";
-const LIVE_METHOD_NAME_DUMP = "LiveUtils.dump";
-/**
- * Utility class for live trading operations.
- *
- * Provides simplified access to liveCommandService.run() with logging.
- * Exported as singleton instance for convenient usage.
- *
- * Features:
- * - Infinite async generator (never completes)
- * - Crash recovery via persisted state
- * - Real-time progression with Date.now()
- *
- * @example
- * ```typescript
- * import { Live } from "./classes/Live";
- *
- * // Infinite loop - use Ctrl+C to stop
- * for await (const result of Live.run("BTCUSDT", {
- *   strategyName: "my-strategy",
- *   exchangeName: "my-exchange",
- *   frameName: ""
- * })) {
- *   if (result.action === "opened") {
- *     console.log("Signal opened:", result.signal);
- *   } else if (result.action === "closed") {
- *     console.log("PNL:", result.pnl.pnlPercentage);
- *   }
- * }
- * ```
- */
-class LiveUtils {
+class BacktestUtils {
     constructor() {
+        /**
+         * Memoized function to get or create BacktestInstance for a symbol-strategy pair.
+         * Each symbol-strategy combination gets its own isolated instance.
+         */
+        this._getInstance = functoolsKit.memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, (symbol, strategyName) => new BacktestInstance(symbol, strategyName));
+        /**
+         * Runs backtest for a symbol with context propagation.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param context - Execution context with strategy, exchange, and frame names
+         * @returns Async generator yielding closed signals with PNL
+         */
+        this.run = (symbol, context) => {
+            const instance = this._getInstance(symbol, context.strategyName);
+            return instance.run(symbol, context);
+        };
+        /**
+         * Runs backtest in background without yielding results.
+         *
+         * Consumes all backtest results internally without exposing them.
+         * Useful for running backtests for side effects only (callbacks, logging).
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param context - Execution context with strategy, exchange, and frame names
+         * @returns Cancellation closure
+         *
+         * @example
+         * ```typescript
+         * // Run backtest silently, only callbacks will fire
+         * await Backtest.background("BTCUSDT", {
+         *   strategyName: "my-strategy",
+         *   exchangeName: "my-exchange",
+         *   frameName: "1d-backtest"
+         * });
+         * console.log("Backtest completed");
+         * ```
+         */
+        this.background = (symbol, context) => {
+            const instance = this._getInstance(symbol, context.strategyName);
+            return instance.background(symbol, context);
+        };
+        /**
+         * Stops the strategy from generating new signals.
+         *
+         * Sets internal flag to prevent strategy from opening new signals.
+         * Current active signal (if any) will complete normally.
+         * Backtest will stop at the next safe point (idle state or after signal closes).
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy name to stop
+         * @returns Promise that resolves when stop flag is set
+         *
+         * @example
+         * ```typescript
+         * // Stop strategy after some condition
+         * await Backtest.stop("BTCUSDT", "my-strategy");
+         * ```
+         */
+        this.stop = async (symbol, strategyName) => {
+            const instance = this._getInstance(symbol, strategyName);
+            return await instance.stop(symbol, strategyName);
+        };
+        /**
+         * Gets statistical data from all closed signals for a symbol-strategy pair.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy name to get data for
+         * @returns Promise resolving to statistical data object
+         *
+         * @example
+         * ```typescript
+         * const stats = await Backtest.getData("BTCUSDT", "my-strategy");
+         * console.log(stats.sharpeRatio, stats.winRate);
+         * ```
+         */
+        this.getData = async (symbol, strategyName) => {
+            const instance = this._getInstance(symbol, strategyName);
+            return await instance.getData(symbol, strategyName);
+        };
+        /**
+         * Generates markdown report with all closed signals for a symbol-strategy pair.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy name to generate report for
+         * @returns Promise resolving to markdown formatted report string
+         *
+         * @example
+         * ```typescript
+         * const markdown = await Backtest.getReport("BTCUSDT", "my-strategy");
+         * console.log(markdown);
+         * ```
+         */
+        this.getReport = async (symbol, strategyName) => {
+            const instance = this._getInstance(symbol, strategyName);
+            return await instance.getReport(symbol, strategyName);
+        };
+        /**
+         * Saves strategy report to disk.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy name to save report for
+         * @param path - Optional directory path to save report (default: "./dump/backtest")
+         *
+         * @example
+         * ```typescript
+         * // Save to default path: ./dump/backtest/my-strategy.md
+         * await Backtest.dump("BTCUSDT", "my-strategy");
+         *
+         * // Save to custom path: ./custom/path/my-strategy.md
+         * await Backtest.dump("BTCUSDT", "my-strategy", "./custom/path");
+         * ```
+         */
+        this.dump = async (symbol, strategyName, path) => {
+            const instance = this._getInstance(symbol, strategyName);
+            return await instance.dump(symbol, strategyName, path);
+        };
+        /**
+         * Lists all active backtest instances with their current status.
+         *
+         * @returns Promise resolving to array of status objects for all instances
+         *
+         * @example
+         * ```typescript
+         * const statusList = await Backtest.list();
+         * statusList.forEach(status => {
+         *   console.log(`${status.symbol} - ${status.strategyName}: ${status.status}`);
+         * });
+         * ```
+         */
+        this.list = async () => {
+            const instanceList = this._getInstance.values();
+            return await Promise.all(instanceList.map((instance) => instance.getStatus()));
+        };
+    }
+}
+/**
+ * Singleton instance of BacktestUtils for convenient backtest operations.
+ *
+ * @example
+ * ```typescript
+ * import { Backtest } from "./classes/Backtest";
+ *
+ * for await (const result of Backtest.run("BTCUSDT", {
+ *   strategyName: "my-strategy",
+ *   exchangeName: "my-exchange",
+ *   frameName: "1d-backtest"
+ * })) {
+ *   if (result.action === "closed") {
+ *     console.log("PNL:", result.pnl.pnlPercentage);
+ *   }
+ * }
+ * ```
+ */
+const Backtest = new BacktestUtils();
+
+const LIVE_METHOD_NAME_RUN = "LiveUtils.run";
+const LIVE_METHOD_NAME_BACKGROUND = "LiveUtils.background";
+const LIVE_METHOD_NAME_STOP = "LiveUtils.stop";
+const LIVE_METHOD_NAME_GET_REPORT = "LiveUtils.getReport";
+const LIVE_METHOD_NAME_DUMP = "LiveUtils.dump";
+const LIVE_METHOD_NAME_TASK = "LiveUtils.task";
+const LIVE_METHOD_NAME_GET_STATUS = "LiveUtils.getStatus";
+/**
+ * Internal task function that runs live trading and handles completion.
+ * Consumes live trading results and updates instance state flags.
+ *
+ * @param symbol - Trading pair symbol
+ * @param context - Execution context with strategy and exchange names
+ * @param self - LiveInstance reference for state management
+ * @returns Promise that resolves when live trading completes
+ *
+ * @internal
+ */
+const INSTANCE_TASK_FN$1 = async (symbol, context, self) => {
+    {
+        self._isStopped = false;
+        self._isDone = false;
+    }
+    for await (const signal of self.run(symbol, context)) {
+        if (signal?.action === "closed" && self._isStopped) {
+            break;
+        }
+    }
+    if (!self._isDone) {
+        await doneLiveSubject.next({
+            exchangeName: context.exchangeName,
+            strategyName: context.strategyName,
+            backtest: false,
+            symbol,
+        });
+    }
+    self._isDone = true;
+};
+/**
+ * Instance class for live trading operations on a specific symbol-strategy pair.
+ *
+ * Provides isolated live trading execution and reporting for a single symbol-strategy combination.
+ * Each instance maintains its own state and context.
+ *
+ * @example
+ * ```typescript
+ * const instance = new LiveInstance("BTCUSDT", "my-strategy");
+ *
+ * for await (const result of instance.run("BTCUSDT", {
+ *   strategyName: "my-strategy",
+ *   exchangeName: "my-exchange"
+ * })) {
+ *   if (result.action === "closed") {
+ *     console.log("Signal closed, PNL:", result.pnl.pnlPercentage);
+ *   }
+ * }
+ * ```
+ */
+class LiveInstance {
+    /**
+     * Creates a new LiveInstance for a specific symbol-strategy pair.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param strategyName - Strategy name for this live trading instance
+     */
+    constructor(symbol, strategyName) {
+        this.symbol = symbol;
+        this.strategyName = strategyName;
+        /** Internal flag indicating if live trading was stopped manually */
+        this._isStopped = false;
+        /** Internal flag indicating if live trading task completed */
+        this._isDone = false;
+        /**
+         * Internal singlerun task that executes the live trading.
+         * Ensures only one live trading run per instance using singlerun wrapper.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategy and exchange names
+         * @returns Promise that resolves when live trading completes
+         *
+         * @internal
+         */
+        this.task = functoolsKit.singlerun(async (symbol, context) => {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_TASK, {
+                symbol,
+                context,
+            });
+            return await INSTANCE_TASK_FN$1(symbol, context, this);
+        });
+        /**
+         * Gets the current status of this live trading instance.
+         *
+         * @returns Promise resolving to status object with symbol, strategyName, and task status
+         *
+         * @example
+         * ```typescript
+         * const instance = new LiveInstance("BTCUSDT", "my-strategy");
+         * const status = await instance.getStatus();
+         * console.log(status.status); // "idle", "running", or "done"
+         * ```
+         */
+        this.getStatus = async () => {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_GET_STATUS);
+            return {
+                symbol: this.symbol,
+                strategyName: this.strategyName,
+                status: this.task.getStatus(),
+            };
+        };
         /**
          * Runs live trading for a symbol with context propagation.
          *
@@ -13546,9 +13996,8 @@ class LiveUtils {
          *
          * @example
          * ```typescript
-         * // Run live trading silently in background, only callbacks will fire
-         * // This will run forever until Ctrl+C
-         * await Live.background("BTCUSDT", {
+         * const instance = new LiveInstance();
+         * const cancel = instance.background("BTCUSDT", {
          *   strategyName: "my-strategy",
          *   exchangeName: "my-exchange"
          * });
@@ -13559,34 +14008,16 @@ class LiveUtils {
                 symbol,
                 context,
             });
-            let isStopped = false;
-            let isDone = false;
-            const task = async () => {
-                for await (const signal of this.run(symbol, context)) {
-                    if (signal?.action === "closed" && isStopped) {
-                        break;
-                    }
-                }
-                if (!isDone) {
-                    await doneLiveSubject.next({
-                        exchangeName: context.exchangeName,
-                        strategyName: context.strategyName,
-                        backtest: false,
-                        symbol,
-                    });
-                }
-                isDone = true;
-            };
-            task().catch((error) => exitEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
+            this.task(symbol, context).catch((error) => exitEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
             return () => {
-                backtest$1.strategyGlobalService.stop({ symbol, strategyName: context.strategyName });
+                backtest$1.strategyGlobalService.stop({ symbol, strategyName: context.strategyName }, false);
                 backtest$1.strategyGlobalService
                     .getPendingSignal(symbol, context.strategyName)
                     .then(async (pendingSignal) => {
                     if (pendingSignal) {
                         return;
                     }
-                    if (!isDone) {
+                    if (!this._isDone) {
                         await doneLiveSubject.next({
                             exchangeName: context.exchangeName,
                             strategyName: context.strategyName,
@@ -13594,11 +14025,200 @@ class LiveUtils {
                             symbol,
                         });
                     }
-                    isDone = true;
+                    this._isDone = true;
                 });
-                isStopped = true;
+                this._isStopped = true;
             };
         };
+        /**
+         * Stops the strategy from generating new signals.
+         *
+         * Sets internal flag to prevent strategy from opening new signals.
+         * Current active signal (if any) will complete normally.
+         * Live trading will stop at the next safe point (idle/closed state).
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy name to stop
+         * @returns Promise that resolves when stop flag is set
+         *
+         * @example
+         * ```typescript
+         * const instance = new LiveInstance();
+         * await instance.stop("BTCUSDT", "my-strategy");
+         * ```
+         */
+        this.stop = async (symbol, strategyName) => {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_STOP, {
+                symbol,
+                strategyName,
+            });
+            await backtest$1.strategyGlobalService.stop({ symbol, strategyName }, false);
+        };
+        /**
+         * Gets statistical data from all live trading events for a symbol-strategy pair.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy name to get data for
+         * @returns Promise resolving to statistical data object
+         *
+         * @example
+         * ```typescript
+         * const instance = new LiveInstance();
+         * const stats = await instance.getData("BTCUSDT", "my-strategy");
+         * console.log(stats.sharpeRatio, stats.winRate);
+         * ```
+         */
+        this.getData = async (symbol, strategyName) => {
+            backtest$1.loggerService.info("LiveUtils.getData", {
+                symbol,
+                strategyName,
+            });
+            return await backtest$1.liveMarkdownService.getData(symbol, strategyName);
+        };
+        /**
+         * Generates markdown report with all events for a symbol-strategy pair.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy name to generate report for
+         * @returns Promise resolving to markdown formatted report string
+         *
+         * @example
+         * ```typescript
+         * const instance = new LiveInstance();
+         * const markdown = await instance.getReport("BTCUSDT", "my-strategy");
+         * console.log(markdown);
+         * ```
+         */
+        this.getReport = async (symbol, strategyName) => {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_GET_REPORT, {
+                symbol,
+                strategyName,
+            });
+            return await backtest$1.liveMarkdownService.getReport(symbol, strategyName);
+        };
+        /**
+         * Saves strategy report to disk.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy name to save report for
+         * @param path - Optional directory path to save report (default: "./dump/live")
+         *
+         * @example
+         * ```typescript
+         * const instance = new LiveInstance();
+         * // Save to default path: ./dump/live/my-strategy.md
+         * await instance.dump("BTCUSDT", "my-strategy");
+         *
+         * // Save to custom path: ./custom/path/my-strategy.md
+         * await instance.dump("BTCUSDT", "my-strategy", "./custom/path");
+         * ```
+         */
+        this.dump = async (symbol, strategyName, path) => {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_DUMP, {
+                symbol,
+                strategyName,
+                path,
+            });
+            await backtest$1.liveMarkdownService.dump(symbol, strategyName, path);
+        };
+    }
+}
+/**
+ * Utility class for live trading operations.
+ *
+ * Provides simplified access to liveCommandService.run() with logging.
+ * Exported as singleton instance for convenient usage.
+ *
+ * Features:
+ * - Infinite async generator (never completes)
+ * - Crash recovery via persisted state
+ * - Real-time progression with Date.now()
+ *
+ * @example
+ * ```typescript
+ * import { Live } from "./classes/Live";
+ *
+ * // Infinite loop - use Ctrl+C to stop
+ * for await (const result of Live.run("BTCUSDT", {
+ *   strategyName: "my-strategy",
+ *   exchangeName: "my-exchange",
+ *   frameName: ""
+ * })) {
+ *   if (result.action === "opened") {
+ *     console.log("Signal opened:", result.signal);
+ *   } else if (result.action === "closed") {
+ *     console.log("PNL:", result.pnl.pnlPercentage);
+ *   }
+ * }
+ * ```
+ */
+class LiveUtils {
+    constructor() {
+        /**
+         * Memoized function to get or create LiveInstance for a symbol-strategy pair.
+         * Each symbol-strategy combination gets its own isolated instance.
+         */
+        this._getInstance = functoolsKit.memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, (symbol, strategyName) => new LiveInstance(symbol, strategyName));
+        /**
+         * Runs live trading for a symbol with context propagation.
+         *
+         * Infinite async generator with crash recovery support.
+         * Process can crash and restart - state will be recovered from disk.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param context - Execution context with strategy and exchange names
+         * @returns Infinite async generator yielding opened and closed signals
+         */
+        this.run = (symbol, context) => {
+            const instance = this._getInstance(symbol, context.strategyName);
+            return instance.run(symbol, context);
+        };
+        /**
+         * Runs live trading in background without yielding results.
+         *
+         * Consumes all live trading results internally without exposing them.
+         * Infinite loop - will run until process is stopped or crashes.
+         * Useful for running live trading for side effects only (callbacks, persistence).
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param context - Execution context with strategy and exchange names
+         * @returns Cancellation closure
+         *
+         * @example
+         * ```typescript
+         * // Run live trading silently in background, only callbacks will fire
+         * // This will run forever until Ctrl+C
+         * await Live.background("BTCUSDT", {
+         *   strategyName: "my-strategy",
+         *   exchangeName: "my-exchange"
+         * });
+         * ```
+         */
+        this.background = (symbol, context) => {
+            const instance = this._getInstance(symbol, context.strategyName);
+            return instance.background(symbol, context);
+        };
+        /**
+         * Stops the strategy from generating new signals.
+         *
+         * Sets internal flag to prevent strategy from opening new signals.
+         * Current active signal (if any) will complete normally.
+         * Live trading will stop at the next safe point (idle/closed state).
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy name to stop
+         * @returns Promise that resolves when stop flag is set
+         *
+         * @example
+         * ```typescript
+         * // Stop live trading gracefully
+         * await Live.stop("BTCUSDT", "my-strategy");
+         * ```
+         */
+        this.stop = async (symbol, strategyName) => {
+            const instance = this._getInstance(symbol, strategyName);
+            return await instance.stop(symbol, strategyName);
+        };
         /**
          * Gets statistical data from all live trading events for a symbol-strategy pair.
          *
@@ -13613,11 +14233,8 @@ class LiveUtils {
          * ```
          */
         this.getData = async (symbol, strategyName) => {
-            backtest$1.loggerService.info("LiveUtils.getData", {
-                symbol,
-                strategyName,
-            });
-            return await backtest$1.liveMarkdownService.getData(symbol, strategyName);
+            const instance = this._getInstance(symbol, strategyName);
+            return await instance.getData(symbol, strategyName);
         };
         /**
          * Generates markdown report with all events for a symbol-strategy pair.
@@ -13633,11 +14250,8 @@ class LiveUtils {
          * ```
          */
         this.getReport = async (symbol, strategyName) => {
-            backtest$1.loggerService.info(LIVE_METHOD_NAME_GET_REPORT, {
-                symbol,
-                strategyName,
-            });
-            return await backtest$1.liveMarkdownService.getReport(symbol, strategyName);
+            const instance = this._getInstance(symbol, strategyName);
+            return await instance.getReport(symbol, strategyName);
         };
         /**
          * Saves strategy report to disk.
@@ -13656,12 +14270,25 @@ class LiveUtils {
          * ```
          */
         this.dump = async (symbol, strategyName, path) => {
-            backtest$1.loggerService.info(LIVE_METHOD_NAME_DUMP, {
-                symbol,
-                strategyName,
-                path,
-            });
-            await backtest$1.liveMarkdownService.dump(symbol, strategyName, path);
+            const instance = this._getInstance(symbol, strategyName);
+            return await instance.dump(symbol, strategyName, path);
+        };
+        /**
+         * Lists all active live trading instances with their current status.
+         *
+         * @returns Promise resolving to array of status objects for all instances
+         *
+         * @example
+         * ```typescript
+         * const statusList = await Live.list();
+         * statusList.forEach(status => {
+         *   console.log(`${status.symbol} - ${status.strategyName}: ${status.status}`);
+         * });
+         * ```
+         */
+        this.list = async () => {
+            const instanceList = this._getInstance.values();
+            return await Promise.all(instanceList.map((instance) => instance.getStatus()));
         };
     }
 }
@@ -13906,30 +14533,112 @@ class Performance {
 
 const WALKER_METHOD_NAME_RUN = "WalkerUtils.run";
 const WALKER_METHOD_NAME_BACKGROUND = "WalkerUtils.background";
+const WALKER_METHOD_NAME_STOP = "WalkerUtils.stop";
 const WALKER_METHOD_NAME_GET_DATA = "WalkerUtils.getData";
 const WALKER_METHOD_NAME_GET_REPORT = "WalkerUtils.getReport";
 const WALKER_METHOD_NAME_DUMP = "WalkerUtils.dump";
+const WALKER_METHOD_NAME_TASK = "WalkerUtils.task";
+const WALKER_METHOD_NAME_GET_STATUS = "WalkerUtils.getStatus";
 /**
- * Utility class for walker operations.
+ * Internal task function that runs walker and handles completion.
+ * Consumes walker results and updates instance state flags.
  *
- * Provides simplified access to walkerCommandService.run() with logging.
- * Automatically pulls exchangeName and frameName from walker schema.
- * Exported as singleton instance for convenient usage.
+ * @param symbol - Trading pair symbol
+ * @param context - Execution context with walker name
+ * @param self - WalkerInstance reference for state management
+ * @returns Promise that resolves when walker completes
+ *
+ * @internal
+ */
+const INSTANCE_TASK_FN = async (symbol, context, self) => {
+    {
+        self._isStopped = false;
+        self._isDone = false;
+    }
+    for await (const _ of self.run(symbol, context)) {
+        if (self._isStopped) {
+            break;
+        }
+    }
+    if (!self._isDone) {
+        const walkerSchema = backtest$1.walkerSchemaService.get(context.walkerName);
+        await doneWalkerSubject.next({
+            exchangeName: walkerSchema.exchangeName,
+            strategyName: context.walkerName,
+            backtest: true,
+            symbol,
+        });
+    }
+    self._isDone = true;
+};
+/**
+ * Instance class for walker operations on a specific symbol-walker pair.
+ *
+ * Provides isolated walker execution and reporting for a single symbol-walker combination.
+ * Each instance maintains its own state and context.
  *
  * @example
  * ```typescript
- * import { Walker } from "./classes/Walker";
+ * const instance = new WalkerInstance("BTCUSDT", "my-walker");
  *
- * for await (const result of Walker.run("BTCUSDT", {
+ * for await (const result of instance.run("BTCUSDT", {
  *   walkerName: "my-walker"
  * })) {
  *   console.log("Progress:", result.strategiesTested, "/", result.totalStrategies);
- *   console.log("Best strategy:", result.bestStrategy, result.bestMetric);
  * }
  * ```
  */
-class WalkerUtils {
-    constructor() {
+class WalkerInstance {
+    /**
+     * Creates a new WalkerInstance for a specific symbol-walker pair.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param walkerName - Walker name for this walker instance
+     */
+    constructor(symbol, walkerName) {
+        this.symbol = symbol;
+        this.walkerName = walkerName;
+        /** Internal flag indicating if walker was stopped manually */
+        this._isStopped = false;
+        /** Internal flag indicating if walker task completed */
+        this._isDone = false;
+        /**
+         * Internal singlerun task that executes the walker.
+         * Ensures only one walker run per instance using singlerun wrapper.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with walker name
+         * @returns Promise that resolves when walker completes
+         *
+         * @internal
+         */
+        this.task = functoolsKit.singlerun(async (symbol, context) => {
+            backtest$1.loggerService.info(WALKER_METHOD_NAME_TASK, {
+                symbol,
+                context,
+            });
+            return await INSTANCE_TASK_FN(symbol, context, this);
+        });
+        /**
+         * Gets the current status of this walker instance.
+         *
+         * @returns Promise resolving to status object with symbol, walkerName, and task status
+         *
+         * @example
+         * ```typescript
+         * const instance = new WalkerInstance("BTCUSDT", "my-walker");
+         * const status = await instance.getStatus();
+         * console.log(status.status); // "idle", "running", or "done"
+         * ```
+         */
+        this.getStatus = async () => {
+            backtest$1.loggerService.info(WALKER_METHOD_NAME_GET_STATUS);
+            return {
+                symbol: this.symbol,
+                walkerName: this.walkerName,
+                status: this.task.getStatus(),
+            };
+        };
         /**
          * Runs walker comparison for a symbol with context propagation.
          *
@@ -13982,11 +14691,10 @@ class WalkerUtils {
          *
          * @example
          * ```typescript
-         * // Run walker silently, only callbacks will fire
-         * await Walker.background("BTCUSDT", {
+         * const instance = new WalkerInstance();
+         * const cancel = instance.background("BTCUSDT", {
          *   walkerName: "my-walker"
          * });
-         * console.log("Walker comparison completed");
          * ```
          */
         this.background = (symbol, context) => {
@@ -13995,31 +14703,13 @@ class WalkerUtils {
                 context,
             });
             const walkerSchema = backtest$1.walkerSchemaService.get(context.walkerName);
-            let isStopped = false;
-            let isDone = false;
-            const task = async () => {
-                for await (const _ of this.run(symbol, context)) {
-                    if (isStopped) {
-                        break;
-                    }
-                }
-                if (!isDone) {
-                    await doneWalkerSubject.next({
-                        exchangeName: walkerSchema.exchangeName,
-                        strategyName: context.walkerName,
-                        backtest: true,
-                        symbol,
-                    });
-                }
-                isDone = true;
-            };
-            task().catch((error) => exitEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
+            this.task(symbol, context).catch((error) => exitEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
             return () => {
                 for (const strategyName of walkerSchema.strategies) {
-                    backtest$1.strategyGlobalService.stop({ symbol, strategyName });
-                    walkerStopSubject.next({ symbol, strategyName });
+                    backtest$1.strategyGlobalService.stop({ symbol, strategyName }, true);
+                    walkerStopSubject.next({ symbol, strategyName, walkerName: context.walkerName });
                 }
-                if (!isDone) {
+                if (!this._isDone) {
                     doneWalkerSubject.next({
                         exchangeName: walkerSchema.exchangeName,
                         strategyName: context.walkerName,
@@ -14027,10 +14717,44 @@ class WalkerUtils {
                         symbol,
                     });
                 }
-                isDone = true;
-                isStopped = true;
+                this._isDone = true;
+                this._isStopped = true;
             };
         };
+        /**
+         * Stops all strategies in the walker from generating new signals.
+         *
+         * Iterates through all strategies defined in walker schema and:
+         * 1. Sends stop signal via walkerStopSubject (interrupts current running strategy)
+         * 2. Sets internal stop flag for each strategy (prevents new signals)
+         *
+         * Current active signals (if any) will complete normally.
+         * Walker will stop at the next safe point.
+         *
+         * Supports multiple walkers running on the same symbol simultaneously.
+         * Stop signal is filtered by walkerName to prevent interference.
+         *
+         * @param symbol - Trading pair symbol
+         * @param walkerName - Walker name to stop
+         * @returns Promise that resolves when all stop flags are set
+         *
+         * @example
+         * ```typescript
+         * const instance = new WalkerInstance();
+         * await instance.stop("BTCUSDT", "my-walker");
+         * ```
+         */
+        this.stop = async (symbol, walkerName) => {
+            backtest$1.loggerService.info(WALKER_METHOD_NAME_STOP, {
+                symbol,
+                walkerName,
+            });
+            const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
+            for (const strategyName of walkerSchema.strategies) {
+                await walkerStopSubject.next({ symbol, strategyName, walkerName });
+                await backtest$1.strategyGlobalService.stop({ symbol, strategyName }, true);
+            }
+        };
         /**
          * Gets walker results data from all strategy comparisons.
          *
@@ -14040,7 +14764,8 @@ class WalkerUtils {
          *
          * @example
          * ```typescript
-         * const results = await Walker.getData("BTCUSDT", "my-walker");
+         * const instance = new WalkerInstance();
+         * const results = await instance.getData("BTCUSDT", "my-walker");
          * console.log(results.bestStrategy, results.bestMetric);
          * ```
          */
@@ -14064,7 +14789,8 @@ class WalkerUtils {
          *
          * @example
          * ```typescript
-         * const markdown = await Walker.getReport("BTCUSDT", "my-walker");
+         * const instance = new WalkerInstance();
+         * const markdown = await instance.getReport("BTCUSDT", "my-walker");
          * console.log(markdown);
          * ```
          */
@@ -14088,11 +14814,12 @@ class WalkerUtils {
          *
          * @example
          * ```typescript
+         * const instance = new WalkerInstance();
          * // Save to default path: ./dump/walker/my-walker.md
-         * await Walker.dump("BTCUSDT", "my-walker");
+         * await instance.dump("BTCUSDT", "my-walker");
          *
          * // Save to custom path: ./custom/path/my-walker.md
-         * await Walker.dump("BTCUSDT", "my-walker", "./custom/path");
+         * await instance.dump("BTCUSDT", "my-walker", "./custom/path");
          * ```
          */
         this.dump = async (symbol, walkerName, path) => {
@@ -14109,6 +14836,166 @@ class WalkerUtils {
         };
     }
 }
+/**
+ * Utility class for walker operations.
+ *
+ * Provides simplified access to walkerCommandService.run() with logging.
+ * Automatically pulls exchangeName and frameName from walker schema.
+ * Exported as singleton instance for convenient usage.
+ *
+ * @example
+ * ```typescript
+ * import { Walker } from "./classes/Walker";
+ *
+ * for await (const result of Walker.run("BTCUSDT", {
+ *   walkerName: "my-walker"
+ * })) {
+ *   console.log("Progress:", result.strategiesTested, "/", result.totalStrategies);
+ *   console.log("Best strategy:", result.bestStrategy, result.bestMetric);
+ * }
+ * ```
+ */
+class WalkerUtils {
+    constructor() {
+        /**
+         * Memoized function to get or create WalkerInstance for a symbol-walker pair.
+         * Each symbol-walker combination gets its own isolated instance.
+         */
+        this._getInstance = functoolsKit.memoize(([symbol, walkerName]) => `${symbol}:${walkerName}`, (symbol, walkerName) => new WalkerInstance(symbol, walkerName));
+        /**
+         * Runs walker comparison for a symbol with context propagation.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param context - Execution context with walker name
+         * @returns Async generator yielding progress updates after each strategy
+         */
+        this.run = (symbol, context) => {
+            const instance = this._getInstance(symbol, context.walkerName);
+            return instance.run(symbol, context);
+        };
+        /**
+         * Runs walker comparison in background without yielding results.
+         *
+         * Consumes all walker progress updates internally without exposing them.
+         * Useful for running walker comparison for side effects only (callbacks, logging).
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param context - Execution context with walker name
+         * @returns Cancellation closure
+         *
+         * @example
+         * ```typescript
+         * // Run walker silently, only callbacks will fire
+         * await Walker.background("BTCUSDT", {
+         *   walkerName: "my-walker"
+         * });
+         * console.log("Walker comparison completed");
+         * ```
+         */
+        this.background = (symbol, context) => {
+            const instance = this._getInstance(symbol, context.walkerName);
+            return instance.background(symbol, context);
+        };
+        /**
+         * Stops all strategies in the walker from generating new signals.
+         *
+         * Iterates through all strategies defined in walker schema and:
+         * 1. Sends stop signal via walkerStopSubject (interrupts current running strategy)
+         * 2. Sets internal stop flag for each strategy (prevents new signals)
+         *
+         * Current active signals (if any) will complete normally.
+         * Walker will stop at the next safe point.
+         *
+         * Supports multiple walkers running on the same symbol simultaneously.
+         * Stop signal is filtered by walkerName to prevent interference.
+         *
+         * @param symbol - Trading pair symbol
+         * @param walkerName - Walker name to stop
+         * @returns Promise that resolves when all stop flags are set
+         *
+         * @example
+         * ```typescript
+         * // Stop walker and all its strategies
+         * await Walker.stop("BTCUSDT", "my-walker");
+         * ```
+         */
+        this.stop = async (symbol, walkerName) => {
+            const instance = this._getInstance(symbol, walkerName);
+            return await instance.stop(symbol, walkerName);
+        };
+        /**
+         * Gets walker results data from all strategy comparisons.
+         *
+         * @param symbol - Trading symbol
+         * @param walkerName - Walker name to get data for
+         * @returns Promise resolving to walker results data object
+         *
+         * @example
+         * ```typescript
+         * const results = await Walker.getData("BTCUSDT", "my-walker");
+         * console.log(results.bestStrategy, results.bestMetric);
+         * ```
+         */
+        this.getData = async (symbol, walkerName) => {
+            const instance = this._getInstance(symbol, walkerName);
+            return await instance.getData(symbol, walkerName);
+        };
+        /**
+         * Generates markdown report with all strategy comparisons for a walker.
+         *
+         * @param symbol - Trading symbol
+         * @param walkerName - Walker name to generate report for
+         * @returns Promise resolving to markdown formatted report string
+         *
+         * @example
+         * ```typescript
+         * const markdown = await Walker.getReport("BTCUSDT", "my-walker");
+         * console.log(markdown);
+         * ```
+         */
+        this.getReport = async (symbol, walkerName) => {
+            const instance = this._getInstance(symbol, walkerName);
+            return await instance.getReport(symbol, walkerName);
+        };
+        /**
+         * Saves walker report to disk.
+         *
+         * @param symbol - Trading symbol
+         * @param walkerName - Walker name to save report for
+         * @param path - Optional directory path to save report (default: "./dump/walker")
+         *
+         * @example
+         * ```typescript
+         * // Save to default path: ./dump/walker/my-walker.md
+         * await Walker.dump("BTCUSDT", "my-walker");
+         *
+         * // Save to custom path: ./custom/path/my-walker.md
+         * await Walker.dump("BTCUSDT", "my-walker", "./custom/path");
+         * ```
+         */
+        this.dump = async (symbol, walkerName, path) => {
+            const instance = this._getInstance(symbol, walkerName);
+            return await instance.dump(symbol, walkerName, path);
+        };
+        /**
+         * Lists all active walker instances with their current status.
+         *
+         * @returns Promise resolving to array of status objects for all instances
+         *
+         * @example
+         * ```typescript
+         * const statusList = await Walker.list();
+         * statusList.forEach(status => {
+         *   console.log(`${status.symbol} - ${status.walkerName}: ${status.status}`);
+         * });
+         * ```
+         */
+        this.list = async () => {
+            const instanceList = this._getInstance.values();
+            return await Promise.all(instanceList.map((instance) => instance.getStatus()));
+        };
+    }
+}
 /**
  * Singleton instance of WalkerUtils for convenient walker operations.
  *