@openfinclaw/fin-strategy-engine 0.0.1

package/src/builtin-strategies/risk-parity-triple-screen.test.ts

@@ -0,0 +1,295 @@
+import { describe, expect, it } from "vitest";
+import type { OHLCV } from "../../../fin-shared-types/src/types.js";
+import { BacktestEngine } from "../backtest-engine.js";
+import type { BacktestConfig } from "../types.js";
+import { createRiskParityTripleScreen } from "./risk-parity-triple-screen.js";
+
+function makeBar(index: number, close: number, overrides?: Partial<OHLCV>): OHLCV {
+  return {
+    timestamp: 1000000 + index * 86400000,
+    open: close,
+    high: close * 1.01,
+    low: close * 0.99,
+    close,
+    volume: 1000,
+    ...overrides,
+  };
+}
+
+const config: BacktestConfig = {
+  capital: 10000,
+  commissionRate: 0,
+  slippageBps: 0,
+  market: "crypto",
+};
+
+describe("Risk-Parity Triple Screen strategy", () => {
+  it("creates strategy with default parameters", () => {
+    const strategy = createRiskParityTripleScreen();
+    expect(strategy.id).toBe("risk-parity-triple-screen");
+    expect(strategy.name).toBe("Risk-Parity Triple Screen");
+    expect(strategy.version).toBe("1.0.0");
+    expect(strategy.markets).toEqual(["crypto", "equity"]);
+    expect(strategy.symbols).toEqual(["BTC/USDT"]);
+    expect(strategy.timeframes).toEqual(["1d"]);
+
+    // Verify all default parameter values
+    expect(strategy.parameters.tideFastEma).toBe(13);
+    expect(strategy.parameters.tideSlowEma).toBe(48);
+    expect(strategy.parameters.tideMacdFast).toBe(12);
+    expect(strategy.parameters.tideMacdSlow).toBe(26);
+    expect(strategy.parameters.tideMacdSignal).toBe(9);
+    expect(strategy.parameters.tideSma).toBe(50);
+    expect(strategy.parameters.tideSlopeLookback).toBe(5);
+    expect(strategy.parameters.waveRsiPeriod).toBe(14);
+    expect(strategy.parameters.waveRsiOversold).toBe(40);
+    expect(strategy.parameters.waveRsiEntry).toBe(50);
+    expect(strategy.parameters.rippleBbPeriod).toBe(20);
+    expect(strategy.parameters.rippleBbStdDev).toBe(2.0);
+    expect(strategy.parameters.atrPeriod).toBe(14);
+    expect(strategy.parameters.riskPctPerTrade).toBe(2.0);
+    expect(strategy.parameters.atrStopMultiplier).toBe(2.0);
+    expect(strategy.parameters.atrProfitMultiplier).toBe(3.5);
+    expect(strategy.parameters.maxSizePct).toBe(80);
+
+    // Verify parameterRanges exist
+    expect(strategy.parameterRanges).toBeDefined();
+    expect(strategy.parameterRanges!.tideFastEma).toEqual({ min: 5, max: 30, step: 1 });
+    expect(strategy.parameterRanges!.atrStopMultiplier).toEqual({ min: 1.0, max: 4.0, step: 0.5 });
+    expect(strategy.parameterRanges!.riskPctPerTrade).toEqual({ min: 0.5, max: 5.0, step: 0.5 });
+  });
+
+  it("creates strategy with custom parameters", () => {
+    const strategy = createRiskParityTripleScreen({
+      tideFastEma: 8,
+      tideSlowEma: 21,
+      tideMacdFast: 6,
+      tideMacdSlow: 18,
+      tideMacdSignal: 5,
+      tideSma: 30,
+      tideSlopeLookback: 3,
+      waveRsiPeriod: 10,
+      waveRsiOversold: 30,
+      waveRsiEntry: 45,
+      rippleBbPeriod: 15,
+      rippleBbStdDev: 1.5,
+      atrPeriod: 10,
+      riskPctPerTrade: 1.5,
+      atrStopMultiplier: 1.5,
+      atrProfitMultiplier: 4.0,
+      maxSizePct: 60,
+      symbol: "ETH/USDT",
+    });
+
+    expect(strategy.parameters.tideFastEma).toBe(8);
+    expect(strategy.parameters.tideSlowEma).toBe(21);
+    expect(strategy.parameters.tideMacdFast).toBe(6);
+    expect(strategy.parameters.tideMacdSlow).toBe(18);
+    expect(strategy.parameters.tideMacdSignal).toBe(5);
+    expect(strategy.parameters.tideSma).toBe(30);
+    expect(strategy.parameters.tideSlopeLookback).toBe(3);
+    expect(strategy.parameters.waveRsiPeriod).toBe(10);
+    expect(strategy.parameters.waveRsiOversold).toBe(30);
+    expect(strategy.parameters.waveRsiEntry).toBe(45);
+    expect(strategy.parameters.rippleBbPeriod).toBe(15);
+    expect(strategy.parameters.rippleBbStdDev).toBe(1.5);
+    expect(strategy.parameters.atrPeriod).toBe(10);
+    expect(strategy.parameters.riskPctPerTrade).toBe(1.5);
+    expect(strategy.parameters.atrStopMultiplier).toBe(1.5);
+    expect(strategy.parameters.atrProfitMultiplier).toBe(4.0);
+    expect(strategy.parameters.maxSizePct).toBe(60);
+    expect(strategy.symbols).toEqual(["ETH/USDT"]);
+  });
+
+  it("returns null during warm-up period", async () => {
+    // Only 10 bars — insufficient for SMA(50), EMA(48), MACD(12,26,9), RSI(14), BB(20), ATR(14)
+    const data: OHLCV[] = [];
+    for (let i = 0; i < 10; i++) {
+      data.push(makeBar(i, 100 + i));
+    }
+    const strategy = createRiskParityTripleScreen();
+
+    const engine = new BacktestEngine();
+    const result = await engine.run(strategy, data, config);
+
+    expect(result.totalTrades).toBe(0);
+  });
+
+  it("generates buy when all three screens pass", async () => {
+    // Test triple screen logic with mock IndicatorLib.
+    // Screen 1 (Tide): EMA(3) > EMA(5) + MACD hist > 0 + SMA(5) rising → score 3/3
+    // Screen 2 (Wave): previously oversold, now RSI > entry → passes
+    // Screen 3 (Ripple): close <= BBLower * 1.01 → passes
+    const strategy = createRiskParityTripleScreen({
+      tideFastEma: 3,
+      tideSlowEma: 5,
+      tideMacdFast: 3,
+      tideMacdSlow: 5,
+      tideMacdSignal: 2,
+      tideSma: 5,
+      tideSlopeLookback: 2,
+      waveRsiPeriod: 3,
+      waveRsiOversold: 35,
+      waveRsiEntry: 45,
+      rippleBbPeriod: 5,
+      rippleBbStdDev: 2,
+      atrPeriod: 3,
+      maxSizePct: 80,
+    });
+
+    const bar = makeBar(20, 100);
+    const memory = new Map<string, unknown>();
+    // Pre-set wave state: RSI was oversold on a previous bar
+    memory.set("waveWasOversold", true);
+
+    // Mock indicators satisfying all three screens:
+    const mockIndicators = {
+      ema: (period: number) => {
+        // tideFastEma(3): current = 102 (above tideSlowEma)
+        if (period === 3) return Array(20).fill(NaN).concat([101, 102]);
+        // tideSlowEma(5): current = 100
+        return Array(20).fill(NaN).concat([99, 100]);
+      },
+      macd: () => ({
+        macd: Array(21).fill(NaN).concat([0.5]),
+        signal: Array(21).fill(NaN).concat([0.2]),
+        histogram: Array(21).fill(NaN).concat([0.3]), // positive → tide point
+      }),
+      sma: () => {
+        // SMA(5): current at index 21 = 99, past (index 19) = 97 → rising
+        const arr = Array(19).fill(NaN);
+        arr.push(97, 98, 99); // indices 19, 20, 21
+        return arr;
+      },
+      rsi: () => Array(20).fill(NaN).concat([40, 50]), // prev=40, curr=50 > entry(45)
+      bollingerBands: () => ({
+        upper: Array(21).fill(NaN).concat([110]),
+        middle: Array(21).fill(NaN).concat([102]),
+        lower: Array(21).fill(NaN).concat([100]), // close(100) <= 100*1.01=101 → ripple passes
+      }),
+      atr: () => Array(20).fill(NaN).concat([1.5, 2]),
+    };
+
+    const ctx = {
+      portfolio: {
+        equity: 10000,
+        cash: 10000,
+        positions: [] as {
+          side: "long";
+          symbol: string;
+          quantity: number;
+          entryPrice: number;
+          currentPrice: number;
+          unrealizedPnl: number;
+        }[],
+      },
+      history: Array(22).fill(bar),
+      indicators: mockIndicators,
+      regime: "sideways" as const,
+      memory,
+      log: () => {},
+    };
+
+    const signal = await strategy.onBar(bar, ctx);
+
+    expect(signal).not.toBeNull();
+    expect(signal!.action).toBe("buy");
+    expect(signal!.stopLoss).toBeDefined();
+    expect(signal!.takeProfit).toBeDefined();
+    expect(signal!.confidence).toBeGreaterThanOrEqual(0.3);
+    expect(signal!.confidence).toBeLessThanOrEqual(0.95);
+    expect(signal!.sizePct).toBeGreaterThan(0);
+    expect(signal!.sizePct).toBeLessThanOrEqual(80);
+    // Wave consumed after buy
+    expect(memory.get("waveWasOversold")).toBe(false);
+    // Entry metadata stored
+    expect(memory.get("entryBar")).toBeDefined();
+    expect(memory.get("entryPrice")).toBe(100);
+  });
+
+  it("does not buy when tide is bearish", async () => {
+    // 20 bars falling steadily from 120 to 80 — EMA fast < slow, MACD negative,
+    // SMA declining. tideScore should stay < 2, blocking all buys.
+    const prices: number[] = [];
+    for (let i = 0; i < 20; i++) {
+      prices.push(120 - i * 2);
+    }
+
+    const data = prices.map((p, i) => makeBar(i, p));
+    const strategy = createRiskParityTripleScreen({
+      tideFastEma: 3,
+      tideSlowEma: 5,
+      tideMacdFast: 3,
+      tideMacdSlow: 5,
+      tideMacdSignal: 2,
+      tideSma: 5,
+      tideSlopeLookback: 2,
+      waveRsiPeriod: 3,
+      waveRsiOversold: 35,
+      waveRsiEntry: 45,
+      rippleBbPeriod: 5,
+      rippleBbStdDev: 2,
+      atrPeriod: 3,
+      maxSizePct: 80,
+    });
+
+    const engine = new BacktestEngine();
+    const result = await engine.run(strategy, data, config);
+
+    expect(result.totalTrades).toBe(0);
+  });
+
+  it("uses risk-parity sizing", async () => {
+    // Verify that the strategy uses ATR-based risk-parity sizing rather than
+    // always allocating maxSizePct. The sizePct should vary based on ATR/price.
+    const prices: number[] = [];
+
+    // Phase 1: uptrend to establish tide
+    for (let i = 0; i < 15; i++) {
+      prices.push(100 + i);
+    }
+
+    // Phase 2: pullback for wave oversold
+    const pullback = [113, 111, 109, 107, 106, 105, 104, 104];
+    prices.push(...pullback);
+
+    // Phase 3: near BB lower + wave recovery
+    prices.push(103, 104);
+
+    // Phase 4: recovery and exit
+    prices.push(106, 108, 110, 112, 114, 116, 118, 120);
+
+    const data = prices.map((p, i) => makeBar(i, p));
+    const strategy = createRiskParityTripleScreen({
+      tideFastEma: 3,
+      tideSlowEma: 5,
+      tideMacdFast: 3,
+      tideMacdSlow: 5,
+      tideMacdSignal: 2,
+      tideSma: 5,
+      tideSlopeLookback: 2,
+      waveRsiPeriod: 3,
+      waveRsiOversold: 35,
+      waveRsiEntry: 45,
+      rippleBbPeriod: 5,
+      rippleBbStdDev: 2,
+      atrPeriod: 3,
+      riskPctPerTrade: 2,
+      maxSizePct: 80,
+    });
+
+    const engine = new BacktestEngine();
+    const result = await engine.run(strategy, data, config);
+
+    // There should be at least one trade
+    if (result.trades.length > 0) {
+      const firstTrade = result.trades[0]!;
+      // Quantity should exist and be reasonable (not zero, not absurdly large)
+      expect(firstTrade.quantity).toBeGreaterThan(0);
+      // The position value should not consume the entire capital (risk-parity limits it)
+      const positionValue = firstTrade.quantity * firstTrade.entryPrice;
+      expect(positionValue).toBeLessThan(config.capital);
+      expect(positionValue).toBeGreaterThan(0);
+    }
+  });
+});

