@backtest-kit/cli 16.4.0 → 16.6.0

package/build/index.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import * as BacktestKit from 'backtest-kit';
-import { setConfig, listenExit, emitters, Notification, Cron, Recent, Storage, Markdown, Report, Dump, State, Memory, MarkdownWriter, ReportWriter, PersistSignalAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistPartialAdapter, PersistBreakevenAdapter, PersistCandleAdapter, PersistStorageAdapter, PersistNotificationAdapter, PersistLogAdapter, PersistMeasureAdapter, PersistIntervalAdapter, PersistMemoryAdapter, PersistRecentAdapter, PersistStateAdapter, PersistSessionAdapter, PersistStrategyAdapter, Log, StorageLive, StorageBacktest, NotificationLive, NotificationBacktest, RecentLive, RecentBacktest, Broker, SessionLive, SessionBacktest, MemoryLive, MemoryBacktest, StateLive, StateBacktest, listExchangeSchema, addExchangeSchema, roundTicks, listFrameSchema, addFrameSchema, listenDoneLive, listenDoneBacktest, shutdown, listenSignal, listStrategySchema, overrideExchangeSchema, Backtest, System, Cache, Interval, alignToInterval, addWalkerSchema, overrideWalkerSchema, Walker, listenDoneWalker, Live, getCandles, checkCandles, warmCandles, listenRisk, listenStrategyCommit, listenSync, listenSignalNotify, Exchange, addSimulatorSchema, Simulator } from 'backtest-kit';
-import { singleshot, sleep, getErrorMessage, errorData, BehaviorSubject, Subject, str, compose, createAwaiter, execpool, queued, randomString, TIMEOUT_SYMBOL, typo, retry, trycatch, memoize, isObject } from 'functools-kit';
+import { setConfig, listenExit, emitters, Notification, Cron, Recent, Storage, Markdown, Report, Dump, State, Memory, MarkdownWriter, ReportWriter, PersistSignalAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistPartialAdapter, PersistBreakevenAdapter, PersistCandleAdapter, PersistStorageAdapter, PersistNotificationAdapter, PersistLogAdapter, PersistMeasureAdapter, PersistIntervalAdapter, PersistMemoryAdapter, PersistRecentAdapter, PersistStateAdapter, PersistSessionAdapter, PersistStrategyAdapter, Log, StorageLive, StorageBacktest, NotificationLive, NotificationBacktest, RecentLive, RecentBacktest, Broker, SessionLive, SessionBacktest, MemoryLive, MemoryBacktest, StateLive, StateBacktest, listExchangeSchema, addExchangeSchema, roundTicks, listFrameSchema, addFrameSchema, listenDoneLive, listenDoneBacktest, shutdown, listenSignal, listStrategySchema, overrideExchangeSchema, Backtest, System, Cache, Interval, alignToInterval, addWalkerSchema, overrideWalkerSchema, Walker, listenDoneWalker, Live, getCandles, checkCandles, warmCandles, listenRisk, listenStrategyCommit, listenOrderFill, listenOrderReject, listenOrderContinue, listenOrderStop, listenSignalNotify, Exchange, runInMockContext, addSimulatorSchema, Simulator } from 'backtest-kit';
+import { singleshot, sleep, getErrorMessage, errorData, BehaviorSubject, Subject, str, compose, createAwaiter, execpool, queued, randomString, TIMEOUT_SYMBOL, typo, retry, trycatch, ttl, Source, memoize, isObject } from 'functools-kit';
 import { exec, spawn } from 'child_process';
 import fs, { constants, realpathSync } from 'fs';
 import * as stackTrace from 'stack-trace';
@@ -28,7 +28,7 @@ import Module, { createRequire } from 'module';
 import * as BacktestKitGraph from '@backtest-kit/graph';
 import * as BacktestKitOllama from '@backtest-kit/ollama';
 import * as BacktestKitPinets from '@backtest-kit/pinets';
-import { run as run$1, Code, toMarkdown as toMarkdown$1 } from '@backtest-kit/pinets';
+import { run as run$1, Code, toMarkdown as toMarkdown$2 } from '@backtest-kit/pinets';
 import * as BacktestKitSignals from '@backtest-kit/signals';
 import open from 'open';
 
@@ -208,14 +208,14 @@ const getReadySubject = singleshot(() => {
     return new Subject();
 });
 
