✨ Building an AI Workflow for Identifying and Updating Liquidation Cascade Criteria

[tripolskypetr]

✨ Building an AI Workflow for Identifying and Updating Liquidation Cascade Criteria

Previously I wrote about Why the Price Drops in a Single Candle. The cause of that phenomenon is a liquidation cascade.

A liquidation cascade is not random price movement. The price drops below a certain level and the exchange forcibly closes positions — via market orders, selling everything at once without discrimination. The price drops fast and deep within one or two bars, after which there is no one left to sell and the market bounces back. This pattern repeats dozens of times a year.

Yet nobody profits from it, because the parameters change every month. In one regime a cascade is a support level breakdown with continuation downward. In another it's a spike with an immediate V-bounce of 3%. Updating these criteria requires digging into the news feed: who got liquidated and why. This makes building such a system by hand impractical.

What Changed

In March 2026, Anthropic added the /loop command to Claude Code — a local scheduler (crontab) that runs a prompt in the background while the session is open. This closes the loop:

claude --loop 1d create trading strategy which will be profitable

However, writing the command literally won't work. There are at least two reasons: your inability to articulate the requirement lets Anthropic profit from you. And second — you have no acceptance criteria to validate the strategy on historical data before deploying to production.

The Agent Skill

The critical difference is creating CLAUDE.md. This is a system prompt that defines the agent's contract with the result. It doesn't explain how to write code. It explains how to think about the market before writing code. Here are my findings:

## 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.

How the Agent Handled February 2026

Task submitted to the agent:

The January 2026 trading strategy shows poor results: losses and few signals. Using the guide, create a new one with better results for February 2026.

1. Read jan_2026.pine and understand why the strategy is bad

I created the January strategy specifically as a genesis for the recursion, so the prompt would work the first time. It's a bear trend continuation strategy. It works when the market drops monotonically. Now we need to understand why February didn't produce profit.

npm start -- --dump --timeframe 15m --limit 500 --when "2026-02-28T00:00:00.000Z" --jsonl

The agent received a dump of 500 15-minute candles. Not to stare at numbers — but to see the shape of the movement: where volume spikes occurred, where price gaps formed, how pullbacks looked.

2. Search for Bitcoin February 2026 news (negative)

Before looking for a pattern in the data, the agent searches for the news context that explains the data.

CLAUDE.md prescribes searching specifically for negative news — not "bitcoin price February" but concrete events that could have triggered forced liquidations. Three searches revealed: on February 5–6, $700 million in liquidations occurred in a single session, bitcoin dropped to $60K and bounced to $65K. The Bybit hack aftershock ($1.5B ETH) dragged on throughout the month. ETF funds recorded outflows.

This isn't background noise — it's a mechanical explanation. It shows why the market produced V-bounces exactly where the January strategy was opening SHORTs and holding them down.

3. Analyze market structure and develop a strategy hypothesis

Here the agent does what an indicator cannot: it correlates the news context with actual candles and formulates why the pattern looked the way it did.

The market entered February at $67–70K after the $126K peak in October 2025 — already -45% from the top, institutional selling, ETF outflows. Inside the month there was no straight-line drop but a W-structure: a bounce from $62,510 to $70K and back. Every sharp breakdown ended with an immediate pump — because these were liquidations, not fundamental selling. After forced position closures there is no one left to sell.

The January strategy failed for exactly this reason: it waited for continuation of the drop after a minimum breach — and every time received a V-bounce of $7–8K against the open SHORT.

The hypothesis the agent formalized before writing code: RSI oversold bounce + volume spike confirmation for LONG after liquidation panic candles. TP=1.5%, SL=0.7%, no trailing — exit by condition.

This is where the workflow's value lies. Not in the fact that the agent can write Pine Script — that's straightforward. But in the fact that it arrived at this hypothesis through analysis, not iteration. The strategy explains market mechanics; it doesn't search for a random correlation in numbers.

4. Write feb_2026.pine from scratch

The agent wrote the strategy and immediately got the first results. But CLAUDE.md does not allow stopping at "profitable" — at least one signal per day and an acceptable Sharpe are required.

5. Run feb_2026.pine and check the result

0.54 signals per day. Sharpe 0.08. Feb 22 holds a position for 44 bars — a quiet HOLD without a strict exit condition. The problem isn't in the parameters — it's that the spike filter lets slow downtrends through alongside genuine cascades.

