@backtest-kit/cli 5.10.2 → 5.11.1

package/build/index.mjs

@@ -4,8 +4,8 @@ import { Storage, Notification, Markdown, Report, Dump, Memory, StorageLive, Sto
 import { getErrorMessage, errorData, singleshot, str, BehaviorSubject, compose, execpool, queued, sleep, randomString, createAwaiter, TIMEOUT_SYMBOL, typo, retry, trycatch, memoize } from 'functools-kit';
 import fs, { constants } from 'fs';
 import * as stackTrace from 'stack-trace';
-import path, { basename, extname, join, resolve } from 'path';
-import fs$1, { access, readFile, mkdir, writeFile } from 'fs/promises';
+import path, { basename, extname, join, resolve, dirname } from 'path';
+import fs$1, { access, readFile, mkdir, writeFile, readdir, copyFile } from 'fs/promises';
 import dotenv from 'dotenv';
 import { createActivator } from 'di-kit';
 import { fileURLToPath } from 'url';
@@ -30,6 +30,7 @@ import * as BacktestKitOllama from '@backtest-kit/ollama';
 import * as BacktestKitPinets from '@backtest-kit/pinets';
 import { run as run$1, Code, toMarkdown } from '@backtest-kit/pinets';
 import * as BacktestKitSignals from '@backtest-kit/signals';
+import { spawn } from 'child_process';
 
 /**
  * Fix for `Attempted to assign to readonly property (at redactToken)`
@@ -93,6 +94,7 @@ setConfig({
 setConfig({
     CC_ENABLE_DCA_EVERYWHERE: true,
     CC_ENABLE_PPPL_EVERYWHERE: true,
+    CC_ENABLE_TRAILING_EVERYWHERE: true,
 });
 setConfig({
     CC_MAX_SIGNAL_GENERATION_SECONDS: 15 * 60,
@@ -258,15 +260,15 @@ const TYPES = {
 
 const entrySubject = new BehaviorSubject();
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
+const __filename$1 = fileURLToPath(import.meta.url);
+const __dirname$1 = path.dirname(__filename$1);
 let _is_launched = false;
 class ResolveService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
         this.loaderService = inject(TYPES.loaderService);
-        this.DEFAULT_TEMPLATE_DIR = path.resolve(__dirname, '..', 'template');
-        this.DEFAULT_MODULES_DIR = path.resolve(__dirname, '..', 'modules');
+        this.DEFAULT_TEMPLATE_DIR = path.resolve(__dirname$1, '..', 'template');
+        this.DEFAULT_MODULES_DIR = path.resolve(__dirname$1, '..', 'modules');
         this.OVERRIDE_TEMPLATE_DIR = path.resolve(process.cwd(), 'template');
         this.OVERRIDE_MODULES_DIR = path.resolve(process.cwd(), 'modules');
         this.getIsLaunched = () => {
@@ -420,6 +422,18 @@ var FrameName;
 })(FrameName || (FrameName = {}));
 var FrameName$1 = FrameName;
 
+const ALLOWED_EXTENSIONS = [
+    `.cjs`,
+    `.mjs`,
+    `.ts`,
+    `.tsx`,
+    `.js`,
+    `.pine`,
+];
+const DISALLOWED_PATHS = [
+    "node_modules",
+    "@backtest-kit",
+];
 const getArgs = singleshot(() => {
     const { values, positionals } = parseArgs({
         args: process.argv,
@@ -514,6 +528,10 @@ const getArgs = singleshot(() => {
                 type: "boolean",
                 default: false,
             },
+            init: {
+                type: "boolean",
+                default: false,
+            },
         },
         strict: false,
         allowPositionals: true,
@@ -523,6 +541,13 @@ const getArgs = singleshot(() => {
         positionals,
     };
 });
+const getPositional = singleshot(() => {
+    const { positionals = [] } = getArgs();
+    const result = positionals
+        .filter((value) => !DISALLOWED_PATHS.some((path) => value.includes(path)))
+        .find((value) => ALLOWED_EXTENSIONS.some((ext) => value.endsWith(ext)));
+    return result || null;
+});
 
 const ADD_FRAME_FN = (self) => {
     self.loggerService.log("Adding February 2024 as a default frame schema");
@@ -708,11 +733,11 @@ class BacktestMainService {
             if (!getEntry(import.meta.url)) {
                 return;
             }
-            const { values, positionals } = getArgs();
+            const { values } = getArgs();
             if (!values.backtest) {
                 return;
             }
-            const [entryPoint = null] = positionals.slice(-1);
+            const entryPoint = getPositional();
             if (!entryPoint) {
                 throw new Error("Entry point is required");
             }
@@ -787,11 +812,11 @@ class LiveMainService {
             if (!getEntry(import.meta.url)) {
                 return;
             }
-            const { values, positionals } = getArgs();
+            const { values } = getArgs();
             if (!values.live) {
                 return;
             }
-            const [entryPoint = null] = positionals.slice(-1);
+            const entryPoint = getPositional();
             if (!entryPoint) {
                 throw new Error("Entry point is required");
             }
@@ -860,11 +885,11 @@ class PaperMainService {
             if (!getEntry(import.meta.url)) {
                 return;
             }
-            const { values, positionals } = getArgs();
+            const { values } = getArgs();
             if (!values.paper) {
                 return;
             }
-            const [entryPoint = null] = positionals.slice(-1);
+            const entryPoint = getPositional();
             if (!entryPoint) {
                 throw new Error("Entry point is required");
             }
@@ -2177,7 +2202,7 @@ const BEFORE_EXIT_FN$4 = singleshot(async () => {
 const listenGracefulShutdown$4 = singleshot(() => {
     process.on("SIGINT", BEFORE_EXIT_FN$4);
 });
-const main$6 = async () => {
+const main$7 = async () => {
     if (!getEntry(import.meta.url)) {
         return;
     }
@@ -2188,7 +2213,7 @@ const main$6 = async () => {
     await cli.backtestMainService.connect();
     listenGracefulShutdown$4();
 };
-main$6();
+main$7();
 
 const BEFORE_EXIT_FN$3 = singleshot(async () => {
     process.off("SIGINT", BEFORE_EXIT_FN$3);
@@ -2209,7 +2234,7 @@ const BEFORE_EXIT_FN$3 = singleshot(async () => {
 const listenGracefulShutdown$3 = singleshot(() => {
     process.on("SIGINT", BEFORE_EXIT_FN$3);
 });
-const main$5 = async () => {
+const main$6 = async () => {
     if (!getEntry(import.meta.url)) {
         return;
     }
@@ -2220,7 +2245,7 @@ const main$5 = async () => {
     cli.paperMainService.connect();
     listenGracefulShutdown$3();
 };
-main$5();
+main$6();
 
 const BEFORE_EXIT_FN$2 = singleshot(async () => {
     process.off("SIGINT", BEFORE_EXIT_FN$2);
@@ -2241,7 +2266,7 @@ const BEFORE_EXIT_FN$2 = singleshot(async () => {
 const listenGracefulShutdown$2 = singleshot(() => {
     process.on("SIGINT", BEFORE_EXIT_FN$2);
 });
-const main$4 = async () => {
+const main$5 = async () => {
     if (!getEntry(import.meta.url)) {
         return;
     }
@@ -2252,7 +2277,7 @@ const main$4 = async () => {
     await cli.liveMainService.connect();
     listenGracefulShutdown$2();
 };
-main$4();
+main$5();
 
 const BEFORE_EXIT_FN$1 = singleshot(async () => {
     process.off("SIGINT", BEFORE_EXIT_FN$1);
@@ -2262,7 +2287,7 @@ const BEFORE_EXIT_FN$1 = singleshot(async () => {
 const listenGracefulShutdown$1 = singleshot(() => {
     process.on("SIGINT", BEFORE_EXIT_FN$1);
 });
-const main$3 = async () => {
+const main$4 = async () => {
     if (!getEntry(import.meta.url)) {
         return;
     }
@@ -2272,7 +2297,7 @@ const main$3 = async () => {
     }
     listenGracefulShutdown$1();
 };
-main$3();
+main$4();
 
 const BEFORE_EXIT_FN = singleshot(async () => {
     process.off("SIGINT", BEFORE_EXIT_FN);
@@ -2282,7 +2307,7 @@ const BEFORE_EXIT_FN = singleshot(async () => {
 const listenGracefulShutdown = singleshot(() => {
     process.on("SIGINT", BEFORE_EXIT_FN);
 });
-const main$2 = async () => {
+const main$3 = async () => {
     if (!getEntry(import.meta.url)) {
         return;
     }
@@ -2292,7 +2317,7 @@ const main$2 = async () => {
     }
     listenGracefulShutdown();
 };
-main$2();
+main$3();
 
 const EXTRACT_ROWS_FN = (plots, schema) => {
     const keys = Object.keys(schema);
@@ -2314,15 +2339,15 @@ const EXTRACT_ROWS_FN = (plots, schema) => {
     }
     return rows;
 };
-const main$1 = async () => {
+const main$2 = async () => {
     if (!getEntry(import.meta.url)) {
         return;
     }
-    const { values, positionals } = getArgs();
+    const { values } = getArgs();
     if (!values.pine) {
         return;
     }
-    const [entryPoint = null] = positionals.slice(-1);
+    const entryPoint = getPositional();
     if (!entryPoint) {
         return;
     }
@@ -2386,9 +2411,9 @@ const main$1 = async () => {
     }
     console.log(await toMarkdown(signalId, plots, signalSchema));
 };
-main$1();
+main$2();
 
-const main = async () => {
+const main$1 = async () => {
     if (!getEntry(import.meta.url)) {
         return;
     }
@@ -2433,6 +2458,83 @@ const main = async () => {
     }
     console.log(JSON.stringify(candles, null, 2));
 };
+main$1();
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const MUSTACHE_EXT = ".mustache";
+async function isDirEmpty(dirPath) {
+    try {
+        const files = await readdir(dirPath);
+        return files.length === 0;
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return true;
+        }
+        throw error;
+    }
+}
+async function copyDir(srcDir, destDir, data) {
+    await mkdir(destDir, { recursive: true });
+    const entries = await readdir(srcDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = join(srcDir, entry.name);
+        if (entry.isDirectory()) {
+            await copyDir(srcPath, join(destDir, entry.name), data);
+            continue;
+        }
+        if (entry.name.endsWith(MUSTACHE_EXT)) {
+            const destName = entry.name.slice(0, -MUSTACHE_EXT.length);
+            const destPath = join(destDir, destName);
+            const template = await readFile(srcPath, "utf-8");
+            const rendered = Mustache.render(template, data);
+            await writeFile(destPath, rendered, "utf-8");
+            console.log(`  -> ${destPath}`);
+        }
+        else {
+            const destPath = join(destDir, entry.name);
+            await copyFile(srcPath, destPath);
+            console.log(`  -> ${destPath}`);
+        }
+    }
+}
+function runScript(scriptPath, cwd) {
+    return new Promise((resolve, reject) => {
+        const node = process.execPath;
+        const child = spawn(node, [scriptPath], { cwd, stdio: "inherit" });
+        child.on("close", (code) => {
+            if (code !== 0) {
+                reject(new Error(`Script exited with code ${code}`));
+                return;
+            }
+            resolve();
+        });
+        child.on("error", reject);
+    });
+}
+const main = async () => {
+    if (!getEntry(import.meta.url)) {
+        return;
+    }
+    const { values } = getArgs();
+    if (!values.init) {
+        return;
+    }
+    const projectName = values.output || "backtest-kit-project";
+    const projectPath = join(process.cwd(), projectName);
+    const templatePath = join(__dirname, "../../template/project");
+    const isEmpty = await isDirEmpty(projectPath);
+    if (!isEmpty) {
+        console.error(`Directory "${projectName}" already exists and is not empty.`);
+        process.exit(1);
+    }
+    console.log(`Creating project in ${projectPath}`);
+    await copyDir(templatePath, projectPath, { PROJECT_NAME: projectName });
+    console.log(`Fetching docs...`);
+    await runScript(join(projectPath, "scripts/fetch_docs.mjs"), projectPath);
+    console.log(`Done! Project created at ${projectPath}`);
+};
 main();
 
 function setLogger(logger) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@backtest-kit/cli",
-  "version": "5.10.2",
+  "version": "5.11.1",
   "description": "Zero-boilerplate CLI runner for backtest-kit strategies. Run backtests, paper trading, and live bots with candle cache warming, web dashboard, and Telegram notifications — no setup code required.",
   "author": {
     "name": "Petr Tripolsky",
@@ -61,11 +61,11 @@
   "devDependencies": {
     "@babel/plugin-transform-modules-umd": "7.27.1",
     "@babel/standalone": "7.29.1",
-    "@backtest-kit/ui": "5.10.0",
-    "@backtest-kit/graph": "5.10.0",
-    "@backtest-kit/ollama": "5.10.0",
-    "@backtest-kit/pinets": "5.10.0",
-    "@backtest-kit/signals": "5.10.0",
+    "@backtest-kit/ui": "5.11.0",
+    "@backtest-kit/graph": "5.11.0",
+    "@backtest-kit/ollama": "5.11.0",
+    "@backtest-kit/pinets": "5.11.0",
+    "@backtest-kit/signals": "5.11.0",
     "@rollup/plugin-replace": "6.0.3",
     "@rollup/plugin-typescript": "11.1.6",
     "@types/image-size": "0.7.0",
@@ -73,7 +73,7 @@
     "@types/mustache": "4.2.6",
     "@types/node": "22.9.0",
     "@types/stack-trace": "0.0.33",
-    "backtest-kit": "5.10.0",
+    "backtest-kit": "5.11.0",
     "glob": "11.0.1",
     "markdown-it": "14.1.1",
     "rimraf": "6.0.1",
@@ -88,12 +88,12 @@
   "peerDependencies": {
     "@babel/plugin-transform-modules-umd": "^7.27.1",
     "@babel/standalone": "^7.29.1",
-    "@backtest-kit/ui": "^5.10.0",
-    "@backtest-kit/graph": "^5.10.0",
-    "@backtest-kit/ollama": "^5.10.0",
-    "@backtest-kit/pinets": "^5.10.0",
-    "@backtest-kit/signals": "^5.10.0",
-    "backtest-kit": "^5.10.0",
+    "@backtest-kit/ui": "^5.11.0",
+    "@backtest-kit/graph": "^5.11.0",
+    "@backtest-kit/ollama": "^5.11.0",
+    "@backtest-kit/pinets": "^5.11.0",
+    "@backtest-kit/signals": "^5.11.0",
+    "backtest-kit": "^5.11.0",
     "markdown-it": "^14.1.1",
     "typescript": "^5.0.0"
   },

package/template/project/CLAUDE.md

@@ -0,0 +1,158 @@
+## Guide
+
+### How to Write a Strategy
+
+**What NOT to do**
+
+- Don't read all project files and bloat the context.
+
+   Strategies are written as simple `.pine` files; the command to run them is below.
+
+- Don't brute-force iterate.
+
+   The worst thing you can do is start incrementally writing into an existing project file. That's not how this works — you need market analysis, not work for the sake of work.
+
+- Don't sacrifice efficiency for universality.
+
+   Markets change. By building a universal solution you lose the optimization that is the competitive edge actually generating profit at any given moment.
+
+- Don't write `.pine` files with side effects.
+
+   You don't need `var` and `na` in PineScript — compute all values on every iteration. This makes errors and unpredictable behavior more likely to surface before going to production. Keep the code easy to understand; avoid premature optimization.
+
+- Don't use hacks in trading strategy code.
+
+   You cannot disguise the absence of an SL by using ATR when the exit keeps shifting relative to the close price on every iteration. Trailing criteria must be finite — you cannot keep shifting the stop loss forever hoping for a bounce or a drop. Avoid HOLD in any form.
+
+- Don't build strategies that produce one signal every few days.
+
+   Three profitable signals is not a successful trading strategy — it's luck. To evaluate a strategy statistically you need at least one signal per day.
+
+**What TO do**
+
+- Every strategy is written for a single calendar month.
+
+   Follow the naming pattern or refuse to work. The money is in optimizing for current market conditions; a backtest spanning two or more months is mathematically meaningless because the final balance will wipe out profit through commission whipsaw.
+
+   * `./math/jan_2026.pine`, `./content/jan_2026.strategy.ts`
+   * `./math/feb_2026.pine`, `./content/feb_2026.strategy.ts`
+   * `./math/march_2026.pine`, `./content/march_2026.strategy.ts`
+   * `./math/apr_2026.pine`, `./content/apr_2026.strategy.ts`
+   * `./math/may_2026.pine`, `./content/may_2026.strategy.ts`
+
+- Read the news background for the chosen time period.
+
+   The focus should ALWAYS be on negative news. Searching for the Bitcoin price gives you marketing trash. Searching for analytics gives you SEO garbage. Use queries like:
+
+   * Bitcoin negative news March 2026 price drop regulatory problems…
+   * bitcoin price February 5 2024 current level forecast analytics BTC
+   * bitcoin negative news February 2024 problems regulator crackdown bitcoin
+   * bitcoin negative news March 2026 regulatory problems bans
+   * bitcoin security hackers fraud regulation negative news problems
+
+- Create a `--dump` to output candles.
+
+   You need to see where the money actually is in the market. Identify the general trend: if it's bearish, protect against LONGs; if it's bullish, protect against SHORTs. There may be a short-term bounce or panic driven by geopolitical news.
+
+- The market may be ranging (sideways).
+
+   There are cases when no position should be opened at all — your analysis must account for this.
+
+- TP/SL should be dynamic, but not scalping.
+
+   The exchange charges 0.2% to enter and 0.2% to exit. You may think the strategy is profitable, but it's whipsaw. Minimum TP: 1%.
+
+- Don't try to build an all-weather strategy.
+
+   I need to understand where the money is in the market only within the specified time period. If the strategy stops being profitable I'll simply ask you to run the analysis again.
+
+- Don't build HOLD strategies.
+
+   I need to find where the money actually is in the market, not sit in a position hoping for luck. The criterion for "where the money is" must be expressed as a formula that finds effective entry points that lead to profit directly.
+
+- Don't brut force strategies.
+
+    Use fresh strategies with different concepts. Do not edit existing strategy one cause this will give you a loop even if you coded it. I need concept engineering
+
+### Market Candle Dump
+
+File `BTCUSDT_500_15m_1772236800000.jsonl` will be created at `./dump/BTCUSDT_500_15m_1772236800000.jsonl`
+
+```
+npm start -- --dump --timeframe 15m --limit 500 --when "2026-02-28T00:00:00.000Z" --jsonl
+```
+
+### Running `.pine` Files
+
+File `impulse_trend_15m.jsonl` will be created at `./math/dump/impulse_trend_15m.jsonl`
+
+```
+npm start --  --pine ./math/impulse_trend_15m.pine --timeframe 15m --limit 500 --when "2026-02-28T00:00:00.000Z" --jsonl
+```
+
+### Algorithm
+
+**Planning the Work**
+
+1. Read the `.pine` file from the previous month if one exists.
+
+2. Read news from the internet for the current month with a focus on negative news.
+
+3. Correlate the news background with the candle dump. News sources must visibly influence the candle data for the chosen time period: price bounce, sideways range, neutral trend, decline, or rally.
+
+4. Understand why the previous month's file stopped working by interpreting its logic in the context of the new news background.
+
+5. In addition to news, review the candle dump independently: assess volatility, market gaps, trading volumes, and risks.
+
+**Writing the Strategy**
+
+1. Create NEW files for the current month and write them from scratch. Do not copy-paste and do not attempt to brute-force parameters. New month — new strategy.
+
+2. Run the `.pine` file and review the output. The acceptance criterion is a profitable trading strategy, not code for the sake of code. Do not stop until profit is achieved.
+
+3. After obtaining a profitable strategy, ALWAYS save the knowledge base used to build it into a markdown file with fundamental market analysis, following the naming pattern:
+
+   * `./report/jan_2026.md`
+   * `./report/feb_2026.md`
+   * `./report/march_2026.md`
+
+4. Run a code review as a separate agent.
+
+   The code review must check the strategy for perpetual hold without strict exit conditions — for example, a trailing SL that shifts forever relative to the close of the last candle. I need not just to make money, but to mathematically identify where the money is in the market in order to avoid large portfolio liquidity drawdowns.
+
+5. If the code review fails, incorporate the findings and rebuild the strategy from scratch following this guide.
+
+### Recommendations
+
+- Search the internet for ideas.
+
+   I welcome borrowing trading ideas from other people via internet search rather than brute-forcing options. It's important not only to find someone else's concept but also to verify in practice that it is actually profitable.
+
+- Analyze market structure.
+
+   Looking at the candles reveals the structures present in the current month: sideways range, neutral trend, bullish trend, bearish trend, high volatility. Think through how to identify and how to act in each case.
+
+- Use a TODO list.
+
+   This guide has many steps. Form a TODO list and work through it step by step, marking each item complete. Include news research, candle `--dump` analysis, pine strategy analysis — as granularly as possible.
+
+- Use deep research.
+
+   The guide calls for intelligent market analysis, not code for the sake of code. Think carefully; don't cut corners on tokens.
+
+- Think logically.
+
+   A 1% target cannot be reached in less than 4 hours. A target below 1% is uninteresting because slippage will knock the position out before achieving an effective Risk/Reward. I don't need a formal reply — I need market analysis.
+
+### Deliverable
+
+A `.pine` file free of marketing fluff:
+
+- Forbidden: TP=0.5% SL=-10% and any similar asymmetric nonsense. Risk management must be sound and must rule out holding on luck.
+- Clearly described and commented operating modes with references to the time period on which they were tested.
+- An honest profitability summary in the file header as a comment.
+- An honest average daily signal count in the file header.
+- An honest `sharpeRatio`, `avgPnl`, `stdDev` in the file header.
+- One or more signals per day — more is better.
+
+If it is impossible to make money, do not try to fudge the results. Write it as it is, without embellishment.

package/template/project/content/feb_2026.strategy.ts

@@ -0,0 +1,114 @@
+import {
+  addExchangeSchema,
+  addFrameSchema,
+  addStrategySchema,
+  listenError,
+  Cache,
+  Log,
+} from "backtest-kit";
+import {
+  errorData,
+  getErrorMessage,
+  randomString,
+  singleshot,
+} from "functools-kit";
+import ccxt from "ccxt";
+import { run, File, extract } from "@backtest-kit/pinets";
+import { outputNode, resolve, sourceNode } from "@backtest-kit/graph";
+
+const getExchange = singleshot(async () => {
+  const exchange = new ccxt.binance({
+    options: {
+      defaultType: "spot",
+      adjustForTimeDifference: true,
+      recvWindow: 60000,
+    },
+    enableRateLimit: true,
+  });
+  await exchange.loadMarkets();
+  return exchange;
+});
+
+const pineSource = sourceNode(
+  Cache.fn(
+    async (symbol) => {
+      const plots = await run(File.fromPath("feb_2026.pine", "../math"), {
+        symbol,
+        timeframe: "15m",
+        limit: 2688,
+      });
+
+      return await extract(plots, {
+        position: "Position",
+        entryPrice: "EntryPrice",
+        tp: "TP",
+        sl: "SL",
+      });
+    },
+    { interval: "15m", key: ([symbol]) => symbol },
+  ),
+);
+
+const signalOutput = outputNode(async ([pineSource]) => {
+  const position =
+    pineSource.position === -1
+      ? "short"
+      : pineSource.position === 1
+        ? "long"
+        : "wait";
+
+  if (position === "wait") {
+    return null;
+  }
+
+  return {
+    id: randomString(),
+    position,
+    priceOpen: pineSource.entryPrice,
+    priceTakeProfit: pineSource.tp,
+    priceStopLoss: pineSource.sl,
+    minuteEstimatedTime: Infinity,
+  } as const;
+}, pineSource);
+
+addExchangeSchema({
+  exchangeName: "ccxt-exchange",
+  getCandles: async (symbol, interval, since, limit) => {
+    const exchange = await getExchange();
+    const candles = await exchange.fetchOHLCV(
+      symbol,
+      interval,
+      since.getTime(),
+      limit,
+    );
+    return candles.map(([timestamp, open, high, low, close, volume]) => ({
+      timestamp,
+      open,
+      high,
+      low,
+      close,
+      volume,
+    }));
+  },
+});
+
+addFrameSchema({
+  frameName: "feb_2026_frame",
+  interval: "1m",
+  startDate: new Date("2026-02-01T00:00:00Z"),
+  endDate: new Date("2026-02-28T23:59:59Z"),
+  note: "February 2026",
+});
+
+addStrategySchema({
+  strategyName: "feb_2026_strategy",
+  interval: "1m",
+  getSignal: async () => await resolve(signalOutput),
+});
+
+listenError((error) => {
+  Log.debug("error", {
+    error: errorData(error),
+    message: getErrorMessage(error),
+  });
+});