-const main$j = () => {
+const main$l = () => {
     const entrySubject = getEntrySubject();
     entrySubject.subscribe(async (path) => {
         console.log("Running", path);
         await getReadySubject().next();
     });
 };
-main$j();
+main$l();
 
 const ERROR_HANDLER_INSTALLED = Symbol.for("error-handler-installed");
 function dumpStackTrace(error) {
@@ -870,6 +870,14 @@ const getArgs = singleshot(() => {
                 type: "boolean",
                 default: false,
             },
+            tune: {
+                type: "boolean",
+                default: false,
+            },
+            split: {
+                type: "string",
+                default: "",
+            },
             commit: {
                 type: "string",
                 default: "",
@@ -2316,6 +2324,13 @@ const STOP_BOT_FN = singleshot(async () => {
     const { stopBot } = await getTelegram();
     stopBot();
 });
+/**
+ * Throttle window for the per-tick order_continue decision channel: at most one
+ * Telegram notification per signalId per 15 minutes via functools-kit ttl. The
+ * terminal order_stop is NOT throttled (fires once per signal) and clears the
+ * throttle slot for its signalId.
+ */
+const ORDER_CHECK_NOTIFY_TTL = 15 * 60 * 1000;
 class TelegramLogicService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
@@ -2464,11 +2479,68 @@ class TelegramLogicService {
                 markdown,
             });
         };
-        this.notifySignalOpen = trycatch(async (event) => {
-            this.loggerService.log("telegramLogicService notifySignalOpen", {
+        this.notifyOrderFillOpen = trycatch(async (event) => {
+            this.loggerService.log("telegramLogicService notifyOrderFillOpen", {
+                event,
+            });
+            const markdown = await this.telegramTemplateService.getOrderFillOpenMarkdown(event);
+            if (!markdown) {
+                return;
+            }
+            await this.telegramWebService.publishNotify({
+                symbol: event.symbol,
+                markdown,
+            });
+        });
+        this.notifyOrderFillClose = trycatch(async (event) => {
+            this.loggerService.log("telegramLogicService notifyOrderFillClose", {
+                event,
+            });
+            const markdown = await this.telegramTemplateService.getOrderFillCloseMarkdown(event);
+            if (!markdown) {
+                return;
+            }
+            await this.telegramWebService.publishNotify({
+                symbol: event.symbol,
+                markdown,
+            });
+        });
+        this.notifyOrderRejectOpen = trycatch(async (event) => {
+            this.loggerService.log("telegramLogicService notifyOrderRejectOpen", {
+                event,
+            });
+            const markdown = await this.telegramTemplateService.getOrderRejectOpenMarkdown(event);
+            if (!markdown) {
+                return;
+            }
+            await this.telegramWebService.publishNotify({
+                symbol: event.symbol,
+                markdown,
+            });
+        });
+        this.notifyOrderRejectClose = trycatch(async (event) => {
+            this.loggerService.log("telegramLogicService notifyOrderRejectClose", {
+                event,
+            });
+            const markdown = await this.telegramTemplateService.getOrderRejectCloseMarkdown(event);
+            if (!markdown) {
+                return;
+            }
+            await this.telegramWebService.publishNotify({
+                symbol: event.symbol,
+                markdown,
+            });
+        });
+        /**
+         * Post-verdict order-check CONTINUE (order_continue). Fires every live tick the
+         * order survives the check, so it is throttled via functools-kit ttl:
+         * one message per signalId per ORDER_CHECK_NOTIFY_TTL (15 minutes).
+         */
+        this.notifyOrderContinue = ttl(trycatch(async (event) => {
+            this.loggerService.log("telegramLogicService notifyOrderContinue", {
                 event,
             });
-            const markdown = await this.telegramTemplateService.getSignalOpenMarkdown(event);
+            const markdown = await this.telegramTemplateService.getOrderContinueMarkdown(event);
             if (!markdown) {
                 return;
             }
@@ -2476,12 +2548,21 @@ class TelegramLogicService {
                 symbol: event.symbol,
                 markdown,
             });
+        }), {
+            key: ([event]) => event.signalId,
+            timeout: ORDER_CHECK_NOTIFY_TTL,
         });
-        this.notifySignalClose = trycatch(async (event) => {
-            this.loggerService.log("telegramLogicService notifySignalClose", {
+        /**
+         * Post-verdict order-check STOP (order_stop). Terminal — fires once per signal,
+         * so no throttle; drops the continue throttle slot for this signalId
+         * (the signal leaves monitoring, the ttl entry would only leak otherwise).
+         */
+        this.notifyOrderStop = trycatch(async (event) => {
+            this.loggerService.log("telegramLogicService notifyOrderStop", {
                 event,
             });
-            const markdown = await this.telegramTemplateService.getSignalCloseMarkdown(event);
+            this.notifyOrderContinue.clear(event.signalId);
+            const markdown = await this.telegramTemplateService.getOrderStopMarkdown(event);
             if (!markdown) {
                 return;
             }
@@ -2586,26 +2667,54 @@ class TelegramLogicService {
                     return;
                 }
             });
-            const unSync = listenSync(async (event) => {
+            // Broker-CONFIRMED fills only (post-verdict orderFillSubject): a rejected or
+            // transient gate attempt never reaches this channel, so "Order Filled" is
+            // guaranteed truthful. The pre-verdict syncSubject is NOT consumed here.
+            const unOrderFill = listenOrderFill(async (event) => {
                 if (event.action === "signal-open") {
-                    // type "schedule" is a resting-order PLACEMENT, not a position open:
-                    // the user already got the "scheduled" notification from listenSignal
-                    if (event.type !== "active") {
-                        return;
-                    }
-                    await this.notifySignalOpen(event);
+                    // Both open outcomes notify: type "active" — the order opened at once
+                    // (immediate fill, no schedule phase), type "schedule" — the resting
+                    // order was placed on the exchange. Either way the broker confirmed a
+                    // real order; the template's Order field carries the type.
+                    await this.notifyOrderFillOpen(event);
+                    return;
+                }
+                if (event.action === "signal-close") {
+                    await this.notifyOrderFillClose(event);
+                    return;
+                }
+            });
+            // Terminal broker rejection (post-verdict orderRejectSubject): exactly one
+            // event per dropped order attempt — the engine consumes the rejected signal
+            // id, so this cannot repeat per-tick for the same signal. Dispatched by
+            // action to the dedicated open/close notifications (single responsibility).
+            const unOrderReject = listenOrderReject(async (event) => {
+                if (event.action === "signal-open") {
+                    await this.notifyOrderRejectOpen(event);
                     return;
                 }
                 if (event.action === "signal-close") {
-                    await this.notifySignalClose(event);
+                    await this.notifyOrderRejectClose(event);
                     return;
                 }
             });
+            // Post-verdict check decisions: CONTINUE fires every surviving tick and is
+            // throttled to one message per signalId per 15 minutes via ttl; terminal
+            // STOP fires once per signal, unthrottled.
+            const unOrderContinue = listenOrderContinue(async (event) => {
+                await this.notifyOrderContinue(event);
+            });
+            const unOrderStop = listenOrderStop(async (event) => {
+                await this.notifyOrderStop(event);
+            });
             const unSignalNotify = listenSignalNotify(async (event) => {
                 await this.notifySignalInfo(event);
             });
+            const unGc = Source.fromInterval(90000).connect(() => {
+                this.notifyOrderContinue.gc();
+            });
             const unConnect = () => this.connect.clear();
-            const unListen = compose(() => unRisk(), () => unSignal(), () => unCommit(), () => unSync(), () => unSignalNotify(), () => unConnect());
+            const unListen = compose(() => unRisk(), () => unSignal(), () => unCommit(), () => unOrderFill(), () => unOrderReject(), () => unOrderContinue(), () => unOrderStop(), () => this.notifyOrderContinue.clear(), () => unGc(), () => unSignalNotify(), () => unConnect());
             return () => {
                 STOP_BOT_FN();
                 unListen();
@@ -2758,25 +2867,65 @@ class TelegramTemplateService {
             }
             return await RENDER_TEMPLATE_FN("average-buy.mustache", event, this);
         };
-        this.getSignalOpenMarkdown = async (event) => {
-            this.loggerService.log("telegramTemplateService getSignalOpenMarkdown", {
+        this.getOrderFillOpenMarkdown = async (event) => {
+            this.loggerService.log("telegramTemplateService getOrderFillOpenMarkdown", {
+                event,
+            });
+            const adapter = await this.getTelegramAdapter();
+            if (adapter?.getOrderFillOpenMarkdown) {
+                return await adapter.getOrderFillOpenMarkdown(event);
+            }
+            return await RENDER_TEMPLATE_FN("order-fill-open.mustache", event, this);
+        };
+        this.getOrderFillCloseMarkdown = async (event) => {
+            this.loggerService.log("telegramTemplateService getOrderFillCloseMarkdown", {
+                event,
+            });
+            const adapter = await this.getTelegramAdapter();
+            if (adapter?.getOrderFillCloseMarkdown) {
+                return await adapter.getOrderFillCloseMarkdown(event);
+            }
+            return await RENDER_TEMPLATE_FN("order-fill-close.mustache", event, this);
+        };
+        this.getOrderRejectOpenMarkdown = async (event) => {
+            this.loggerService.log("telegramTemplateService getOrderRejectOpenMarkdown", {
+                event,
+            });
+            const adapter = await this.getTelegramAdapter();
+            if (adapter?.getOrderRejectOpenMarkdown) {
+                return await adapter.getOrderRejectOpenMarkdown(event);
+            }
+            return await RENDER_TEMPLATE_FN("order-reject-open.mustache", event, this);
+        };
+        this.getOrderRejectCloseMarkdown = async (event) => {
+            this.loggerService.log("telegramTemplateService getOrderRejectCloseMarkdown", {
+                event,
+            });
+            const adapter = await this.getTelegramAdapter();
+            if (adapter?.getOrderRejectCloseMarkdown) {
+                return await adapter.getOrderRejectCloseMarkdown(event);
+            }
+            return await RENDER_TEMPLATE_FN("order-reject-close.mustache", event, this);
+        };
+        this.getOrderContinueMarkdown = async (event) => {
+            this.loggerService.log("telegramTemplateService getOrderContinueMarkdown", {
                 event,
             });
             const adapter = await this.getTelegramAdapter();
-            if (adapter?.getSignalOpenMarkdown) {
-                return await adapter.getSignalOpenMarkdown(event);
+            if (adapter?.getOrderContinueMarkdown) {
+                return await adapter.getOrderContinueMarkdown(event);
             }
-            return await RENDER_TEMPLATE_FN("signal-open.mustache", event, this);
+            return await RENDER_TEMPLATE_FN("order-continue.mustache", event, this);
         };
-        this.getSignalCloseMarkdown = async (event) => {
-            this.loggerService.log("telegramTemplateService getSignalCloseMarkdown", {
+        this.getOrderStopMarkdown = async (event) => {
+            this.loggerService.log("telegramTemplateService getOrderStopMarkdown", {
                 event,
             });
             const adapter = await this.getTelegramAdapter();
-            if (adapter?.getSignalCloseMarkdown) {
-                return await adapter.getSignalCloseMarkdown(event);
+            if (adapter?.getOrderStopMarkdown) {
+                return await adapter.getOrderStopMarkdown(event);
             }
-            return await RENDER_TEMPLATE_FN("signal-close.mustache", event, this);
+            return await RENDER_TEMPLATE_FN("order-stop.mustache", event, this);
         };
         this.getCancelScheduledMarkdown = async (event) => {
             this.loggerService.log("telegramTemplateService getCancelScheduledMarkdown", {
@@ -3506,14 +3655,14 @@ const cli = {
 };
 init();
 
-const MODES = ["backtest", "walker", "paper", "live", "main", "pine", "editor", "dump", "pnldebug", "brokerdebug", "simulator", "flush", "init", "docker", "help", "version"];
+const MODES = ["backtest", "walker", "paper", "live", "main", "pine", "editor", "dump", "pnldebug", "brokerdebug", "simulator", "tune", "flush", "init", "docker", "help", "version"];
 const ENTRY_PATH$1 = "./node_modules/@backtest-kit/cli/build/index.mjs";
 const HELP_TEXT$1 = `
 Example:
 
   node ${ENTRY_PATH$1} --help
 `.trimStart();
-const main$i = async () => {
+const main$k = async () => {
     if (!getEntry(import.meta.url)) {
         return;
     }
@@ -3521,14 +3670,14 @@ const main$i = async () => {
     if (MODES.some((mode) => values[mode])) {
         return;
     }
-    process.stdout.write(`@backtest-kit/cli ${"16.4.0"}\n`);
+    process.stdout.write(`@backtest-kit/cli ${"16.6.0"}\n`);
     process.stdout.write("\n");
     process.stdout.write(`Run with --help to see available commands.\n`);
     process.stdout.write("\n");
     process.stdout.write(HELP_TEXT$1);
     process.exit(0);
 };
-main$i();
+main$k();
 
 const notifyShutdown = singleshot(async () => {
     console.log("Graceful shutdown initiated.");
@@ -3544,7 +3693,7 @@ const flush = async (entryPoint) => {
         console.log(`Removed: ${target}`);
     }
 };
-const main$h = async () => {
+const main$j = async () => {
     if (!getEntry(import.meta.url)) {
         return;
     }
@@ -3561,7 +3710,7 @@ const main$h = async () => {
     }
     process.exit(0);
 };
-main$h();
+main$j();
 
 const BEFORE_EXIT_FN$6 = singleshot(async () => {
     process.off("SIGINT", BEFORE_EXIT_FN$6);
@@ -3584,7 +3733,7 @@ const BEFORE_EXIT_FN$6 = singleshot(async () => {
 const listenGracefulShutdown$6 = singleshot(() => {
     process.on("SIGINT", BEFORE_EXIT_FN$6);
 });
-const main$g = async () => {
+const main$i = async () => {
     if (!getEntry(import.meta.url)) {
         return;
     }
@@ -3602,7 +3751,7 @@ const main$g = async () => {
     await cli.backtestMainService.connect();
     listenGracefulShutdown$6();
 };
-main$g();
+main$i();
 
 const BEFORE_EXIT_FN$5 = singleshot(async () => {
     process.off("SIGINT", BEFORE_EXIT_FN$5);
@@ -3621,7 +3770,7 @@ const BEFORE_EXIT_FN$5 = singleshot(async () => {
 const listenGracefulShutdown$5 = singleshot(() => {
     process.on("SIGINT", BEFORE_EXIT_FN$5);
 });
-const main$f = async () => {
+const main$h = async () => {
     if (!getEntry(import.meta.url)) {
         return;
     }
@@ -3640,7 +3789,7 @@ const main$f = async () => {
     listenGracefulShutdown$5();
     await cli.walkerMainService.connect();
 };
-main$f();
+main$h();
 
 const BEFORE_EXIT_FN$4 = singleshot(async () => {
     process.off("SIGINT", BEFORE_EXIT_FN$4);
@@ -3662,7 +3811,7 @@ const BEFORE_EXIT_FN$4 = singleshot(async () => {
 const listenGracefulShutdown$4 = singleshot(() => {
     process.on("SIGINT", BEFORE_EXIT_FN$4);
 });
-const main$e = async () => {
+const main$g = async () => {
     if (!getEntry(import.meta.url)) {
         return;
     }
@@ -3676,7 +3825,7 @@ const main$e = async () => {
     await cli.paperMainService.connect();
     listenGracefulShutdown$4();
 };
-main$e();
+main$g();
 
 const BEFORE_EXIT_FN$3 = singleshot(async () => {
     process.off("SIGINT", BEFORE_EXIT_FN$3);
@@ -3698,7 +3847,7 @@ const BEFORE_EXIT_FN$3 = singleshot(async () => {
 const listenGracefulShutdown$3 = singleshot(() => {
     process.on("SIGINT", BEFORE_EXIT_FN$3);
 });
-const main$d = async () => {
+const main$f = async () => {
     if (!getEntry(import.meta.url)) {
         return;
     }
@@ -3712,7 +3861,7 @@ const main$d = async () => {
     await cli.liveMainService.connect();
     listenGracefulShutdown$3();
 };
-main$d();
+main$f();
 
 const stopBacktestList$1 = async () => {
     for (const item of await Backtest.list()) {
@@ -3776,7 +3925,7 @@ const BEFORE_EXIT_FN$2 = singleshot(async () => {
 const listenGracefulShutdown$2 = singleshot(() => {
     process.on("SIGINT", BEFORE_EXIT_FN$2);
 });
-const main$c = async () => {
+const main$e = async () => {
     if (!getEntry(import.meta.url)) {
         return;
     }
@@ -3832,7 +3981,7 @@ const main$c = async () => {
     listenGracefulShutdown$2();
     await cli.resolveService.attachEntry(path.resolve(cwd, entryPoint));
 };
-main$c();
+main$e();
 
 const MODE_MODULE = {
     backtest: "backtest.module",
@@ -3935,7 +4084,7 @@ const createGracefulShutdown = (mode) => {
         process.on("SIGINT", handler);
     });
 };
-const main$b = async () => {
+const main$d = async () => {
     if (!getEntry(import.meta.url)) {
         return;
     }
@@ -4011,7 +4160,7 @@ const main$b = async () => {
     }
     await getEntrySubject().next(absolutePath);
 };
-main$b();
+main$d();
 
 const BEFORE_EXIT_FN$1 = singleshot(async () => {
     process.off("SIGINT", BEFORE_EXIT_FN$1);
@@ -4022,7 +4171,7 @@ const BEFORE_EXIT_FN$1 = singleshot(async () => {
 const listenGracefulShutdown$1 = singleshot(() => {
     process.on("SIGINT", BEFORE_EXIT_FN$1);
 });
-const main$a = async () => {
+const main$c = async () => {
     if (!getEntry(import.meta.url)) {
         return;
     }
@@ -4032,7 +4181,7 @@ const main$a = async () => {
     }
     listenGracefulShutdown$1();
 };
-main$a();
+main$c();
 
 const BEFORE_EXIT_FN = singleshot(async () => {
     process.off("SIGINT", BEFORE_EXIT_FN);
@@ -4043,7 +4192,7 @@ const BEFORE_EXIT_FN = singleshot(async () => {
 const listenGracefulShutdown = singleshot(() => {
     process.on("SIGINT", BEFORE_EXIT_FN);
 });
-const main$9 = async () => {
+const main$b = async () => {
     if (!getEntry(import.meta.url)) {
         return;
     }
@@ -4053,7 +4202,7 @@ const main$9 = async () => {
     }
     listenGracefulShutdown();
 };
-main$9();
+main$b();
 
 const EXTRACT_ROWS_FN = (plots, schema) => {
     const keys = Object.keys(schema);
@@ -4075,7 +4224,7 @@ const EXTRACT_ROWS_FN = (plots, schema) => {
     }
     return rows;
 };
-const main$8 = async () => {
+const main$a = async () => {
     if (!getEntry(import.meta.url)) {
         return;
     }
@@ -4167,17 +4316,17 @@ const main$8 = async () => {
     if (values.markdown) {
         const filePath = resolve(dumpDir, `${dumpName}.md`);
         await mkdir(dumpDir, { recursive: true });
-        await writeFile(filePath, await toMarkdown$1(signalId, plots, signalSchema), "utf-8");
+        await writeFile(filePath, await toMarkdown$2(signalId, plots, signalSchema), "utf-8");
         console.log(`Saved: ${filePath}`);
         process.exit(0);
         return;
     }
-    console.log(await toMarkdown$1(signalId, plots, signalSchema));
+    console.log(await toMarkdown$2(signalId, plots, signalSchema));
     process.exit(0);
 };
-main$8();
+main$a();
 
-const main$7 = async () => {
+const main$9 = async () => {
     if (!getEntry(import.meta.url)) {
         return;
     }
@@ -4240,9 +4389,9 @@ const main$7 = async () => {
     };
     process.on("SIGINT", beforeExit);
 };
-main$7();
+main$9();
 
-const main$6 = async () => {
+const main$8 = async () => {
     if (!getEntry(import.meta.url)) {
         return;
     }
@@ -4323,9 +4472,9 @@ const main$6 = async () => {
     console.log(JSON.stringify(candles, null, 2));
     process.exit(0);
 };
-main$6();
+main$8();
 
-const main$5 = async () => {
+const main$7 = async () => {
     if (!getEntry(import.meta.url)) {
         return;
     }
@@ -4439,11 +4588,314 @@ const main$5 = async () => {
     }
     process.exit(0);
 };
-main$5();
+main$7();
 
-const SIMULATOR_NAME = "cli_simulator";
-const IDEA_DIRECTIONS = ["LONG", "SHORT", "NEUTRAL"];
-const validateIdea = (idea, line) => {
+const getBroker = singleshot(() => {
+    // Reaches into BrokerAdapter internals on purpose: the public commit*
+    // methods skip when payload.backtest=true and require enable(), while
+    // brokerdebug must fire exactly one commit at the raw adapter proxy.
+    const broker = Broker["getInstance"]();
+    if (!broker) {
+        throw new Error("Broker instance is not initialized.");
+    }
+    return broker;
+});
+/** Called when a new signal is opened (position entry confirmed). */
+const commitOrderOpen = trycatch(async (payload) => {
+    const broker = getBroker();
+    return await broker.onOrderOpenCommit(payload);
+}, {
+    fallback: (error) => {
+        console.log(error);
+        process.exit(-1);
+    },
+});
+/** Called when a new signal is closed (take-profit, stop-loss, or manual close). */
+const commitOrderClose = trycatch(async (payload) => {
+    const broker = getBroker();
+    return await broker.onOrderCloseCommit(payload);
+}, {
+    fallback: (error) => {
+        console.log(error);
+        process.exit(-1);
+    },
+});
+/** Called when a partial profit close is committed. */
+const commitPartialProfit = trycatch(async (payload) => {
+    const broker = getBroker();
+    return await broker.onPartialProfitCommit(payload);
+}, {
+    fallback: (error) => {
+        console.log(error);
+        process.exit(-1);
+    },
+});
+/** Called when a partial loss close is committed. */
+const commitPartialLoss = trycatch(async (payload) => {
+    const broker = getBroker();
+    return await broker.onPartialLossCommit(payload);
+}, {
+    fallback: (error) => {
+        console.log(error);
+        process.exit(-1);
+    },
+});
+/** Called when a trailing stop update is committed. */
+const commitTrailingStop = trycatch(async (payload) => {
+    const broker = getBroker();
+    return await broker.onTrailingStopCommit(payload);
+}, {
+    fallback: (error) => {
+        console.log(error);
+        process.exit(-1);
+    },
+});
+/** Called when a trailing take-profit update is committed. */
+const commitTrailingTake = trycatch(async (payload) => {
+    const broker = getBroker();
+    return await broker.onTrailingTakeCommit(payload);
+}, {
+    fallback: (error) => {
+        console.log(error);
+        process.exit(-1);
+    },
+});
+/** Called when a breakeven stop is committed (stop loss moved to entry price). */
+const commitBreakeven = trycatch(async (payload) => {
+    const broker = getBroker();
+    return await broker.onBreakevenCommit(payload);
+}, {
+    fallback: (error) => {
+        console.log(error);
+        process.exit(-1);
+    },
+});
+/** Called when a DCA (average-buy) entry is committed. */
+const commitAverageBuy = trycatch(async (payload) => {
+    const broker = getBroker();
+    return await broker.onAverageBuyCommit(payload);
+}, {
+    fallback: (error) => {
+        console.log(error);
+        process.exit(-1);
+    },
+});
+const COMMITS = [
+    "signal-open",
+    "signal-close",
+    "partial-profit",
+    "partial-loss",
+    "average-buy",
+    "trailing-stop",
+    "trailing-take",
+    "breakeven",
+];
+const ZERO_PNL = {
+    pnlPercentage: 0,
+    priceOpen: 0,
+    priceClose: 0,
+    pnlCost: 0,
+    pnlEntries: 0,
+};
+const main$6 = async () => {
+    if (!getEntry(import.meta.url)) {
+        return;
+    }
+    const { values } = getArgs();
+    if (!values.brokerdebug) {
+        return;
+    }
+    {
+        const cwd = process.cwd();
+        dotenv.config({ path: path.join(cwd, '.env'), override: true, quiet: true });
+    }
+    await cli.configConnectionService.loadConfig("setup.config");
+    {
+        const loader = await cli.configConnectionService.loadConfig("loader.config");
+        try {
+            if (typeof loader === "function") {
+                await loader();
+            }
+            if (typeof loader?.loader === "function") {
+                await loader.loader();
+            }
+        }
+        catch (error) {
+            console.error("Module loader failed", error);
+            process.exit(-1);
+        }
+    }
+    await cli.moduleConnectionService.loadModule("brokerdebug.module");
+    const [defaultExchangeName = null] = await listExchangeSchema();
+    const exchangeName = values.exchange || defaultExchangeName?.exchangeName;
+    const symbol = values.symbol || "BTCUSDT";
+    const commit = values.commit || "signal-open";
+    if (!COMMITS.includes(commit)) {
+        console.error(`Unknown --commit value: ${commit}`);
+        console.error(`Available: ${COMMITS.join(", ")}`);
+        process.exit(1);
+    }
+    const candles = await Exchange.getCandles(symbol, "1m", 5, { exchangeName });
+    const lastCandle = candles[candles.length - 1];
+    const currentPrice = lastCandle.close;
+    const priceTakeProfit = currentPrice * 1.02;
+    const priceStopLoss = currentPrice * 0.98;
+    const context = {
+        strategyName: "broker-test",
+        exchangeName: exchangeName,
+    };
+    const signalId = `broker-debug-${Date.now()}`;
+    const when = alignToInterval(new Date(), "1m");
+    {
+        console.log(`symbol=${symbol} price=${currentPrice} commit=${commit}`);
+        console.time(commit);
+    }
+    const run = async () => {
+        if (commit === "signal-open") {
+            await commitOrderOpen({
+                type: "active",
+                symbol,
+                signalId,
+                cost: 100,
+                position: "long",
+                priceOpen: currentPrice,
+                priceTakeProfit,
+                priceStopLoss,
+                pnl: ZERO_PNL,
+                peakProfit: ZERO_PNL,
+                maxDrawdown: ZERO_PNL,
+                attempt: 0,
+                context,
+                when,
+                backtest: true,
+            });
+        }
+        if (commit === "signal-close") {
+            await commitOrderClose({
+                symbol,
+                signalId,
+                cost: 100,
+                position: "long",
+                currentPrice,
+                priceOpen: currentPrice,
+                priceTakeProfit,
+                priceStopLoss,
+                totalEntries: 1,
+                totalPartials: 0,
+                attempt: 0,
+                pnl: ZERO_PNL,
+                peakProfit: ZERO_PNL,
+                maxDrawdown: ZERO_PNL,
+                context,
+                when,
+                backtest: true,
+            });
+        }
+        if (commit === "partial-profit") {
+            await commitPartialProfit({
+                symbol,
+                signalId,
+                percentToClose: 50,
+                cost: 50,
+                currentPrice,
+                position: "long",
+                priceTakeProfit,
+                priceStopLoss,
+                context,
+                when,
+                backtest: true,
+            });
+        }
+        if (commit === "partial-loss") {
+            await commitPartialLoss({
+                symbol,
+                signalId,
+                percentToClose: 50,
+                cost: 50,
+                currentPrice,
+                position: "long",
+                priceTakeProfit,
+                priceStopLoss,
+                context,
+                when,
+                backtest: true,
+            });
+        }
+        if (commit === "average-buy") {
+            await commitAverageBuy({
+                symbol,
+                signalId,
+                currentPrice,
+                cost: 100,
+                position: "long",
+                priceTakeProfit,
+                priceStopLoss,
+                context,
+                when,
+                backtest: true,
+            });
+        }
+        if (commit === "trailing-stop") {
+            await commitTrailingStop({
+                symbol,
+                signalId,
+                percentShift: -50,
+                currentPrice,
+                newStopLossPrice: priceStopLoss + (currentPrice - priceStopLoss) * 0.5,
+                takeProfitPrice: priceTakeProfit,
+                position: "long",
+                context,
+                when,
+                backtest: true,
+            });
+        }
+        if (commit === "trailing-take") {
+            await commitTrailingTake({
+                symbol,
+                signalId,
+                percentShift: 50,
+                currentPrice,
+                newTakeProfitPrice: priceTakeProfit + (priceTakeProfit - currentPrice) * 0.5,
+                takeProfitPrice: priceTakeProfit,
+                position: "long",
+                context,
+                when,
+                backtest: true,
+            });
+        }
+        if (commit === "breakeven") {
+            await commitBreakeven({
+                symbol,
+                signalId,
+                currentPrice,
+                newStopLossPrice: currentPrice,
+                newTakeProfitPrice: priceTakeProfit,
+                position: "long",
+                context,
+                when,
+                backtest: true,
+            });
+        }
+    };
+    await runInMockContext(run, {
+        when,
+        strategyName: context.strategyName,
+        exchangeName: context.exchangeName,
+        frameName: "",
+        symbol,
+        backtest: true,
+    });
+    {
+        console.log(`${commit} OK`);
+        console.timeEnd(commit);
+    }
+    process.exit(0);
+};
+main$6();
+
+const SIMULATOR_NAME$1 = "cli_simulator";
+const IDEA_DIRECTIONS$1 = ["LONG", "SHORT", "NEUTRAL"];
+const validateIdea$1 = (idea, line) => {
     if (typeof idea !== "object" || idea === null) {
         return `line ${line}: not an object`;
     }
@@ -4456,15 +4908,16 @@ const validateIdea = (idea, line) => {
     if (typeof idea.symbol !== "string" || !idea.symbol) {
         return `line ${line}: "symbol" must be a non-empty string`;
     }
-    if (!IDEA_DIRECTIONS.includes(idea.direction)) {
-        return `line ${line}: "direction" must be one of ${IDEA_DIRECTIONS.join("|")}, got ${JSON.stringify(idea.direction)}`;
+    if (!IDEA_DIRECTIONS$1.includes(idea.direction)) {
+        return `line ${line}: "direction" must be one of ${IDEA_DIRECTIONS$1.join("|")}, got ${JSON.stringify(idea.direction)}`;
     }
     if (typeof idea.author !== "string" || !idea.author) {
         return `line ${line}: "author" must be a non-empty string`;
     }
     return null;
 };
-const toMarkdown = (result) => {
+const toMarkdown$1 = (result) => {
+    const profitable = result.reports.filter(({ totalPnlPercent }) => totalPnlPercent > 0).length;
     const lines = [];
     lines.push(`# Simulator Report — ${result.symbol}`);
     lines.push("");
@@ -4473,33 +4926,36 @@ const toMarkdown = (result) => {
     lines.push(`| Ideas (total / directional) | ${result.ideasTotal} / ${result.ideasDirectional} |`);
     lines.push(`| Profiles (truncated) | ${result.profileCount} (${result.truncatedCount}) |`);
     lines.push(`| Authors allowed / banned | ${result.allowedAuthors.length} / ${result.bannedAuthors.length} |`);
-    lines.push(`| Grid points | ${result.reports.length} |`);
+    lines.push(`| Profitable corridor | ${profitable} / ${result.reports.length} grid points |`);
     lines.push(`| Hold minutes avg / p95 / p99 | ${result.avgHoldMinutes.toFixed(0)} / ${result.p95HoldMinutes} / ${result.p99HoldMinutes} |`);
     lines.push("");
     lines.push(`## Ranking winners`);
     lines.push("");
-    lines.push(`| Criterion | Stop% | Trailing% | Hold | Aligned | Track | HitRate | Trades | PNL% | WinRate | Sharpe | Sortino |`);
-    lines.push(`| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |`);
+    lines.push(`| Criterion | Stop% | Hold | Track | HitRate | Trades | PNL% | WinRate | Sharpe | Sortino |`);
+    lines.push(`| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |`);
     for (const best of result.best) {
         if (!best.report) {
-            lines.push(`| ${best.criterion} | — | — | — | — | — | — | — | — | — | — | — |`);
+            lines.push(`| ${best.criterion} | — | — | — | — | — | — | — | — | — |`);
             continue;
         }
         const { point } = best.report;
-        lines.push(`| ${best.criterion} | ${point.hardStopPercent} | ${point.trailingTakePercent} | ${point.holdMinutes / 60}h | ${point.minIdeasAligned} | ${point.minAuthorTrack} | ${point.minAuthorHitRate} | ` +
+        lines.push(`| ${best.criterion} | ${point.hardStopPercent} | ${point.holdMinutes / 60}h | ${point.minAuthorTrack} | ${point.minAuthorHitRate} | ` +
             `${best.report.trades} | ${best.report.totalPnlPercent.toFixed(2)}% | ${(best.report.winRate * 100).toFixed(0)}% | ${best.report.sharpe.toFixed(2)} | ${best.report.sortino.toFixed(2)} |`);
     }
     lines.push("");
-    lines.push(`## Allowed authors (production whitelist)`);
+    lines.push(`## Allowed authors (whitelist of the sharpe winner rule)`);
     lines.push("");
     lines.push(`| Author | Ideas | Hits | HitRate |`);
     lines.push(`| --- | --- | --- | --- |`);
-    for (const stat of result.authorStats.filter(({ banned }) => !banned)) {
+    // артефакт авторов живёт по-победительно в best[] — ран-левел
+    // authorStats в ISimulatorResult больше нет
+    const sharpeBest = result.best.find(({ criterion }) => criterion === "sharpe");
+    for (const stat of (sharpeBest?.authorStats ?? []).filter(({ banned }) => !banned)) {
         lines.push(`| ${stat.author} | ${stat.ideas} | ${stat.hits} | ${(stat.hitRate * 100).toFixed(0)}% |`);
     }
     return lines.join("\n");
 };
-const main$4 = async () => {
+const main$5 = async () => {
     if (!getEntry(import.meta.url)) {
         return;
     }
@@ -4536,7 +4992,7 @@ const main$4 = async () => {
                 console.error(`Error: invalid JSON in ideas file, line ${i + 1}`);
                 process.exit(1);
             }
-            const problem = validateIdea(idea, i + 1);
+            const problem = validateIdea$1(idea, i + 1);
             if (problem) {
                 console.error(`Error: ideas file does not match the idea structure — ${problem}`);
                 console.error(`Expected shape: { "id": number, "ts": number, "symbol": string, "direction": "LONG"|"SHORT"|"NEUTRAL", "author": string }`);
@@ -4572,11 +5028,48 @@ const main$4 = async () => {
     }
     const [defaultExchangeName = null] = await listExchangeSchema();
     const exchangeName = values.exchange || defaultExchangeName?.exchangeName;
+    if (values.verbose) {
+        overrideExchangeSchema({
+            exchangeName,
+            callbacks: {
+                onCandleData(symbol, interval, since) {
+                    console.log(`Received candle data for symbol: ${symbol}, interval: ${interval}, since: ${since.toUTCString()}`);
+                },
+            },
+        });
+    }
     const symbol = values.symbol || "BTCUSDT";
+    // Проба осуществимости, НЕ поиск заработка (подбор параметров — у
+    // --tune): собирающая прибыль механика выключена, остаётся вопрос
+    // "есть ли прибыльный коридор" по стопу x холду x правилу бана —
+    // 48 точек, быстрый вердикт
     addSimulatorSchema({
-        simulatorName: SIMULATOR_NAME,
+        simulatorName: SIMULATOR_NAME$1,
         exchangeName,
+        gridAxes: {
+            // грубая шкала катастрофы: коридор должен быть широким, не точкой
+            hardStopPercent: [2, 3, 5, 7],
+            // инертен: проба не собирает прибыль, выход — по времени или стопу
+            trailingTakePercent: [100],
+            holdMinutes: [24 * 60, 2 * 24 * 60, 3 * 24 * 60],
+            // одного проверенного автора достаточно — консенсус не перебираем
+            minIdeasAligned: [1],
+            // правило бана — единственная перебираемая "умность" пробы
+            minAuthorTrack: [3, 5],
+            minAuthorHitRate: [0.5, 0.6],
+            minAuthorWilson: [0],
+            minWeightAligned: [0],
+            profitLockPercent: [0],
+            authorMetric: ["close"],
+            banCriteria: ["sharpe", "pnl"],
+        },
+        reportOrder: "sharpe",
         callbacks: {
+            onProgress: (symbol, stage, processed, total) => {
+                if (values.verbose) {
+                    console.log("onProgress", { symbol, stage, processed, total });
+                }
+            },
             onIdeas: (symbol, ideasTotal, ideasDirectional) => {
                 if (values.verbose) {
                     console.log("onIdeas", { symbol, ideasTotal, ideasDirectional });
@@ -4632,7 +5125,7 @@ const main$4 = async () => {
     });
     const result = await Simulator.run({
         symbol,
-        simulatorName: SIMULATOR_NAME,
+        simulatorName: SIMULATOR_NAME$1,
         ideas,
     });
     const dumpName = values.output || `simulator_${symbol}_${Date.now()}`;
@@ -4647,11 +5140,299 @@ const main$4 = async () => {
     if (values.markdown) {
         const filePath = resolve(dumpDir, `${dumpName}.md`);
         await mkdir(dumpDir, { recursive: true });
-        await writeFile(filePath, toMarkdown(result), "utf-8");
+        await writeFile(filePath, toMarkdown$1(result), "utf-8");
         console.log(`Saved: ${filePath}`);
         process.exit(0);
     }
-    console.log(toMarkdown(result));
+    console.log(toMarkdown$1(result));
+    process.exit(0);
+};
+main$5();
+
+const SIMULATOR_NAME = "cli_tune";
+/** Доля времени фида, уходящая в обучение; хвост — один OOS-выстрел. */
+const DEFAULT_TRAIN_SPLIT = 0.7;
+const IDEA_DIRECTIONS = ["LONG", "SHORT", "NEUTRAL"];
+const validateIdea = (idea, line) => {
+    if (typeof idea !== "object" || idea === null) {
+        return `line ${line}: not an object`;
+    }
+    if (typeof idea.id !== "number") {
+        return `line ${line}: "id" must be a number, got ${typeof idea.id}`;
+    }
+    if (typeof idea.ts !== "number") {
+        return `line ${line}: "ts" must be a number (unix ms), got ${typeof idea.ts}`;
+    }
+    if (typeof idea.symbol !== "string" || !idea.symbol) {
+        return `line ${line}: "symbol" must be a non-empty string`;
+    }
+    if (!IDEA_DIRECTIONS.includes(idea.direction)) {
+        return `line ${line}: "direction" must be one of ${IDEA_DIRECTIONS.join("|")}, got ${JSON.stringify(idea.direction)}`;
+    }
+    if (typeof idea.author !== "string" || !idea.author) {
+        return `line ${line}: "author" must be a non-empty string`;
+    }
+    return null;
+};
+const pointLabel = (point) => `H=${point.hardStopPercent} TT=${point.trailingTakePercent} hold=${point.holdMinutes / 60}h N=${point.minIdeasAligned} ` +
+    `track=${point.minAuthorTrack} rate=${point.minAuthorHitRate} wilson=${point.minAuthorWilson} W=${point.minWeightAligned} ` +
+    `lock=${point.profitLockPercent} metric=${point.authorMetric}`;
+const fmtRatio = (value) => Number.isFinite(value) ? value.toFixed(2) : "inf";
+const toMarkdown = (train, test, trainSplit) => {
+    const lines = [];
+    lines.push(`# Tune Report — ${train.symbol}`);
+    lines.push("");
+    lines.push(`Walk-forward: train on the first ${Math.round(trainSplit * 100)}% of the feed time range, ONE out-of-sample shot of the frozen sharpe winner on the tail.`);
+    lines.push("");
+    lines.push(`## Train (${train.ideasDirectional} directional ideas, ${train.reports.length} grid points)`);
+    lines.push("");
+    lines.push(`| Criterion | Point | Trades | PNL% | WinRate | DD% | Sharpe | Sortino |`);
+    lines.push(`| --- | --- | --- | --- | --- | --- | --- | --- |`);
+    for (const best of train.best) {
+        if (!best.report) {
+            lines.push(`| ${best.criterion} | — | — | — | — | — | — | — |`);
+            continue;
+        }
+        lines.push(`| ${best.criterion} | ${pointLabel(best.report.point)} | ${best.report.trades} | ${best.report.totalPnlPercent.toFixed(2)}% | ` +
+            `${(best.report.winRate * 100).toFixed(0)}% | ${best.report.maxSeriesDrawdownPercent.toFixed(2)} | ${fmtRatio(best.report.sharpe)} | ${fmtRatio(best.report.sortino)} |`);
+    }
+    lines.push("");
+    lines.push(`## Out-of-sample (frozen sharpe winner, ${test.ideasDirectional} tail ideas)`);
+    lines.push("");
+    lines.push(`Frozen point: ${pointLabel(test.point)}`);
+    lines.push("");
+    lines.push(`| Metric | Value |`);
+    lines.push(`| --- | --- |`);
+    lines.push(`| Trades (skipped busy) | ${test.report.trades} (${test.report.skippedBusy}) |`);
+    lines.push(`| PNL | ${test.report.totalPnlPercent.toFixed(2)}% |`);
+    lines.push(`| Win rate | ${(test.report.winRate * 100).toFixed(0)}% |`);
+    lines.push(`| Profit factor | ${fmtRatio(test.report.profitFactor)} |`);
+    lines.push(`| Max series drawdown | ${test.report.maxSeriesDrawdownPercent.toFixed(2)}% |`);
+    lines.push(`| Sharpe / Sortino | ${fmtRatio(test.report.sharpe)} / ${fmtRatio(test.report.sortino)} |`);
+    lines.push(`| Recovery factor | ${fmtRatio(test.report.recoveryFactor)} |`);
+    lines.push(`| Exits | ${Object.entries(test.report.exitReasons).map(([reason, count]) => `${reason}=${count}`).join(", ")} |`);
+    lines.push("");
+    lines.push(`## Test trades`);
+    lines.push("");
+    lines.push(`| Direction | Exit | PNL% | Hold | Entry (UTC) |`);
+    lines.push(`| --- | --- | --- | --- | --- |`);
+    for (const trade of test.trades) {
+        lines.push(`| ${trade.direction} | ${trade.exitReason} | ${trade.pnlPercent.toFixed(2)} | ${trade.holdMinutesActual}m | ${new Date(trade.entryTimestamp).toISOString()} |`);
+    }
+    lines.push("");
+    lines.push(`## Frozen author track record (train range, sharpe winner rule)`);
+    lines.push("");
+    lines.push(`Freeze these raw numbers for production \`Simulator.test\` — banned flags and vote weights are re-derived from them under the frozen point's rule; an author absent from the list is banned by default.`);
+    lines.push("");
+    lines.push(`| Author | Ideas | Hits | Banned |`);
+    lines.push(`| --- | --- | --- | --- |`);
+    for (const stat of test.authorStats) {
+        lines.push(`| ${stat.author} | ${stat.ideas} | ${stat.hits} | ${stat.banned ? "yes" : ""} |`);
+    }
+    return lines.join("\n");
+};
+const main$4 = async () => {
+    if (!getEntry(import.meta.url)) {
+        return;
+    }
+    const { values, positionals } = getArgs();
+    if (!values.tune) {
+        return;
+    }
+    const [ideasPath = null] = positionals.filter((value) => value.endsWith(".jsonl"));
+    if (!ideasPath) {
+        console.error("Error: positional path to an ideas .jsonl file is required");
+        process.exit(1);
+    }
+    let ideas = [];
+    {
+        let content;
+        try {
+            content = await readFile(resolve(ideasPath), "utf-8");
+        }
+        catch (error) {
+            console.error(`Error: cannot read ideas file: ${ideasPath}`);
+            process.exit(1);
+        }
+        const rows = content.split("\n").filter(Boolean);
+        if (!rows.length) {
+            console.error(`Error: ideas file is empty: ${ideasPath}`);
+            process.exit(1);
+        }
+        for (let i = 0; i < rows.length; i++) {
+            let idea;
+            try {
+                idea = JSON.parse(rows[i]);
+            }
+            catch {
+                console.error(`Error: invalid JSON in ideas file, line ${i + 1}`);
+                process.exit(1);
+            }
+            const problem = validateIdea(idea, i + 1);
+            if (problem) {
+                console.error(`Error: ideas file does not match the idea structure — ${problem}`);
+                console.error(`Expected shape: { "id": number, "ts": number, "symbol": string, "direction": "LONG"|"SHORT"|"NEUTRAL", "author": string }`);
+                process.exit(1);
+            }
+            ideas.push(idea);
+        }
+    }
+    const trainSplit = values.split
+        ? parseFloat(values.split)
+        : DEFAULT_TRAIN_SPLIT;
+    if (!Number.isFinite(trainSplit) || trainSplit <= 0 || trainSplit >= 1) {
+        console.error(`Error: --split must be a fraction between 0 and 1, got ${values.split}`);
+        process.exit(1);
+    }
+    {
+        const cwd = process.cwd();
+        dotenv.config({ path: path.join(cwd, '.env'), override: true, quiet: true });
+    }
+    await cli.configConnectionService.loadConfig("setup.config");
+    {
+        const loader = await cli.configConnectionService.loadConfig("loader.config");
+        try {
+            if (typeof loader === "function") {
+                await loader();
+            }
+            if (typeof loader?.loader === "function") {
+                await loader.loader();
+            }
+        }
+        catch (error) {
+            console.error("Module loader failed", error);
+            process.exit(-1);
+        }
+    }
+    await cli.moduleConnectionService.loadModule("tune.module");
+    {
+        await cli.exchangeSchemaService.addSchema();
+        await cli.symbolSchemaService.addSchema();
+    }
+    const [defaultExchangeName = null] = await listExchangeSchema();
+    const exchangeName = values.exchange || defaultExchangeName?.exchangeName;
+    if (values.verbose) {
+        overrideExchangeSchema({
+            exchangeName,
+            callbacks: {
+                onCandleData(symbol, interval, since) {
+                    console.log(`Received candle data for symbol: ${symbol}, interval: ${interval}, since: ${since.toUTCString()}`);
+                },
+            },
+        });
+    }
+    const symbol = values.symbol || "BTCUSDT";
+    // Подбор параметров: полная сетка с собирающей прибыль механикой —
+    // замок, трейлинг, взвешенный консенсус, Вильсон, обе метрики бана.
+    // Честность обеспечивается сплитом: обучение видит только голову,
+    // хвост тратится на один выстрел замороженного sharpe-победителя
+    addSimulatorSchema({
+        simulatorName: SIMULATOR_NAME,
+        exchangeName,
+        gridAxes: {
+            // стопы < 2% сидят внутри медианного шейкаута и не выигрывают
+            hardStopPercent: [2, 2.5, 3, 4, 5, 7],
+            trailingTakePercent: [1, 1.5, 2, 3, 4],
+            holdMinutes: [24 * 60, 2 * 24 * 60, 3 * 24 * 60],
+            minIdeasAligned: [1, 2],
+            minAuthorTrack: [2, 3, 5],
+            minAuthorHitRate: [0.5, 0.6],
+            minAuthorWilson: [0, 0.6],
+            minWeightAligned: [0, 0.6, 1.2],
+            profitLockPercent: [0, 1.5, 2.5],
+            authorMetric: ["close", "reach"],
+            banCriteria: ["sharpe"],
+        },
+        reportOrder: "sharpe",
+        callbacks: {
+            onProgress: (symbol, stage, processed, total) => {
+                if (values.verbose) {
+                    console.log("onProgress", { symbol, stage, processed, total });
+                }
+            },
+            onIdeas: (symbol, ideasTotal, ideasDirectional) => {
+                if (values.verbose) {
+                    console.log("onIdeas", { symbol, ideasTotal, ideasDirectional });
+                }
+            },
+            onProfiles: (symbol, profiles, truncatedCount) => {
+                if (values.verbose) {
+                    console.log("onProfiles", { symbol, profiles: profiles.length, truncatedCount });
+                }
+            },
+            onAuthorsTrained: (symbol, stats, bannedIdeas) => {
+                if (values.verbose) {
+                    console.log("onAuthorsTrained", {
+                        symbol,
+                        authors: stats.length,
+                        banned: stats.filter(({ banned }) => banned).length,
+                        bannedIdeas,
+                    });
+                }
+            },
+            onRanking: (symbol, criterion, _sorted, best) => {
+                if (values.verbose) {
+                    console.log("onRanking", {
+                        symbol,
+                        criterion,
+                        point: best.report?.point ?? null,
+                        pnl: best.report ? +best.report.totalPnlPercent.toFixed(2) : null,
+                    });
+                }
+            },
+            onTestDone: (symbol, result) => {
+                if (values.verbose) {
+                    console.log("onTestDone", {
+                        symbol,
+                        trades: result.report.trades,
+                        pnl: +result.report.totalPnlPercent.toFixed(2),
+                    });
+                }
+            },
+        },
+    });
+    // обучение видит ТОЛЬКО голову ленты; хвост — один OOS-выстрел
+    const sorted = [...ideas].sort((a, b) => a.ts - b.ts);
+    const cutoff = sorted[0].ts + (sorted[sorted.length - 1].ts - sorted[0].ts) * trainSplit;
+    const trainIdeas = sorted.filter(({ ts }) => ts < cutoff);
+    const testIdeas = sorted.filter(({ ts }) => ts >= cutoff);
+    const train = await Simulator.run({
+        symbol,
+        simulatorName: SIMULATOR_NAME,
+        ideas: trainIdeas,
+    });
+    const sharpeBest = train.best.find(({ criterion }) => criterion === "sharpe");
+    if (!sharpeBest?.report) {
+        console.error("Error: training produced no sharpe winner — nothing to freeze for the out-of-sample shot");
+        process.exit(1);
+    }
+    // заморозка: точка и трек-рекорд sharpe-победителя как есть — из
+    // замороженных статов test() читает только author/ideas/hits и сам
+    // перевыводит баны и веса под правило точки
+    const test = await Simulator.test({
+        symbol,
+        simulatorName: SIMULATOR_NAME,
+        ideas: testIdeas,
+        point: sharpeBest.report.point,
+        authorStats: sharpeBest.authorStats,
+    });
+    const dumpName = values.output || `tune_${symbol}_${Date.now()}`;
+    const dumpDir = join(process.cwd(), "dump");
+    if (values.json) {
+        const filePath = resolve(dumpDir, `${dumpName}.json`);
+        await mkdir(dumpDir, { recursive: true });
+        await writeFile(filePath, JSON.stringify({ trainSplit, train, test }, null, 2), "utf-8");
+        console.log(`Saved: ${filePath}`);
+        process.exit(0);
+    }
+    if (values.markdown) {
+        const filePath = resolve(dumpDir, `${dumpName}.md`);
+        await mkdir(dumpDir, { recursive: true });
+        await writeFile(filePath, toMarkdown(train, test, trainSplit), "utf-8");
+        console.log(`Saved: ${filePath}`);
+        process.exit(0);
+    }
+    console.log(toMarkdown(train, test, trainSplit));
     process.exit(0);
 };
 main$4();
@@ -4852,7 +5633,8 @@ Modes:
   --dump                Fetch and save raw OHLCV candles
   --pnldebug            Simulate PnL per minute for a given entry price and direction
   --brokerdebug         Fire a single broker commit against the live broker adapter
-  --simulator <ideas.jsonl>  Sweep exit/entry parameters over crowd ideas, train author whitelist
+  --simulator <ideas.jsonl>  Feasibility probe over crowd ideas: is there a profitable corridor at all
+  --tune      <ideas.jsonl>  Walk-forward parameter search: train on the head, one frozen shot on the tail
   --flush  <entry...>   Delete report/log/markdown/agent folders from strategy dump dir
   --init                Scaffold a new project in the current directory
   --docker              Scaffold a Docker workspace for running strategies in a container
@@ -4987,19 +5769,47 @@ Simulator flags (--simulator):
   "author": string }. The file is validated BEFORE any work; a line that does not
   match the structure aborts the run with an error.
 
-  Runs the backtest-kit Simulator entity: one 5-day candle pass per idea, flood
-  dedupe (one idea per author per direction per 8h), default-ban author filter
-  (ban thresholds are grid axes), grid evaluation with time-based Sharpe/Sortino,
-  three ranking winners. The report includes the production author whitelist.
+  A FEASIBILITY PROBE, not a parameter search (that is --tune): the profit-harvesting
+  machinery is off (no profit lock, inert trailing, no weighted consensus), and a
+  fast 48-point grid of hard stop x hold x ban rule answers one question — does the
+  feed contain a profitable corridor at all. One 5-day candle pass per idea, flood
+  dedupe (one idea per author per direction per 8h), default-ban author filter,
+  time-based Sharpe/Sortino, four ranking winners. The report carries the corridor
+  share and the whitelist of the sharpe winner's ban rule as evidence.
   Ideas of other symbols are filtered out — one shared feed serves any --symbol.
 
   No output flag → print the Markdown summary to stdout. With --verbose every
-  simulator lifecycle callback (onIdeas, onProfiles, onAuthorsTrained, onGridPoint,
-  onRanking, onDone) is logged to the console as it fires.
+  simulator lifecycle callback (onProgress, onIdeas, onProfiles, onAuthorsTrained,
+  onGridPoint, onRanking, onDone) is logged to the console as it fires.
 
   Module file ./modules/simulator.module is loaded automatically if it exists
   (register your exchange there); without it CCXT Binance is used by default.
 
+Tune flags (--tune):
+
+  --symbol      <string>   Trading pair to tune (default: BTCUSDT)
+  --exchange    <string>   Exchange name (default: first registered)
+  --split       <string>   Train share of the feed time range, 0..1 (default: 0.7)
+  --output      <string>   Output file base name (default: tune_{SYMBOL}_{TIMESTAMP})
+  --json                   Save { trainSplit, train, test } to ./dump/<output>.json
+  --markdown               Save walk-forward report to ./dump/<output>.md
+  --verbose                Log simulator lifecycle callbacks to the console
+
+  Positional: path to an ideas .jsonl file — same shape and validation as --simulator.
+
+  The PARAMETER SEARCH counterpart of the --simulator probe: the full grid with the
+  profit-harvesting machinery on — profit lock, trailing take, weighted consensus,
+  Wilson-bound ban, both author-hit metrics (close/reach). Honesty is structural:
+  training sees ONLY the head of the feed (--split of its time range), then the
+  sharpe winner is frozen — point and raw author track record — and fired exactly
+  once on the tail via Simulator.test. Nothing is trained on the tail; authors
+  unseen in training are banned by default. The report carries the train winners,
+  the out-of-sample result with the trade list, and the frozen author track record
+  to hardcode for production Simulator.test.
+
+  Module file ./modules/tune.module is loaded automatically if it exists
+  (register your exchange there); without it CCXT Binance is used by default.
+
 Flush flags (--flush):
 
   One or more positional entry points. For each entry point the following
@@ -5033,7 +5843,8 @@ Module hooks (loaded automatically by each mode):
   modules/dump.module       --dump       Exchange schema for candle dumps
   modules/pnldebug.module   --pnldebug      Exchange schema for PnL debug runs
   modules/brokerdebug.module  --brokerdebug   Broker adapter used for broker commit testing
-  modules/simulator.module  --simulator     Exchange schema for crowd-ideas simulation
+  modules/simulator.module  --simulator     Exchange schema for the crowd-ideas feasibility probe
+  modules/tune.module       --tune          Exchange schema for the walk-forward parameter search
 
   --flush has no associated module. It only removes dump subdirectories.
 
@@ -5062,8 +5873,10 @@ Examples:
   node ${ENTRY_PATH} --pnldebug --priceopen 67956.73 --direction long --when 1772064000000 --minutes 60 --markdown
   node ${ENTRY_PATH} --brokerdebug --commit signal-open --symbol BTCUSDT
   node ${ENTRY_PATH} --brokerdebug --commit partial-profit --symbol ETHUSDT
-  node ${ENTRY_PATH} --simulator --symbol BTCUSDT ./assets/ts-ideas.normalized.jsonl
-  node ${ENTRY_PATH} --simulator --symbol BTCUSDT --json --output jun_2026_sweep ./assets/ts-ideas.normalized.jsonl
+  node ${ENTRY_PATH} --simulator --symbol BTCUSDT ./assets/tv-ideas.normalized.jsonl
+  node ${ENTRY_PATH} --simulator --symbol BTCUSDT --json --output jun_2026_probe ./assets/tv-ideas.normalized.jsonl
+  node ${ENTRY_PATH} --tune --symbol BTCUSDT ./assets/tv-ideas.normalized.jsonl
+  node ${ENTRY_PATH} --tune --symbol BTCUSDT --split 0.7 --markdown --output jun_2026_tune ./assets/tv-ideas.normalized.jsonl
   node ${ENTRY_PATH} --flush ./content/feb_2026.strategy/feb_2026.strategy.ts
   node ${ENTRY_PATH} --flush ./content/feb_2026.strategy/feb_2026.strategy.ts ./content/feb_2026.strategy/feb_2026.test.ts
   node ${ENTRY_PATH} --init --output my-trading-bot
@@ -5077,7 +5890,7 @@ const main$1 = async () => {
     if (!values.help) {
         return;
     }
-    process.stdout.write(`@backtest-kit/cli ${"16.4.0"}\n\n`);
+    process.stdout.write(`@backtest-kit/cli ${"16.6.0"}\n\n`);
     process.stdout.write(HELP_TEXT);
     process.exit(0);
 };
@@ -5091,7 +5904,7 @@ const main = async () => {
     if (!values.version) {
         return;
     }
-    process.stdout.write(`@backtest-kit/cli ${"16.4.0"}\n`);
+    process.stdout.write(`@backtest-kit/cli ${"16.6.0"}\n`);
     process.exit(0);
 };
 main();