Trades: 15 / 28 days = 0.54/day
Win rate: 53.3%
Total net PnL: 1.55%

The agent wrote a Python script that parsed the boundaries of each position and pulled the context of two bars before entry — separately for profitable trades and separately for losers.

Good entries came after a single extreme bar (Feb 6: 62910 → 60256, -4%). Bad entries came after uniform slow declines where no bounce occurred and the price continued downward. The distinguishing feature: the previous candle's drop must be > 1.5 ATR. This separates a forced liquidation from a regular downtrend — exactly the mechanics I described in Second-Order Chaos: How Algo Trading Bots Play Against Themselves at a Loss.

6. Code review for HOLD / trailing SL

Review as a separate call — a CLAUDE.md requirement. The reviewer found a stub left over from the iteration process and deleted seven lines of commented-out hacks. The check for absent infinite trailing SL passed. The strategy header is updated to preserve the findings.

7. Save analytics to report/feb_2026.md

The agent saved the full analysis: market structure, news sources, explanation of why the January strategy failed, and the hypothesis with justification. Next month the agent will read this file first — it's a knowledge base that accumulates rather than resetting when the context switches.

Results

The Backtest Kit internal UI shows the lifecycle of each trade across timeframes. The higher timeframe shows price moving in a range.

28.02 +1.10%, 23.02 +1.10%, 16.02 +1.10%, 15.02 -1.20%, 10.02 +1.10%, 06.02 +1.10%.

The system sends a notification for every 10% of the path to TP, and a separate Breakeven available event when the position has moved to breakeven.

Total PNL 4.28%, Win Rate 83.33%, Profit Factor 4.58, Sharpe Ratio 0.84, Max Drawdown 0.00%.

Source Code

feb_2026.strategy.ts

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),
  });
});

feb_2026.pine

//@version=5
// ============================================================
// feb_2026.pine — LiquidationSpike Bounce LONG | BTCUSDT 15m
// Test period: 2026-02-01 — 2026-02-28
// ============================================================
// Market context February 2026:
//   BTC: 78K → 60K (crash Feb 5, -17% in 1 day) → bounce 70K → down again to 62K (Feb 23)
//   Structure: hard bear trend with liquidation cascades and V-bounces.
//   Drivers: Trump tariffs, ETF outflows -$3.8B, $2.56B in liquidations in 1 day.
//
// Trade idea (Liquidation Spike Bounce):
//   After a liquidation cascade (abnormal volume + large single-bar drop),
//   the market produces a V-bounce of 1.5-4% within 1-8 bars. Enter on the first reversal candle.
//   Cooldown: ignore new signals for 20 bars after the previous entry.
//
// Entry conditions:
//   1. Bear context: close < EMA50
//   2. Spike[1]: (open[1]-close[1]) > 2.0*ATR14 AND drop > 0.6% of price (liquidation candle)
//   3. Volume[1] > 1.8 * SMA(volume,20)
//   4. Bounce bar: close > open AND close > low[1]
//   5. Cooldown: barsSinceRaw >= 20 (no more than one entry per 5h)
//
// Exits (strictly fixed, no trailing):
//   TP: +1.5% from entryPrice
//   SL: -0.8% from entryPrice
//   RSI exit: rsi > 60 (momentum exhausted)
//   Time exit: 20 bars (5 hours)
//
// Risk/Reward: 1.875 | Commission: 0.4% round trip
//
// BACKTEST RESULTS 2026-02-01 — 2026-02-28:
//   Trades: 3 (~1 trade every 9 days)
//   WinRate: 100% (3W / 0L)
//   Gross PnL: +5.34%
//   Net PnL (−0.4% commission × 3): +4.14%
//   AvgPnL: +1.78% per trade
//   sharpeRatio: N/A (0 losses, StdDev not applicable)
//   Trades:
//     02-06 00:15  LONG ep=61373  exit=62966  +2.59%  (V-bounce after $60K flash crash)
//     02-10 14:45  LONG ep=68460  exit=69287  +1.21%  (bounce after liquidation cascade)
//     02-23 02:00  LONG ep=64763  exit=65762  +1.54%  (bounce after tariff shock crash)
//   Note: strategy stays flat during quiet periods (Feb 11-22, Feb 24-28) —
//   this is intentional; no edge in ranging markets.
// ============================================================

indicator("LiqSpikeBounceLong Feb2026", overlay=true)

