@backtest-kit/cli 3.8.0 → 4.0.1

package/README.md

@@ -22,7 +22,8 @@ Point the CLI at your strategy file, choose a mode, and it handles exchange conn
 - 🌐 **Web Dashboard**: Launch `@backtest-kit/ui` with a single `--ui` flag
 - 📬 **Telegram Alerts**: Send formatted trade notifications with charts via `--telegram`
 - 🔌 **Default Binance**: CCXT Binance exchange schema registered automatically when none is provided
-- 🧩 **Module Hooks**: Drop a `modules/live.module.mjs` file to handle every position lifecycle event
+- 🧩 **Module Hooks**: Drop a `live.module.mjs`, `paper.module.mjs`, or `backtest.module.mjs` to register a `Broker` adapter. No manual wiring needed.
+- 🗃️ **Transactional Live Orders**: Broker adapter intercepts every trade mutation before internal state changes — exchange rejection rolls back the operation atomically.
 - 🔑 **Pluggable Logger**: Override the built-in logger with `setLogger()` from your strategy module
 - 🛑 **Graceful Shutdown**: SIGINT stops the active run and cleans up all subscriptions safely
 
@@ -230,11 +231,14 @@ monorepo/
 ├── .env                      # shared API keys (exchange, Telegram, etc.)
 └── strategies/
     ├── oct_2025/
-    │   ├── index.mjs         # entry point — registers exchange/frame/strategy schemas
-    │   ├── .env              # overrides root .env for this strategy (optional)
-    │   ├── modules/          # live.module.mjs specific to this strategy
-    │   ├── template/         # custom Mustache templates (optional)
-    │   └── dump/             # auto-created: candle cache + backtest reports
+    │   ├── index.mjs             # entry point — registers exchange/frame/strategy schemas
+    │   ├── .env                  # overrides root .env for this strategy 
+    │   ├── modules (optional)
+    │   |    ├── live.module.mjs       # broker adapter for --live mode (optional)
+    │   |    ├── paper.module.mjs      # broker adapter for --paper mode (optional)
+    │   |    ├── backtest.module.mjs   # broker adapter for --backtest mode (optional)
+    │   ├── template/             # custom Mustache templates (optional)
+    │   └── dump/                 # auto-created: candle cache + backtest reports
     └── dec_2025/
         ├── index.mjs
         ├── .env
@@ -264,13 +268,15 @@ npm run backtest:dec
 
 ### Isolated Resources Per Strategy
 
-| Resource            | Path (relative to strategy dir)   | Isolated         |
-|---------------------|-----------------------------------|------------------|
-| Candle cache        | `./dump/data/candle/`             | ✅ per-strategy  |
-| Backtest reports    | `./dump/`                         | ✅ per-strategy  |
-| Live module         | `./modules/live.module.mjs`       | ✅ per-strategy  |
-| Telegram templates  | `./template/*.mustache`           | ✅ per-strategy  |
-| Environment variables | `./.env` (overrides root)       | ✅ per-strategy  |
+| Resource                 | Path (relative to strategy dir)   | Isolated         |
+|--------------------------|-----------------------------------|------------------|
+| Candle cache             | `./dump/data/candle/`             | ✅ per-strategy  |
+| Backtest reports         | `./dump/`                         | ✅ per-strategy  |
+| Broker module (live)     | `./modules/live.module.mjs`       | ✅ per-strategy  |
+| Broker module (paper)    | `./modules/paper.module.mjs`      | ✅ per-strategy  |
+| Broker module (backtest) | `./modules/backtest.module.mjs`   | ✅ per-strategy  |
+| Telegram templates       | `./template/*.mustache`           | ✅ per-strategy  |
+| Environment variables    | `./.env` (overrides root)         | ✅ per-strategy  |
 
 Each strategy run produces its own `dump/` directory, making it straightforward to compare results across time periods — both by inspection and by pointing an AI agent at a specific strategy folder.
 
@@ -292,72 +298,91 @@ Sends formatted HTML messages with 1m / 15m / 1h price charts to your Telegram c
 
 Requires `CC_TELEGRAM_TOKEN` and `CC_TELEGRAM_CHANNEL` in your environment.
 
-## 🧩 Live Module Hooks
+## 🧩 Module Hooks (Broker Adapter)
 