package/src/builtin-strategies/risk-parity-triple-screen.ts

@@ -0,0 +1,295 @@
+import type { OHLCV } from "../../../fin-shared-types/src/types.js";
+import type { Signal, StrategyContext, StrategyDefinition } from "../types.js";
+
+/**
+ * Risk-Parity Triple Screen composite strategy.
+ *
+ * Applies Alexander Elder's Triple Screen method with risk-parity position sizing:
+ *
+ * Screen 1 (Tide): Long-term trend scored 0-3 via EMA crossover, MACD histogram,
+ *   and SMA slope. Requires score >= 2 to pass.
+ * Screen 2 (Wave): Medium-term pullback state machine — RSI must first dip below
+ *   oversold threshold, then recover above entry level to confirm a reversal.
+ * Screen 3 (Ripple): Short-term entry timing — price must be near the lower
+ *   Bollinger Band (within 1% tolerance).
+ *
+ * Position sizing uses ATR-based risk parity: risk a fixed percentage of equity
+ * per trade, with stop distance derived from ATR.
+ *
+ * Sell when: tide flips bearish, price touches upper BB, RSI overbought & reversing,
+ * or time stop (20 bars) is hit.
+ */
+export function createRiskParityTripleScreen(params?: {
+  tideFastEma?: number;
+  tideSlowEma?: number;
+  tideMacdFast?: number;
+  tideMacdSlow?: number;
+  tideMacdSignal?: number;
+  tideSma?: number;
+  tideSlopeLookback?: number;
+  waveRsiPeriod?: number;
+  waveRsiOversold?: number;
+  waveRsiEntry?: number;
+  rippleBbPeriod?: number;
+  rippleBbStdDev?: number;
+  atrPeriod?: number;
+  riskPctPerTrade?: number;
+  atrStopMultiplier?: number;
+  atrProfitMultiplier?: number;
+  maxSizePct?: number;
+  symbol?: string;
+}): StrategyDefinition {
+  const tideFastEma = params?.tideFastEma ?? 13;
+  const tideSlowEma = params?.tideSlowEma ?? 48;
+  const tideMacdFast = params?.tideMacdFast ?? 12;
+  const tideMacdSlow = params?.tideMacdSlow ?? 26;
+  const tideMacdSignal = params?.tideMacdSignal ?? 9;
+  const tideSma = params?.tideSma ?? 50;
+  const tideSlopeLookback = params?.tideSlopeLookback ?? 5;
+  const waveRsiPeriod = params?.waveRsiPeriod ?? 14;
+  const waveRsiOversold = params?.waveRsiOversold ?? 40;
+  const waveRsiEntry = params?.waveRsiEntry ?? 50;
+  const rippleBbPeriod = params?.rippleBbPeriod ?? 20;
+  const rippleBbStdDev = params?.rippleBbStdDev ?? 2.0;
+  const atrPeriod = params?.atrPeriod ?? 14;
+  const riskPctPerTrade = params?.riskPctPerTrade ?? 2.0;
+  const atrStopMultiplier = params?.atrStopMultiplier ?? 2.0;
+  const atrProfitMultiplier = params?.atrProfitMultiplier ?? 3.5;
+  const maxSizePct = params?.maxSizePct ?? 80;
+  const symbol = params?.symbol ?? "BTC/USDT";
+
+  return {
+    id: "risk-parity-triple-screen",
+    name: "Risk-Parity Triple Screen",
+    version: "1.0.0",
+    markets: ["crypto", "equity"],
+    symbols: [symbol],
+    timeframes: ["1d"],
+    parameters: {
+      tideFastEma,
+      tideSlowEma,
+      tideMacdFast,
+      tideMacdSlow,
+      tideMacdSignal,
+      tideSma,
+      tideSlopeLookback,
+      waveRsiPeriod,
+      waveRsiOversold,
+      waveRsiEntry,
+      rippleBbPeriod,
+      rippleBbStdDev,
+      atrPeriod,
+      riskPctPerTrade,
+      atrStopMultiplier,
+      atrProfitMultiplier,
+      maxSizePct,
+    },
+    parameterRanges: {
+      tideFastEma: { min: 5, max: 30, step: 1 },
+      tideSlowEma: { min: 20, max: 100, step: 2 },
+      tideMacdFast: { min: 8, max: 20, step: 2 },
+      tideMacdSlow: { min: 20, max: 40, step: 2 },
+      tideMacdSignal: { min: 5, max: 15, step: 1 },
+      tideSma: { min: 20, max: 100, step: 5 },
+      tideSlopeLookback: { min: 3, max: 10, step: 1 },
+      waveRsiPeriod: { min: 5, max: 28, step: 1 },
+      waveRsiOversold: { min: 25, max: 45, step: 5 },
+      waveRsiEntry: { min: 40, max: 60, step: 5 },
+      rippleBbPeriod: { min: 10, max: 40, step: 5 },
+      rippleBbStdDev: { min: 1.0, max: 3.0, step: 0.25 },
+      atrPeriod: { min: 7, max: 28, step: 1 },
+      riskPctPerTrade: { min: 0.5, max: 5.0, step: 0.5 },
+      atrStopMultiplier: { min: 1.0, max: 4.0, step: 0.5 },
+      atrProfitMultiplier: { min: 2.0, max: 6.0, step: 0.5 },
+      maxSizePct: { min: 20, max: 100, step: 10 },
+    },
+
+    async onBar(bar: OHLCV, ctx: StrategyContext): Promise<Signal | null> {
+      // 1. Compute all indicators
+      const tideFastEmaArr = ctx.indicators.ema(tideFastEma);
+      const tideSlowEmaArr = ctx.indicators.ema(tideSlowEma);
+      const { histogram: macdHistogram } = ctx.indicators.macd(
+        tideMacdFast,
+        tideMacdSlow,
+        tideMacdSignal,
+      );
+      const sma50Arr = ctx.indicators.sma(tideSma);
+      const rsiArr = ctx.indicators.rsi(waveRsiPeriod);
+      const bb = ctx.indicators.bollingerBands(rippleBbPeriod, rippleBbStdDev);
+      const atrArr = ctx.indicators.atr(atrPeriod);
+
+      const len = tideFastEmaArr.length;
+      if (len < 2) return null;
+
+      const currTideFastEma = tideFastEmaArr[len - 1]!;
+      const currTideSlowEma = tideSlowEmaArr[len - 1]!;
+      const currMacdHistogram = macdHistogram[len - 1]!;
+      const currSma50 = sma50Arr[len - 1]!;
+      const currRsi = rsiArr[len - 1]!;
+      const prevRsi = rsiArr[len - 2]!;
+      const currBBUpper = bb.upper[len - 1]!;
+      const currBBLower = bb.lower[len - 1]!;
+      const currAtr = atrArr[len - 1]!;
+
+      // SMA value from tideSlopeLookback bars ago
+      const slopeLookbackIdx = len - 1 - tideSlopeLookback;
+      const pastSma50 = slopeLookbackIdx >= 0 ? sma50Arr[slopeLookbackIdx]! : NaN;
+
+      // 2. NaN guard
+      if (
+        Number.isNaN(currTideFastEma) ||
+        Number.isNaN(currTideSlowEma) ||
+        Number.isNaN(currMacdHistogram) ||
+        Number.isNaN(currSma50) ||
+        Number.isNaN(pastSma50) ||
+        Number.isNaN(currRsi) ||
+        Number.isNaN(prevRsi) ||
+        Number.isNaN(currBBUpper) ||
+        Number.isNaN(currBBLower) ||
+        Number.isNaN(currAtr)
+      ) {
+        return null;
+      }
+
+      // 3. Regime filter
+      if (ctx.regime === "crisis") return null;
+
+      // 4. Position check
+      const hasLong = ctx.portfolio.positions.some((p) => p.side === "long");
+
+      // 5. Screen 1: Tide (long-term trend, scored 0-3)
+      const emaBullish = currTideFastEma > currTideSlowEma;
+      const macdPositive = currMacdHistogram > 0;
+      const smaSloping = currSma50 > pastSma50;
+
+      const tideScore = (emaBullish ? 1 : 0) + (macdPositive ? 1 : 0) + (smaSloping ? 1 : 0);
+      const tidePassed = tideScore >= 2;
+
+      // 6. Screen 2: Wave (medium-term pullback state machine)
+      let waveWasOversold = (ctx.memory.get("waveWasOversold") as boolean) ?? false;
+
+      if (currRsi < waveRsiOversold) {
+        waveWasOversold = true;
+      }
+      ctx.memory.set("waveWasOversold", waveWasOversold);
+
+      const wavePassed = waveWasOversold && currRsi > waveRsiEntry;
+
+      // If wave passed, consume the signal (reset state)
+      if (wavePassed) {
+        ctx.memory.set("waveWasOversold", false);
+      }
+
+      // 7. Screen 3: Ripple (short-term entry timing — near lower BB)
+      const ripplePassed = bar.close <= currBBLower * 1.01;
+
+      // 8. BUY conditions
+      if (!hasLong && tidePassed && wavePassed && ripplePassed) {
+        // Risk-parity position sizing
+        const stopDistance = atrStopMultiplier * currAtr;
+        const riskAmount = ctx.portfolio.equity * (riskPctPerTrade / 100);
+        const sharesFromRisk = riskAmount / stopDistance;
+        const positionValue = sharesFromRisk * bar.close;
+        const sizePct = Math.min(
+          maxSizePct,
+          Math.max(10, (positionValue / ctx.portfolio.equity) * 100),
+        );
+
+        // Confidence: base 0.4, plus component bonuses
+        const confidence = Math.min(
+          0.95,
+          Math.max(0.3, 0.4 + 0.1 * tideScore + (wavePassed ? 0.15 : 0) + (ripplePassed ? 0.1 : 0)),
+        );
+
+        const stopLoss = bar.close - stopDistance;
+        const takeProfit = bar.close + atrProfitMultiplier * currAtr;
+
+        // Store entry metadata in memory
+        ctx.memory.set("screens", {
+          tide: tideScore,
+          wave: true,
+          ripple: true,
+        });
+        ctx.memory.set("entryBar", ctx.history.length);
+        ctx.memory.set("entryPrice", bar.close);
+
+        return {
+          action: "buy",
+          symbol,
+          sizePct,
+          orderType: "market",
+          reason: `Triple Screen buy: tide=${tideScore}/3, wave=oversold-recovery, ripple=near-BB-lower (close=${bar.close.toFixed(2)}, BBL=${currBBLower.toFixed(2)})`,
+          confidence,
+          stopLoss,
+          takeProfit,
+        };
+      }
+
+      // 9. SELL conditions
+      if (hasLong) {
+        // Tide flips bearish
+        if (tideScore < 2) {
+          ctx.memory.delete("screens");
+          ctx.memory.delete("entryBar");
+          ctx.memory.delete("entryPrice");
+          return {
+            action: "sell",
+            symbol,
+            sizePct: 100,
+            orderType: "market",
+            reason: `Tide bearish: tideScore=${tideScore} < 2`,
+            confidence: 0.7,
+          };
+        }
+
+        // BB upper touch
+        if (bar.close >= currBBUpper) {
+          ctx.memory.delete("screens");
+          ctx.memory.delete("entryBar");
+          ctx.memory.delete("entryPrice");
+          return {
+            action: "sell",
+            symbol,
+            sizePct: 100,
+            orderType: "market",
+            reason: `BB upper touch: close=${bar.close.toFixed(2)} >= BBU=${currBBUpper.toFixed(2)}`,
+            confidence: 0.75,
+          };
+        }
+
+        // RSI extreme + reversal
+        if (currRsi > 80 && currRsi < prevRsi) {
+          ctx.memory.delete("screens");
+          ctx.memory.delete("entryBar");
+          ctx.memory.delete("entryPrice");
+          return {
+            action: "sell",
+            symbol,
+            sizePct: 100,
+            orderType: "market",
+            reason: `RSI overbought reversal: RSI=${currRsi.toFixed(1)} > 80 and declining`,
+            confidence: 0.7,
+          };
+        }
+
+        // Time stop
+        const entryBar = ctx.memory.get("entryBar") as number | undefined;
+        if (entryBar !== undefined && ctx.history.length - entryBar > 20) {
+          ctx.memory.delete("screens");
+          ctx.memory.delete("entryBar");
+          ctx.memory.delete("entryPrice");
+          return {
+            action: "sell",
+            symbol,
+            sizePct: 100,
+            orderType: "market",
+            reason: `Time stop: held ${ctx.history.length - entryBar} bars > 20 limit`,
+            confidence: 0.6,
+          };
+        }
+      }
+
+      return null;
+    },
+  };
+}