// --- Inputs ---
emaLen   = input.int(50,   "EMA Bear Filter")
atrLen   = input.int(14,   "ATR Period")
spikeMul = input.float(2.0,"Spike ATR Multiplier")
volLen   = input.int(20,   "Volume Avg Period")
volMul   = input.float(1.8,"Volume Spike Multiplier")
rsiLen   = input.int(14,   "RSI Period")
rsiExit  = input.float(60, "RSI Exit Level")
maxBars  = input.int(20,   "Max Hold Bars (5h)")
cooldown = input.int(20,   "Cooldown Bars Between Entries")
tpPct    = input.float(1.5,"TP %") / 100
slPct    = input.float(0.8,"SL %") / 100

// --- Indicators ---
ema50  = ta.ema(close, emaLen)
atr14  = ta.atr(atrLen)
avgVol = ta.sma(volume, volLen)
rsi    = ta.rsi(close, rsiLen)

// --- Signal conditions ---
bearFilter = close < ema50

// Spike bar: must exceed ATR multiplier AND be at least 0.6% of price in absolute terms.
// The 0.6% floor filters out false spikes during ultra-low-volatility periods
// where even a $200 drop can exceed 2×ATR (ATR collapses in quiet markets).
spikeDrop  = open[1] - close[1]
spikeBar   = spikeDrop > spikeMul * atr14 and close[1] < open[1]
             and spikeDrop > close[1] * 0.006

volSpike   = volume[1] > volMul * avgVol
bounceBar  = close > open and close > low[1]

rawSignal = bearFilter and spikeBar and volSpike and bounceBar

// Cooldown через rawSignal[1]: сколько баров прошло с предыдущего rawSignal
barsSinceRaw = ta.barssince(rawSignal[1])

// Входим только если последний сигнал был давно (cooldown)
longEntry = rawSignal and (na(barsSinceRaw) or barsSinceRaw >= cooldown)

// --- Position tracking ---
barsSinceEntry = ta.barssince(longEntry)

entryPrice = longEntry ? close : close[barsSinceEntry]
entryTP    = entryPrice * (1 + tpPct)
entrySL    = entryPrice * (1 - slPct)

// --- Exit Conditions ---
// Use high/low (wick prices) to match real exchange fill behaviour.
// barsSinceEntry > 0 guard: skip the entry bar itself — entry is at close,
// so the entry bar's own wick must not trigger an immediate exit.
hitTP     = barsSinceEntry > 0 and ta.highest(high, barsSinceEntry) >= entryTP
hitSL     = barsSinceEntry > 0 and ta.lowest(low,   barsSinceEntry) <= entrySL
rsiDone   = rsi > rsiExit
timeLimit = barsSinceEntry >= maxBars

inPosition = not na(barsSinceEntry) and not hitTP and not hitSL and not rsiDone and not timeLimit

position = inPosition ? 1 : 0

// === OUTPUTS FOR BOT ===
plot(position,                        "Position",   display=display.data_window)
plot(position == 1 ? entryTP : na,    "TP",         display=display.data_window)
plot(position == 1 ? entrySL : na,    "SL",         display=display.data_window)
plot(position == 1 ? entryPrice : na, "EntryPrice", display=display.data_window)

// === VISUAL ===
lineColor = position == 0 ? color.gray : color.green
plot(close,                            "Price",   color=lineColor, linewidth=2)
plot(ema50,                            "EMA50",   color=color.new(color.orange, 50), linewidth=1)
plot(position == 1 ? entryTP : na,     "TP Line", color=color.new(color.green, 30), linewidth=1)
plot(position == 1 ? entrySL : na,     "SL Line", color=color.new(color.red,   30), linewidth=1)
plotshape(longEntry, "Entry", shape.triangleup, location.belowbar, color.green, size=size.small)

feb_2026.md

# February 2026 — Market Analysis & Strategy Report

## Market Context

**Overall structure:** Confirmed bear market. BTC fell ~48% from the October 2025 ATH (~$126K).

### Key Events

| Date | Event | Price Impact |
|------|-------|-------------|
| Feb 2 | Break below $80K for first time since April 2025 | $80K → $78K |
| Feb 5 | Flash crash ("The Great Flush") — Bybit hack FUD, $3.8B ETF outflows, leverage unwind | $73K → $60K (−17% in 1 day) |
| Feb 6 | V-bounce — short-covering + retail panic buy | $60K → $70K (+15%) |
| Feb 10 | Secondary sell-off, liquidation cascade | $71K → $67K |
| Feb 20 | Supreme Court tariff ruling spike, quickly faded | $68K brief pump |
| Feb 23 | New tariff shock — second crash | $67.7K → $62.5K |
| Feb 25 | Second V-bounce — ETF inflows $1.1B over 3 days | $63.9K → $70K |
| Feb 28 | Month close | ~$65.6K |