-Create a `modules/live.module.mjs` file in your **project root** to receive lifecycle callbacks for every trading event:
+The CLI supports **mode-specific module files** that are loaded as side-effect imports before the strategy starts. Each file is expected to call `Broker.useBrokerAdapter()` from `backtest-kit` to register a broker adapter.
 
-```javascript
-// modules/live.module.mjs
+| Mode          | Module file                     | Loaded before               |
+|---------------|---------------------------------|-----------------------------|
+| `--live`      | `./modules/live.module.mjs`     | `Live.background()`         |
+| `--paper`     | `./modules/paper.module.mjs`    | `Live.background()` (paper) |
+| `--backtest`  | `./modules/backtest.module.mjs` | `Backtest.background()`     |
 
-export default class {
+> File is resolved relative to `cwd` (the strategy directory). All of `.mjs`, `.cjs`, `.ts` extensions are tried automatically. Missing module is a soft warning — not an error.
 
-  onOpened(event) {
-    console.log('Position opened', event.symbol, event.priceOpen);
-  }
+### How It Works
 
-  onClosed(event) {
-    console.log('Position closed', event.symbol, event.priceClosed);
-  }
+The module file is a side-effect import. When the CLI loads it, your code runs and registers the adapter. From that point on, `backtest-kit` intercepts every trade-mutating call through the adapter **before** updating internal state — if the adapter throws, the position state is never changed.
 
-  onScheduled(event) {
-    console.log('Signal scheduled', event.id);
-  }
+```javascript
+// live.module.mjs
+import { Broker } from 'backtest-kit';
+import { myExchange } from './exchange.mjs';
 
