@backtest-kit/cli 5.11.0 → 6.0.0

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)`
@@ -259,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 = () => {
@@ -429,6 +430,10 @@ const ALLOWED_EXTENSIONS = [
     `.js`,
     `.pine`,
 ];
+const DISALLOWED_PATHS = [
+    "node_modules",
+    "@backtest-kit",
+];
 const getArgs = singleshot(() => {
     const { values, positionals } = parseArgs({
         args: process.argv,
@@ -523,6 +528,18 @@ const getArgs = singleshot(() => {
                 type: "boolean",
                 default: false,
             },
+            init: {
+                type: "boolean",
+                default: false,
+            },
+            help: {
+                type: "boolean",
+                default: false,
+            },
+            version: {
+                type: "boolean",
+                default: false,
+            },
         },
         strict: false,
         allowPositionals: true,
@@ -534,7 +551,9 @@ const getArgs = singleshot(() => {
 });
 const getPositional = singleshot(() => {
     const { positionals = [] } = getArgs();
-    const result = positionals.find((value) => ALLOWED_EXTENSIONS.some((ext) => value.endsWith(ext)));
+    const result = positionals
+        .filter((value) => !DISALLOWED_PATHS.some((path) => value.includes(path)))
+        .find((value) => ALLOWED_EXTENSIONS.some((ext) => value.endsWith(ext)));
     return result || null;
 });
 
@@ -2191,7 +2210,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$9 = async () => {
     if (!getEntry(import.meta.url)) {
         return;
     }
@@ -2202,7 +2221,7 @@ const main$6 = async () => {
     await cli.backtestMainService.connect();
     listenGracefulShutdown$4();
 };
-main$6();
+main$9();
 
 const BEFORE_EXIT_FN$3 = singleshot(async () => {
     process.off("SIGINT", BEFORE_EXIT_FN$3);
@@ -2223,7 +2242,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$8 = async () => {
     if (!getEntry(import.meta.url)) {
         return;
     }
@@ -2234,7 +2253,7 @@ const main$5 = async () => {
     cli.paperMainService.connect();
     listenGracefulShutdown$3();
 };
-main$5();
+main$8();
 
 const BEFORE_EXIT_FN$2 = singleshot(async () => {
     process.off("SIGINT", BEFORE_EXIT_FN$2);
@@ -2255,7 +2274,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$7 = async () => {
     if (!getEntry(import.meta.url)) {
         return;
     }
@@ -2266,7 +2285,7 @@ const main$4 = async () => {
     await cli.liveMainService.connect();
     listenGracefulShutdown$2();
 };
-main$4();
+main$7();
 
 const BEFORE_EXIT_FN$1 = singleshot(async () => {
     process.off("SIGINT", BEFORE_EXIT_FN$1);
@@ -2276,7 +2295,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$6 = async () => {
     if (!getEntry(import.meta.url)) {
         return;
     }
@@ -2286,7 +2305,7 @@ const main$3 = async () => {
     }
     listenGracefulShutdown$1();
 };
-main$3();
+main$6();
 
 const BEFORE_EXIT_FN = singleshot(async () => {
     process.off("SIGINT", BEFORE_EXIT_FN);
@@ -2296,7 +2315,7 @@ const BEFORE_EXIT_FN = singleshot(async () => {
 const listenGracefulShutdown = singleshot(() => {
     process.on("SIGINT", BEFORE_EXIT_FN);
 });
-const main$2 = async () => {
+const main$5 = async () => {
     if (!getEntry(import.meta.url)) {
         return;
     }
@@ -2306,7 +2325,7 @@ const main$2 = async () => {
     }
     listenGracefulShutdown();
 };
-main$2();
+main$5();
 
 const EXTRACT_ROWS_FN = (plots, schema) => {
     const keys = Object.keys(schema);
@@ -2328,7 +2347,7 @@ const EXTRACT_ROWS_FN = (plots, schema) => {
     }
     return rows;
 };
-const main$1 = async () => {
+const main$4 = async () => {
     if (!getEntry(import.meta.url)) {
         return;
     }
@@ -2381,6 +2400,7 @@ const main$1 = async () => {
         await mkdir(dumpDir, { recursive: true });
         await writeFile(filePath, JSON.stringify(rows, null, 2), "utf-8");
         console.log(`Saved: ${filePath}`);
+        process.exit(0);
         return;
     }
     if (values.jsonl) {
@@ -2389,6 +2409,7 @@ const main$1 = async () => {
         await mkdir(dumpDir, { recursive: true });
         await writeFile(filePath, rows.map((r) => JSON.stringify(r)).join("\n"), "utf-8");
         console.log(`Saved: ${filePath}`);
+        process.exit(0);
         return;
     }
     if (values.markdown) {
@@ -2396,13 +2417,15 @@ const main$1 = async () => {
         await mkdir(dumpDir, { recursive: true });
         await writeFile(filePath, await toMarkdown(signalId, plots, signalSchema), "utf-8");
         console.log(`Saved: ${filePath}`);
+        process.exit(0);
         return;
     }
     console.log(await toMarkdown(signalId, plots, signalSchema));
+    process.exit(0);
 };
-main$1();
+main$4();
 
-const main = async () => {
+const main$3 = async () => {
     if (!getEntry(import.meta.url)) {
         return;
     }
@@ -2436,6 +2459,7 @@ const main = async () => {
         await mkdir(dumpDir, { recursive: true });
         await writeFile(filePath, JSON.stringify(candles, null, 2), "utf-8");
         console.log(`Saved: ${filePath}`);
+        process.exit(0);
         return;
     }
     if (values.jsonl) {
@@ -2443,9 +2467,221 @@ const main = async () => {
         await mkdir(dumpDir, { recursive: true });
         await writeFile(filePath, candles.map((r) => JSON.stringify(r)).join("\n"), "utf-8");
         console.log(`Saved: ${filePath}`);
+        process.exit(0);
         return;
     }
     console.log(JSON.stringify(candles, null, 2));
+    process.exit(0);
+};
+main$3();
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const MUSTACHE_EXT = ".mustache";
+const MUSTACHE_RENAME = {
+    "gitignore": ".gitignore",
+    "package": "package.json",
+};
+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 === ".gitkeep") {
+            continue;
+        }
+        if (entry.name.endsWith(MUSTACHE_EXT)) {
+            const baseName = entry.name.slice(0, -MUSTACHE_EXT.length);
+            const destName = MUSTACHE_RENAME[baseName] ?? baseName;
+            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$2 = 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}`);
+    process.exit(0);
+};
+main$2();
+
+const HELP_TEXT = `
+@backtest-kit/cli
+
+Usage:
+  node index.mjs --<mode> [flags] [entry-point]
+
+Modes:
+
+  --backtest <entry>    Run strategy against historical candle data
+  --paper    <entry>    Paper trading (live prices, no real orders)
+  --live     <entry>    Live trading with real orders
+  --pine     <entry>    Execute a local .pine indicator file
+  --dump                Fetch and save raw OHLCV candles
+  --init                Scaffold a new project in the current directory
+  --help                Print this help message
+
+Backtest flags:
+
+  --symbol      <string>   Trading pair (default: BTCUSDT)
+  --strategy    <string>   Strategy name from addStrategySchema (default: first registered)
+  --exchange    <string>   Exchange name from addExchangeSchema (default: first registered)
+  --frame       <string>   Frame name from addFrameSchema (default: first registered)
+  --cacheInterval <string> Comma-separated intervals to pre-cache (default: "1m, 15m, 30m, 4h")
+  --noCache                Skip candle cache warming before the run
+  --verbose                Log every candle fetch to stdout
+  --ui                     Start web dashboard at http://localhost:60050
+  --telegram               Send trade notifications to Telegram
+
+Paper / Live flags:
+
+  --symbol    <string>   Trading pair (default: BTCUSDT)
+  --strategy  <string>   Strategy name (default: first registered)
+  --exchange  <string>   Exchange name (default: first registered)
+  --verbose              Log every candle fetch to stdout
+  --ui                   Start web dashboard
+  --telegram             Send Telegram notifications
+
+PineScript flags (--pine):
+
+  --symbol      <string>   Trading pair (default: BTCUSDT)
+  --timeframe   <string>   Candle interval (default: 15m)
+  --limit       <string>   Number of candles to fetch (default: 250)
+  --when        <string>   End date — ISO 8601 or Unix ms (default: now)
+  --exchange    <string>   Exchange name (default: first registered)
+  --output      <string>   Output file base name without extension
+  --json                   Save output as JSON array to <pine-dir>/dump/<output>.json
+  --jsonl                  Save output as JSONL to <pine-dir>/dump/<output>.jsonl
+  --markdown               Save output as Markdown table to <pine-dir>/dump/<output>.md
+
+  Only plot() calls with display=display.data_window produce output columns.
+  Module file ./modules/pine.module is loaded automatically if it exists.
+
+Candle dump flags (--dump):
+
+  --symbol      <string>   Trading pair (default: BTCUSDT)
+  --timeframe   <string>   Candle interval (default: 15m)
+  --limit       <string>   Number of candles (default: 250)
+  --when        <string>   End date — ISO 8601 or Unix ms (default: now)
+  --exchange    <string>   Exchange name (default: first registered)
+  --output      <string>   Output file base name (default: {SYMBOL}_{LIMIT}_{TIMEFRAME}_{TIMESTAMP})
+  --json                   Save as JSON array to ./dump/<output>.json
+  --jsonl                  Save as JSONL to ./dump/<output>.jsonl
+
+  Module file ./modules/dump.module is loaded automatically if it exists.
+
+Init flags (--init):
+
+  --output <string>   Target directory name (default: backtest-kit-project)
+
+  Scaffolds a project and runs scripts/fetch_docs.mjs to download library docs.
+
+Module hooks (loaded automatically by each mode):
+
+  modules/backtest.module   --backtest   Broker adapter for backtest
+  modules/paper.module      --paper      Broker adapter for paper trading
+  modules/live.module       --live       Broker adapter for live trading
+  modules/pine.module       --pine       Exchange schema for PineScript runs
+  modules/dump.module       --dump       Exchange schema for candle dumps
+
+  Extensions .ts, .mjs, .cjs are tried automatically. Missing module = soft warning.
+
+Environment variables:
+
+  CC_TELEGRAM_TOKEN    Telegram bot token (required for --telegram)
+  CC_TELEGRAM_CHANNEL  Telegram channel or chat ID (required for --telegram)
+  CC_WWWROOT_HOST      UI server bind address (default: 0.0.0.0)
+  CC_WWWROOT_PORT      UI server port (default: 60050)
+
+Examples:
+
+  node index.mjs --backtest ./content/feb_2026.strategy.ts
+  node index.mjs --backtest --symbol BTCUSDT --noCache --ui ./content/feb_2026.strategy.ts
+  node index.mjs --paper --symbol ETHUSDT ./content/feb_2026.strategy.ts
+  node index.mjs --live --ui --telegram ./content/feb_2026.strategy.ts
+  node index.mjs --pine ./math/feb_2026.pine --timeframe 15m --limit 500 --jsonl
+  node index.mjs --dump --symbol BTCUSDT --timeframe 15m --limit 500 --jsonl
+  node index.mjs --init --output my-trading-bot
+`.trimStart();
+const main$1 = async () => {
+    if (!getEntry(import.meta.url)) {
+        return;
+    }
+    const { values } = getArgs();
+    if (!values.help) {
+        return;
+    }
+    process.stdout.write(HELP_TEXT);
+    process.exit(0);
+};
+main$1();
+
+const main = async () => {
+    if (!getEntry(import.meta.url)) {
+        return;
+    }
+    const { values } = getArgs();
+    if (!values.version) {
+        return;
+    }
+    process.stdout.write(`@backtest-kit/cli ${"6.0.0"}\n`);
+    process.exit(0);
 };
 main();
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@backtest-kit/cli",
-  "version": "5.11.0",
+  "version": "6.0.0",
   "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.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/ui": "6.0.0",
+    "@backtest-kit/graph": "6.0.0",
+    "@backtest-kit/ollama": "6.0.0",
+    "@backtest-kit/pinets": "6.0.0",
+    "@backtest-kit/signals": "6.0.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.11.0",
+    "backtest-kit": "6.0.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.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",
+    "@backtest-kit/ui": "^6.0.0",
+    "@backtest-kit/graph": "^6.0.0",
+    "@backtest-kit/ollama": "^6.0.0",
+    "@backtest-kit/pinets": "^6.0.0",
+    "@backtest-kit/signals": "^6.0.0",
+    "backtest-kit": "^6.0.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.