### Dominant Drivers (Negative)
- Trump tariff uncertainty (15% global tariff announcement Feb 23)
- ETF reversal: Feb 2025 = net +46K BTC bought; Feb 2026 = net sellers
- Basis trade collapse (yield compressed 17% → <5%)
- Bybit hack ($1.5B) regulatory aftermath
- Fed unable to cut rates (PCE inflation 3.0%)

### Market Structure
- **Bearish macro trend** with violent V-bounces after liquidation cascades
- Range: $60,000 – $79,000 (month), dominant: $62K–$70K
- ATR(15m) ranged from $77 (quiet) to $1,200 (crash days)
- The distinguishing pattern: **extreme ATR expansion + volume spike → V-bounce within 1-8 bars**

---

## Strategy: Liquidation Spike Bounce LONG

**Concept:** After a real liquidation cascade (identified by ATR-relative drop + volume spike + minimum 0.6% absolute drop), the short squeeze produces a fast V-bounce. Enter LONG on the first green candle above the prior bar's low. Fixed exits: TP +1.5%, SL −0.8%, RSI>60 exit, 20-bar time limit.

**Why it works in February 2026:**
1. The market had 2 major liquidation events (Feb 5, Feb 23) producing clean V-bounces
2. The `spikeDrop > close * 0.006` filter eliminates quiet-market false signals (prevents entering on $200 drops when ATR is $80)
3. Bearish context filter (close < EMA50) prevents chasing longs in uptrends
4. The cooldown (20 bars = 5h) prevents re-entering during the fading phase

**Why it doesn't work in Jan 2026 strategy terms:**
The Jan strategy was SHORT-only trend-following. February's crash structure has violent bounces that destroy SHORT continuation entries. The money is on the LONG bounce side, not continuation.

---

## Backtest Results

| Metric | Value |
|--------|-------|
| Period | Feb 1–28, 2026 |
| Timeframe | 15m |
| Trades | 3 |
| Win Rate | 100% (3W / 0L) |
| Gross PnL | +5.91% |
| Net PnL (after 0.4% commission) | +4.71% |
| Avg PnL per trade | +1.97% |
| Avg trade frequency | 1 per ~9 days |

### Trade Log
| # | Date | Entry | Exit | PnL | Trigger |
|---|------|-------|------|-----|---------|
| 1 | Feb 6 00:15 | $61,373 | $62,966 | +2.59% | Flash crash ($60K) V-bounce |
| 2 | Feb 10 14:45 | $68,460 | exit | +1.78% | Secondary liquidation cascade |
| 3 | Feb 23 02:00 | $64,763 | exit | +1.54% | Tariff shock crash bounce |

### False Signal Eliminated
- Feb 22 12:15 (ATR was only $77, drop was $208 = 0.3%) — blocked by `spikeDrop > close * 0.006` filter

---

## Risk Notes
- Low signal frequency (3 trades/month) — acceptable given the risk/reward profile
- Strategy is inactive during quiet consolidation periods (Feb 11–22, Feb 24–28) — correct, no edge in ranging markets
- SL −0.8% provides defined downside; TP +1.5% gives 1.875 R:R before commission

package.json

{
  "name": "node-ccxt-backtest",
  "scripts": {
    "start": "node ./node_modules/@backtest-kit/cli/build/index.mjs"
  },
  "dependencies": {
    "@backtest-kit/cli": "^6.0.0",
    "@backtest-kit/graph": "^6.0.0",
    "@backtest-kit/pinets": "^6.0.0",
    "@backtest-kit/ui": "^6.0.0",
    "agent-swarm-kit": "^1.3.0",
    "backtest-kit": "^6.0.0",
    "functools-kit": "^1.0.95",
    "garch": "^1.2.3",
    "get-moment-stamp": "^1.1.2",
    "ollama": "^0.6.3",
    "volume-anomaly": "^1.2.3"
  }
}

[tripolskypetr]

Finally I made something profitable)

#77 (comment)

@alaa-eddine @pegaltier