-  onCancelled(event) {
-    console.log('Signal cancelled', event.id);
+class MyBroker {
+  async onSignalOpenCommit({ symbol, priceOpen, direction }) {
+    await myExchange.openPosition(symbol, direction, priceOpen);
   }
 
-  onRisk(event) {
-    console.warn('Risk rejection', event.reason);
+  async onSignalCloseCommit({ symbol, priceClosed }) {
+    await myExchange.closePosition(symbol, priceClosed);
   }
 
-  onPartialProfit(event) {
-    console.log('Partial profit taken', event.symbol);
+  async onPartialProfitCommit({ symbol, cost, currentPrice }) {
+    await myExchange.createOrder({
+      symbol,
+      side: 'sell',
+      quantity: cost / currentPrice,
+    });
   }
 
-  onPartialLoss(event) {
-    console.log('Partial loss taken', event.symbol);
+  async onAverageBuyCommit({ symbol, cost, currentPrice }) {
+    await myExchange.createOrder({
+      symbol,
+      side: 'buy',
+      quantity: cost / currentPrice,
+    });
   }
+}
 
-  onTrailingTake(event) {
-    console.log('Trailing take adjusted', event.symbol);
-  }
+Broker.useBrokerAdapter(MyBroker);
 
-  onTrailingStop(event) {
-    console.log('Trailing stop adjusted', event.symbol);
-  }
+Broker.enable();
+```
 
-  onBreakeven(event) {
-    console.log('Breakeven triggered', event.symbol);
-  }
+### Available Broker Hooks
 
-  onAverageBuy(event) {
-    console.log('Cost averaging (DCA)', event.symbol);
-  }
-}
-```
+| Method                   | Payload type                 | Triggered on              |
+|--------------------------|------------------------------|---------------------------|
+| `onSignalOpenCommit`     | `BrokerSignalOpenPayload`    | Position activation       |
+| `onSignalCloseCommit`    | `BrokerSignalClosePayload`   | SL / TP / manual close    |
+| `onPartialProfitCommit`  | `BrokerPartialProfitPayload` | PP                        |
+| `onPartialLossCommit`    | `BrokerPartialLossPayload`   | PL                        |
+| `onTrailingStopCommit`   | `BrokerTrailingStopPayload`  | SL adjustment             |
+| `onTrailingTakeCommit`   | `BrokerTrailingTakePayload`  | TP adjustment             |
+| `onBreakevenCommit`      | `BrokerBreakevenPayload`     | SL moved to entry         |
+| `onAverageBuyCommit`     | `BrokerAverageBuyPayload`    | DCA entry                 |
 
-All methods are optional — implement only the events you care about. The module is loaded dynamically from `{cwd}/modules/live.module.mjs` (supports `.cjs` and `.mjs` extensions).
+All methods are optional. Unimplemented hooks are silently skipped. In backtest mode all broker calls are skipped automatically — no adapter code runs during backtests.
 
-### TypeScript Interface
+### TypeScript
 
 ```typescript
-import type { ILiveModule } from '@backtest-kit/cli';
+import { Broker, IBroker, BrokerSignalOpenPayload, BrokerSignalClosePayload } from 'backtest-kit';
 
-export default class MyModule implements ILiveModule {
-  onOpened(event) { /* ... */ }
-  onClosed(event) { /* ... */ }
+class MyBroker implements Partial<IBroker> {
+  async onSignalOpenCommit(payload: BrokerSignalOpenPayload) {
+    // place open order on exchange
+  }
+
+  async onSignalCloseCommit(payload: BrokerSignalClosePayload) {
+    // place close order on exchange
+  }
 }
+
+Broker.useBrokerAdapter(MyBroker);
+
+Broker.enable();
 ```
 
 ## 📦 Supported Entry Point Formats
@@ -576,7 +601,7 @@ npm run backtest
 - 📬 Telegram notifications with price charts — no chart code needed
 - 🛑 Graceful shutdown on SIGINT — no hanging processes
 - 🔌 Works with any `backtest-kit` strategy file as-is
-- 🧩 Module hooks for custom logic without touching the CLI internals
+- 🧩 Broker adapter hooks via side-effect module files — no CLI internals to touch
 
 ## 🤝 Contribute
 

package/build/index.cjs

@@ -226,7 +226,6 @@ const schemaServices$1 = {
 const providerServices$1 = {
     frontendProviderService: Symbol('frontendProviderService'),
     telegramProviderService: Symbol('telegramProviderService'),
-    liveProviderService: Symbol('liveProviderService'),
 };
 const webServices$1 = {
     telegramWebService: Symbol('telegramWebService'),
@@ -612,6 +611,7 @@ class BacktestMainService {
         this.cacheLogicService = inject(TYPES.cacheLogicService);
         this.frontendProviderService = inject(TYPES.frontendProviderService);
         this.telegramProviderService = inject(TYPES.telegramProviderService);
+        this.moduleConnectionService = inject(TYPES.moduleConnectionService);
         this.run = functoolsKit.singleshot(async (payload) => {
             this.loggerService.log("backtestMainService run", {
                 payload,
@@ -660,6 +660,7 @@ class BacktestMainService {
                 });
                 notifyVerbose();
             }
+            await this.moduleConnectionService.loadModule("./backtest.module");
             BacktestKit.Backtest.background(symbol, {
                 strategyName,
                 frameName,
@@ -703,7 +704,7 @@ class LiveMainService {
         this.symbolSchemaService = inject(TYPES.symbolSchemaService);
         this.frontendProviderService = inject(TYPES.frontendProviderService);
         this.telegramProviderService = inject(TYPES.telegramProviderService);
-        this.liveProviderService = inject(TYPES.liveProviderService);
+        this.moduleConnectionService = inject(TYPES.moduleConnectionService);
         this.run = functoolsKit.singleshot(async (payload) => {
             this.loggerService.log("liveMainService run", {
                 payload,
@@ -711,7 +712,6 @@ class LiveMainService {
             {
                 this.frontendProviderService.connect();
                 this.telegramProviderService.connect();
-                this.liveProviderService.connect();
             }
             await this.resolveService.attachEntryPoint(payload.entryPoint);
             {
@@ -740,6 +740,7 @@ class LiveMainService {
                 });
                 notifyVerbose();
             }
+            await this.moduleConnectionService.loadModule("./live.module");
             BacktestKit.Live.background(symbol, {
                 strategyName,
                 exchangeName,
@@ -778,6 +779,7 @@ class PaperMainService {
         this.symbolSchemaService = inject(TYPES.symbolSchemaService);
         this.frontendProviderService = inject(TYPES.frontendProviderService);
         this.telegramProviderService = inject(TYPES.telegramProviderService);
+        this.moduleConnectionService = inject(TYPES.moduleConnectionService);
         this.run = functoolsKit.singleshot(async (payload) => {
             this.loggerService.log("paperMainService init");
             {
@@ -811,6 +813,7 @@ class PaperMainService {
                 });
                 notifyVerbose();
             }
+            await this.moduleConnectionService.loadModule("./paper.module");
             BacktestKit.Live.background(symbol, {
                 strategyName,
                 exchangeName,
@@ -1513,6 +1516,26 @@ class TelegramLogicService {
                 markdown,
             });
         };
+        this.notifySignalOpen = functoolsKit.trycatch(async (event) => {
+            this.loggerService.log("telegramLogicService notifySignalOpen", {
+                event,
+            });
+            const markdown = await this.telegramTemplateService.getSignalOpenMarkdown(event);
+            await this.telegramWebService.publishNotify({
+                symbol: event.symbol,
+                markdown,
+            });
+        });
+        this.notifySignalClose = functoolsKit.trycatch(async (event) => {
+            this.loggerService.log("telegramLogicService notifySignalClose", {
+                event,
+            });
+            const markdown = await this.telegramTemplateService.getSignalCloseMarkdown(event);
+            await this.telegramWebService.publishNotify({
+                symbol: event.symbol,
+                markdown,
+            });
+        });
         this.connect = functoolsKit.singleshot(() => {
             this.loggerService.log("telegramLogicService connect");
             const unRisk = BacktestKit.listenRisk(async (event) => {
@@ -1562,8 +1585,18 @@ class TelegramLogicService {
                     return;
                 }
             });
+            const unSync = BacktestKit.listenSync(async (event) => {
+                if (event.action === "signal-open") {
+                    await this.notifySignalOpen(event);
+                    return;
+                }
+                if (event.action === "signal-close") {
+                    await this.notifySignalClose(event);
+                    return;
+                }
+            });
             const unConnect = () => this.connect.clear();
-            const unListen = functoolsKit.compose(() => unRisk(), () => unSignal(), () => unCommit(), () => unConnect());
+            const unListen = functoolsKit.compose(() => unRisk(), () => unSignal(), () => unCommit(), () => unSync(), () => unConnect());
             return () => {
                 STOP_BOT_FN();
                 unListen();
@@ -1658,6 +1691,18 @@ class TelegramTemplateService {
             });
             return await RENDER_TEMPLATE_FN("average-buy.mustache", event, this);
         };
+        this.getSignalOpenMarkdown = async (event) => {
+            this.loggerService.log("telegramTemplateService getSignalOpenMarkdown", {
+                event,
+            });
+            return await RENDER_TEMPLATE_FN("signal-open.mustache", event, this);
+        };
+        this.getSignalCloseMarkdown = async (event) => {
+            this.loggerService.log("telegramTemplateService getSignalCloseMarkdown", {
+                event,
+            });
+            return await RENDER_TEMPLATE_FN("signal-close.mustache", event, this);
+        };
     }
 }
 
@@ -1677,38 +1722,35 @@ const getExtVariants = (fileName) => {
 const REQUIRE_MODULE_FACTORY = (fileName) => {
     for (const variant of getExtVariants(fileName)) {
         try {
-            return require$2(variant);
+            require$2(variant);
+            return true;
         }
         catch {
             continue;
         }
     }
-    return null;
+    return false;
 };
 const IMPORT_MODULE_FACTORY = async (fileName) => {
     {
-        return null;
+        return false;
     }
 };
 const BABEL_MODULE_FACTORY = async (fileName, self) => {
     for (const variant of getExtVariants(fileName)) {
         try {
             const code = await fs$1.readFile(variant, "utf-8");
-            const { exports } = self.babelService.transpileAndRun(code);
-            if (exports.default) {
-                return exports.default;
-            }
-            return exports;
+            self.babelService.transpileAndRun(code);
+            return true;
         }
         catch (error) {
             console.log(functoolsKit.getErrorMessage(error));
             continue;
         }
     }
-    return null;
+    return false;
 };
 const LOAD_MODULE_MODULE_FN = async (fileName, self) => {
-    let Ctor = null;
     const overridePath = path.join(self.resolveService.OVERRIDE_MODULES_DIR, fileName);
     const targetPath = path.join(process.cwd(), "modules", fileName);
     const hasOverride = await fs$1
@@ -1716,212 +1758,29 @@ const LOAD_MODULE_MODULE_FN = async (fileName, self) => {
         .then(() => true)
         .catch(() => false);
     const resolvedFile = hasOverride ? overridePath : targetPath;
-    if ((Ctor = REQUIRE_MODULE_FACTORY(resolvedFile))) {
-        return typeof Ctor === "function" ? new Ctor() : Ctor;
+    if (REQUIRE_MODULE_FACTORY(resolvedFile)) {
+        return true;
     }
-    if ((Ctor = await IMPORT_MODULE_FACTORY())) {
-        return typeof Ctor === "function" ? new Ctor() : Ctor;
+    if (await IMPORT_MODULE_FACTORY()) {
+        return true;
     }
-    if ((Ctor = await BABEL_MODULE_FACTORY(resolvedFile, self))) {
-        return typeof Ctor === "function" ? new Ctor() : Ctor;
+    if (await BABEL_MODULE_FACTORY(resolvedFile, self)) {
+        return true;
     }
-    throw new Error(`Module module import failed for file: ${resolvedFile}`);
+    console.warn(`Module module import failed for file: ${resolvedFile}`);
+    return false;
 };
 class ModuleConnectionService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
         this.resolveService = inject(TYPES.resolveService);
         this.babelService = inject(TYPES.babelService);
-        this.getInstance = functoolsKit.memoize(([fileName]) => `${fileName}`, async (fileName) => {
+        this.loadModule = async (fileName) => {
             this.loggerService.log("moduleConnectionService getInstance", {
                 fileName,
             });
             return await LOAD_MODULE_MODULE_FN(fileName, this);
-        });
-    }
-}
-
-const LOAD_INSTANCE_FN = functoolsKit.singleshot(functoolsKit.trycatch(async (self) => {
-    const module = (await self.moduleConnectionService.getInstance("./live.module"));
-    return module;
-}, { defaultValue: null }));
-class LiveProviderService {
-    constructor() {
-        this.loggerService = inject(TYPES.loggerService);
-        this.moduleConnectionService = inject(TYPES.moduleConnectionService);
-        this.handleTrailingTake = async (event) => {
-            this.loggerService.log("liveProviderService handleTrailingTake", {
-                event,
-            });
-            const instance = await LOAD_INSTANCE_FN(this);
-            if (instance?.onTrailingTake) {
-                await instance.onTrailingTake(event);
-            }
-        };
-        this.handleTrailingStop = async (event) => {
-            this.loggerService.log("liveProviderService handleTrailingStop", {
-                event,
-            });
-            const instance = await LOAD_INSTANCE_FN(this);
-            if (instance?.onTrailingStop) {
-                await instance.onTrailingStop(event);
-            }
-        };
-        this.handleBreakeven = async (event) => {
-            this.loggerService.log("liveProviderService handleBreakeven", {
-                event,
-            });
-            const instance = await LOAD_INSTANCE_FN(this);
-            if (instance?.onBreakeven) {
-                await instance.onBreakeven(event);
-            }
         };
-        this.handlePartialProfit = async (event) => {
-            this.loggerService.log("liveProviderService handlePartialProfit", {
-                event,
-            });
-            const instance = await LOAD_INSTANCE_FN(this);
-            if (instance?.onPartialProfit) {
-                await instance.onPartialProfit(event);
-            }
-        };
-        this.handlePartialLoss = async (event) => {
-            this.loggerService.log("liveProviderService handlePartialLoss", {
-                event,
-            });
-            const instance = await LOAD_INSTANCE_FN(this);
-            if (instance?.onPartialLoss) {
-                await instance.onPartialLoss(event);
-            }
-        };
-        this.handleScheduled = async (event) => {
-            this.loggerService.log("liveProviderService handleScheduled", {
-                event,
-            });
-            const instance = await LOAD_INSTANCE_FN(this);
-            if (instance?.onScheduled) {
-                await instance.onScheduled(event);
-            }
-        };
-        this.handleCancelled = async (event) => {
-            this.loggerService.log("liveProviderService handleCancelled", {
-                event,
-            });
-            const instance = await LOAD_INSTANCE_FN(this);
-            if (instance?.onCancelled) {
-                await instance.onCancelled(event);
-            }
-        };
-        this.handleOpened = async (event) => {
-            this.loggerService.log("liveProviderService handleOpened", {
-                event,
-            });
-            const instance = await LOAD_INSTANCE_FN(this);
-            if (instance?.onOpened) {
-                await instance.onOpened(event);
-            }
-        };
-        this.handleClosed = async (event) => {
-            this.loggerService.log("liveProviderService handleClosed", {
-                event,
-            });
-            const instance = await LOAD_INSTANCE_FN(this);
-            if (instance?.onClosed) {
-                await instance.onClosed(event);
-            }
-        };
-        this.handleRisk = async (event) => {
-            this.loggerService.log("liveProviderService handleClosed", {
-                event,
-            });
-            const instance = await LOAD_INSTANCE_FN(this);
-            if (instance?.onRisk) {
-                await instance.onRisk(event);
-            }
-        };
-        this.handleAverageBuy = async (event) => {
-            this.loggerService.log("liveProviderService handleAverageBuy", {
-                event,
-            });
-            const instance = await LOAD_INSTANCE_FN(this);
-            if (instance?.onAverageBuy) {
-                await instance.onAverageBuy(event);
-            }
-        };
-        this.enable = functoolsKit.singleshot(() => {
-            this.loggerService.log("liveProviderService enable");
-            LOAD_INSTANCE_FN(this).then((module) => {
-                if (module) {
-                    this.loggerService.log("Live trading initialized successfully with ./modules/live.module.mjs");
-                    return;
-                }
-                console.log("No ./modules/live.module.mjs found, live trading failed to initialize");
-                process.exit(-1);
-            });
-            const unRisk = BacktestKit.listenRisk(async (event) => {
-                await this.handleRisk(event);
-            });
-            const unSignal = BacktestKit.listenSignal(async (event) => {
-                if (event.action === "scheduled") {
-                    await this.handleScheduled(event);
-                    return;
-                }
-                if (event.action === "cancelled") {
-                    await this.handleCancelled(event);
-                    return;
-                }
-                if (event.action === "opened") {
-                    await this.handleOpened(event);
-                    return;
-                }
-                if (event.action === "closed") {
-                    await this.handleClosed(event);
-                    return;
-                }
-            });
-            const unCommit = BacktestKit.listenStrategyCommit(async (event) => {
-                if (event.action === "trailing-take") {
-                    await this.handleTrailingTake(event);
-                    return;
-                }
-                if (event.action === "trailing-stop") {
-                    await this.handleTrailingStop(event);
-                    return;
-                }
-                if (event.action === "breakeven") {
-                    await this.handleBreakeven(event);
-                    return;
-                }
-                if (event.action === "partial-profit") {
-                    await this.handlePartialProfit(event);
-                    return;
-                }
-                if (event.action === "partial-loss") {
-                    await this.handlePartialLoss(event);
-                    return;
-                }
-                if (event.action === "average-buy") {
-                    await this.handleAverageBuy(event);
-                    return;
-                }
-            });
-            const unConnect = () => this.enable.clear();
-            return functoolsKit.compose(() => unRisk(), () => unSignal(), () => unCommit(), () => unConnect());
-        });
-        this.disable = () => {
-            this.loggerService.log("liveProviderService disable");
-            if (this.enable.hasValue()) {
-                const lastSubscription = this.enable();
-                lastSubscription();
-            }
-        };
-        this.connect = functoolsKit.singleshot(async () => {
-            this.loggerService.log("liveProviderService connect");
-            if (!getArgs().values.live) {
-                return;
-            }
-            return entrySubject.subscribe(this.enable);
-        });
     }
 }
 
@@ -2044,7 +1903,6 @@ globalThis.BacktestKitSignals = BacktestKitSignals__namespace;
 {
     provide(TYPES.telegramProviderService, () => new TelegramProviderService());
     provide(TYPES.frontendProviderService, () => new FrontendProviderService());
-    provide(TYPES.liveProviderService, () => new LiveProviderService());
 }
 {
     provide(TYPES.telegramWebService, () => new TelegramWebService());
@@ -2083,7 +1941,6 @@ const schemaServices = {
 const providerServices = {
     frontendProviderService: inject(TYPES.frontendProviderService),
     telegramProviderService: inject(TYPES.telegramProviderService),
-    liveProviderService: inject(TYPES.liveProviderService),
 };
 const webServices = {
     telegramWebService: inject(TYPES.telegramWebService),
@@ -2188,7 +2045,6 @@ const BEFORE_EXIT_FN$2 = functoolsKit.singleshot(async () => {
         exchangeName,
         strategyName,
     });
-    BacktestKit.listenDoneLive(cli.liveProviderService.disable);
 });
 const listenGracefulShutdown$2 = functoolsKit.singleshot(() => {
     process.on("SIGINT", BEFORE_EXIT_FN$2);