@openfinclaw/fin-strategy-engine 0.0.1

package/src/builtin-strategies/trend-following-momentum.ts

@@ -0,0 +1,209 @@
+import type { OHLCV } from "../../../fin-shared-types/src/types.js";
+import type { Signal, StrategyContext, StrategyDefinition } from "../types.js";
+
+/**
+ * Trend-Following Momentum composite strategy.
+ * Combines EMA crossover, MACD histogram confirmation, RSI filter,
+ * and ATR-based dynamic stop-loss / take-profit with trailing stop.
+ *
+ * Buy when: EMA golden cross + MACD histogram rising & positive + RSI not overbought.
+ * Sell when: EMA death cross OR MACD histogram turns negative OR trailing stop hit.
+ */
+export function createTrendFollowingMomentum(params?: {
+  fastEma?: number;
+  slowEma?: number;
+  macdFast?: number;
+  macdSlow?: number;
+  macdSignal?: number;
+  rsiPeriod?: number;
+  rsiOverbought?: number;
+  atrPeriod?: number;
+  atrStopMultiplier?: number;
+  atrProfitMultiplier?: number;
+  maxSizePct?: number;
+  symbol?: string;
+}): StrategyDefinition {
+  const fastEma = params?.fastEma ?? 12;
+  const slowEma = params?.slowEma ?? 26;
+  const macdFast = params?.macdFast ?? 12;
+  const macdSlow = params?.macdSlow ?? 26;
+  const macdSignal = params?.macdSignal ?? 9;
+  const rsiPeriod = params?.rsiPeriod ?? 14;
+  const rsiOverbought = params?.rsiOverbought ?? 75;
+  const atrPeriod = params?.atrPeriod ?? 14;
+  const atrStopMultiplier = params?.atrStopMultiplier ?? 2.0;
+  const atrProfitMultiplier = params?.atrProfitMultiplier ?? 3.0;
+  const maxSizePct = params?.maxSizePct ?? 80;
+  const symbol = params?.symbol ?? "BTC/USDT";
+
+  return {
+    id: "trend-following-momentum",
+    name: "Trend-Following Momentum",
+    version: "1.0.0",
+    markets: ["crypto", "equity"],
+    symbols: [symbol],
+    timeframes: ["1d"],
+    parameters: {
+      fastEma,
+      slowEma,
+      macdFast,
+      macdSlow,
+      macdSignal,
+      rsiPeriod,
+      rsiOverbought,
+      atrPeriod,
+      atrStopMultiplier,
+      atrProfitMultiplier,
+      maxSizePct,
+    },
+    parameterRanges: {
+      fastEma: { min: 5, max: 50, step: 1 },
+      slowEma: { min: 10, max: 100, step: 2 },
+      macdFast: { min: 8, max: 20, step: 2 },
+      macdSlow: { min: 20, max: 40, step: 2 },
+      macdSignal: { min: 5, max: 15, step: 1 },
+      rsiPeriod: { min: 7, max: 28, step: 1 },
+      rsiOverbought: { min: 65, max: 85, step: 5 },
+      atrPeriod: { min: 7, max: 28, step: 1 },
+      atrStopMultiplier: { min: 1.0, max: 4.0, step: 0.5 },
+      atrProfitMultiplier: { min: 1.5, max: 6.0, step: 0.5 },
+      maxSizePct: { min: 20, max: 100, step: 10 },
+    },
+
+    async onBar(bar: OHLCV, ctx: StrategyContext): Promise<Signal | null> {
+      // Compute indicators
+      const fastEmaArr = ctx.indicators.ema(fastEma);
+      const slowEmaArr = ctx.indicators.ema(slowEma);
+      const { histogram } = ctx.indicators.macd(macdFast, macdSlow, macdSignal);
+      const rsiArr = ctx.indicators.rsi(rsiPeriod);
+      const atrArr = ctx.indicators.atr(atrPeriod);
+
+      const len = fastEmaArr.length;
+      if (len < 2) return null;
+
+      const currFast = fastEmaArr[len - 1]!;
+      const currSlow = slowEmaArr[len - 1]!;
+      const prevFast = fastEmaArr[len - 2]!;
+      const prevSlow = slowEmaArr[len - 2]!;
+      const currHist = histogram[len - 1]!;
+      const prevHist = histogram[len - 2]!;
+      const currRsi = rsiArr[len - 1]!;
+      const currAtr = atrArr[len - 1]!;
+      const prevClose =
+        ctx.history.length >= 2 ? ctx.history[ctx.history.length - 2]!.close : bar.close;
+
+      // Skip if any indicator value is NaN (warm-up period)
+      if (
+        Number.isNaN(currFast) ||
+        Number.isNaN(currSlow) ||
+        Number.isNaN(prevFast) ||
+        Number.isNaN(prevSlow) ||
+        Number.isNaN(currHist) ||
+        Number.isNaN(prevHist) ||
+        Number.isNaN(currRsi) ||
+        Number.isNaN(currAtr)
+      ) {
+        return null;
+      }
+
+      // Skip during crisis regime
+      if (ctx.regime === "crisis") return null;
+
+      const hasLong = ctx.portfolio.positions.some((p) => p.side === "long");
+
+      // --- SELL conditions (check first so trailing stop updates every bar) ---
+      if (hasLong) {
+        // Update trailing stop
+        const storedStop = ctx.memory.get("trailingStop") as number | undefined;
+        if (storedStop !== undefined) {
+          const newStop = Math.max(storedStop, bar.close - atrStopMultiplier * currAtr);
+          ctx.memory.set("trailingStop", newStop);
+
+          // Trailing stop hit
+          if (bar.close < newStop) {
+            ctx.memory.delete("trailingStop");
+            ctx.memory.delete("entryAtr");
+            return {
+              action: "sell",
+              symbol,
+              sizePct: 100,
+              orderType: "market",
+              reason: `Trailing stop hit: close=${bar.close.toFixed(2)} < stop=${newStop.toFixed(2)}`,
+              confidence: 0.8,
+            };
+          }
+        }
+
+        // EMA death cross
+        if (prevFast >= prevSlow && currFast < currSlow) {
+          ctx.memory.delete("trailingStop");
+          ctx.memory.delete("entryAtr");
+          return {
+            action: "sell",
+            symbol,
+            sizePct: 100,
+            orderType: "market",
+            reason: `EMA death cross: fast(${fastEma})=${currFast.toFixed(2)} < slow(${slowEma})=${currSlow.toFixed(2)}`,
+            confidence: 0.7,
+          };
+        }
+
+        // MACD histogram turns negative
+        if (currHist < 0) {
+          ctx.memory.delete("trailingStop");
+          ctx.memory.delete("entryAtr");
+          return {
+            action: "sell",
+            symbol,
+            sizePct: 100,
+            orderType: "market",
+            reason: `MACD histogram negative: ${currHist.toFixed(4)}`,
+            confidence: 0.6,
+          };
+        }
+      }
+
+      // --- BUY conditions (all must be true) ---
+      if (!hasLong) {
+        const goldenCross = prevFast <= prevSlow && currFast > currSlow;
+        const macdRising = currHist > 0 && currHist > prevHist;
+        const rsiNotOverbought = currRsi < rsiOverbought;
+
+        if (goldenCross && macdRising && rsiNotOverbought) {
+          // Compute confidence components
+          const histStrength = Math.min((Math.abs(currHist) / prevClose) * 1000, 1);
+          const rsiScore = 1 - currRsi / 100;
+          const emaSepScore = Math.min((Math.abs(currFast - currSlow) / prevClose) * 100, 1);
+          const confidence = Math.max(
+            0.3,
+            Math.min(0.95, 0.5 + 0.15 * histStrength + 0.1 * rsiScore + 0.1 * emaSepScore),
+          );
+
+          // ATR-based stop-loss and take-profit
+          const stopLoss = bar.close - atrStopMultiplier * currAtr;
+          const takeProfit = bar.close + atrProfitMultiplier * currAtr;
+
+          // Store trailing stop and entry ATR in memory
+          ctx.memory.set("trailingStop", stopLoss);
+          ctx.memory.set("entryAtr", currAtr);
+
+          // Dynamic position sizing
+          const sizePct = Math.min(maxSizePct, Math.max(20, confidence * 100));
+
+          return {
+            action: "buy",
+            symbol,
+            sizePct,
+            orderType: "market",
+            reason: `Trend-following buy: EMA golden cross + MACD histogram rising (${currHist.toFixed(4)}) + RSI=${currRsi.toFixed(1)}`,
+            confidence,
+            stopLoss,
+            takeProfit,
+          };
+        }
+      }
+
+      return null;
+    },
+  };
+}

package/src/builtin-strategies/volatility-mean-reversion.test.ts

@@ -0,0 +1,193 @@
+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 { createVolatilityMeanReversion } from "./volatility-mean-reversion.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",
+};
+
+/**
+ * Helper: generates a base oscillation of 25 bars around 100 using sin wave,
+ * which establishes BB width with bbPeriod=20. The resulting BB lower is ~95.
+ * A sudden crash below 88 will breach the lower band. After a 2-bar crash
+ * and a micro-bounce, RSI(3) turns up while still oversold and price stays
+ * below the slowly-adapting BB lower band.
+ */
+function generateOscillatingBase(): number[] {
+  const prices: number[] = [];
+  for (let i = 0; i < 25; i++) {
+    prices.push(100 + 3 * Math.sin(i * 0.5));
+  }
+  return prices;
+}
+
+/** Strategy params tuned for test data: bbPeriod=20 for slow BB adaptation. */
+const testParams = {
+  bbPeriod: 20,
+  rsiPeriod: 3,
+  atrPeriod: 3,
+  trendFilterPeriod: 5,
+  useTrendFilter: 0,
+  maxAtrPctFilter: 10.0,
+};
+
+describe("Volatility Mean Reversion strategy", () => {
+  it("creates strategy with default parameters", () => {
+    const strategy = createVolatilityMeanReversion();
+    expect(strategy.id).toBe("volatility-mean-reversion");
+    expect(strategy.name).toBe("Volatility Mean Reversion");
+    expect(strategy.version).toBe("1.0.0");
+    expect(strategy.parameters.bbPeriod).toBe(20);
+    expect(strategy.parameters.bbStdDev).toBe(2.0);
+    expect(strategy.parameters.rsiPeriod).toBe(7);
+    expect(strategy.parameters.rsiOversold).toBe(25);
+    expect(strategy.parameters.rsiOverbought).toBe(75);
+    expect(strategy.parameters.atrPeriod).toBe(14);
+    expect(strategy.parameters.atrStopMultiplier).toBe(1.5);
+    expect(strategy.parameters.trendFilterPeriod).toBe(200);
+    expect(strategy.parameters.useTrendFilter).toBe(1);
+    expect(strategy.parameters.maxSizePct).toBe(60);
+    expect(strategy.parameters.maxAtrPctFilter).toBe(5.0);
+  });
+
+  it("creates strategy with custom parameters", () => {
+    const strategy = createVolatilityMeanReversion({
+      bbPeriod: 15,
+      rsiPeriod: 5,
+      rsiOversold: 20,
+      rsiOverbought: 80,
+      atrPeriod: 10,
+      atrStopMultiplier: 2.0,
+      trendFilterPeriod: 100,
+      useTrendFilter: 0,
+      maxSizePct: 40,
+      maxAtrPctFilter: 3.0,
+      symbol: "ETH/USDT",
+    });
+    expect(strategy.parameters.bbPeriod).toBe(15);
+    expect(strategy.parameters.rsiPeriod).toBe(5);
+    expect(strategy.parameters.rsiOversold).toBe(20);
+    expect(strategy.parameters.rsiOverbought).toBe(80);
+    expect(strategy.parameters.atrPeriod).toBe(10);
+    expect(strategy.parameters.atrStopMultiplier).toBe(2.0);
+    expect(strategy.parameters.trendFilterPeriod).toBe(100);
+    expect(strategy.parameters.useTrendFilter).toBe(0);
+    expect(strategy.parameters.maxSizePct).toBe(40);
+    expect(strategy.parameters.maxAtrPctFilter).toBe(3.0);
+    expect(strategy.symbols).toEqual(["ETH/USDT"]);
+  });
+
+  it("returns null during warm-up period", async () => {
+    // Only 5 bars — not enough for BB(20) or RSI(3)+ATR(3) to all converge
+    const data = [makeBar(0, 100), makeBar(1, 101), makeBar(2, 99), makeBar(3, 98), makeBar(4, 97)];
+    const strategy = createVolatilityMeanReversion(testParams);
+
+    const engine = new BacktestEngine();
+    const result = await engine.run(strategy, data, config);
+
+    expect(result.totalTrades).toBe(0);
+  });
+
+  it("buys on BB lower touch with RSI oversold confirmation", async () => {
+    // 25-bar sin-wave oscillation establishes BB width (~95-105 bands with bbPeriod=20).
+    // 2-bar crash (88, 84) breaches the lower band. Micro-bounce to 85 triggers RSI
+    // turning up while still oversold and price still below the slowly-adapting BB lower.
+    const prices = generateOscillatingBase();
+    // Bars 25-26: sharp crash below BB lower
+    prices.push(88, 84);
+    // Bar 27: micro-bounce — RSI turns up, still oversold, still below BB lower
+    prices.push(85);
+    // Bars 28-37: recovery through BB middle and beyond
+    prices.push(88, 92, 96, 99, 101, 103, 105, 106, 107, 108);
+
+    const data = prices.map((p, i) => makeBar(i, p));
+    const strategy = createVolatilityMeanReversion(testParams);
+
+    const engine = new BacktestEngine();
+    const result = await engine.run(strategy, data, config);
+
+    // The crash + bounce should trigger at least one buy
+    expect(result.totalTrades).toBeGreaterThanOrEqual(1);
+    // Entry should be during the crash phase (price < 90)
+    if (result.trades.length > 0) {
+      expect(result.trades[0]!.entryPrice).toBeLessThan(90);
+    }
+  });
+
+  it("sells when price reverts to BB middle", async () => {
+    // Same crash setup, but focus on verifying the exit at BB middle
+    const prices = generateOscillatingBase();
+    // Crash + bounce to trigger entry
+    prices.push(88, 84, 85);
+    // Recovery that crosses BB middle (around 96-97 after crash)
+    prices.push(88, 92, 96, 99, 101, 103, 105, 106, 107, 108);
+
+    const data = prices.map((p, i) => makeBar(i, p));
+    const strategy = createVolatilityMeanReversion(testParams);
+
+    const engine = new BacktestEngine();
+    const result = await engine.run(strategy, data, config);
+
+    // Should have at least one completed trade
+    expect(result.totalTrades).toBeGreaterThanOrEqual(1);
+
+    if (result.trades.length > 0) {
+      const firstTrade = result.trades[0]!;
+      // Exit should be due to mean reversion (price reaching BB middle)
+      // or end-of-backtest or time stop (acceptable alternative exits)
+      const validExitReason =
+        firstTrade.exitReason.includes("Mean reversion target") ||
+        firstTrade.exitReason.includes("RSI overbought") ||
+        firstTrade.exitReason === "end-of-backtest" ||
+        firstTrade.exitReason.includes("Time stop");
+      expect(validExitReason).toBe(true);
+      // Entry was during the dip
+      expect(firstTrade.entryPrice).toBeLessThan(90);
+    }
+  });
+
+  it("respects time stop after 10 bars holding", async () => {
+    // Same crash setup to trigger entry, but then price stays flat below BB middle
+    // for > 10 bars so the time stop fires.
+    const prices = generateOscillatingBase();
+    // Crash + bounce to trigger entry
+    prices.push(88, 84, 85);
+    // Stay flat well below BB middle (~96) for 20 bars — never reaches BB middle
+    for (let i = 0; i < 20; i++) {
+      // Oscillate between 85-86 to avoid RSI overbought exit
+      prices.push(85 + (i % 2));
+    }
+
+    const data = prices.map((p, i) => makeBar(i, p));
+    const strategy = createVolatilityMeanReversion(testParams);
+
+    const engine = new BacktestEngine();
+    const result = await engine.run(strategy, data, config);
+
+    // Should have at least one trade
+    expect(result.totalTrades).toBeGreaterThanOrEqual(1);
+
+    // At least one trade should have exited via time stop or end-of-backtest
+    const hasTimeStopOrForceExit = result.trades.some(
+      (t) => t.exitReason.includes("Time stop") || t.exitReason === "end-of-backtest",
+    );
+    expect(hasTimeStopOrForceExit).toBe(true);
+  });
+});

package/src/builtin-strategies/volatility-mean-reversion.ts

@@ -0,0 +1,212 @@
+import type { OHLCV } from "../../../fin-shared-types/src/types.js";
+import type { Signal, StrategyContext, StrategyDefinition } from "../types.js";
+
+/**
+ * Volatility Mean Reversion strategy.
+ * Enters long when price drops below Bollinger Band lower with RSI oversold confirmation
+ * and RSI turning up. Exits when price reverts to BB middle, RSI becomes overbought,
+ * or a time stop (10 bars) is triggered.
+ */
+export function createVolatilityMeanReversion(params?: {
+  bbPeriod?: number;
+  bbStdDev?: number;
+  rsiPeriod?: number;
+  rsiOversold?: number;
+  rsiOverbought?: number;
+  atrPeriod?: number;
+  atrStopMultiplier?: number;
+  trendFilterPeriod?: number;
+  useTrendFilter?: number;
+  maxSizePct?: number;
+  maxAtrPctFilter?: number;
+  symbol?: string;
+}): StrategyDefinition {
+  const bbPeriod = params?.bbPeriod ?? 20;
+  const bbStdDev = params?.bbStdDev ?? 2.0;
+  const rsiPeriod = params?.rsiPeriod ?? 7;
+  const rsiOversold = params?.rsiOversold ?? 25;
+  const rsiOverbought = params?.rsiOverbought ?? 75;
+  const atrPeriod = params?.atrPeriod ?? 14;
+  const atrStopMultiplier = params?.atrStopMultiplier ?? 1.5;
+  const trendFilterPeriod = params?.trendFilterPeriod ?? 200;
+  const useTrendFilter = params?.useTrendFilter ?? 1;
+  const maxSizePct = params?.maxSizePct ?? 60;
+  const maxAtrPctFilter = params?.maxAtrPctFilter ?? 5.0;
+  const symbol = params?.symbol ?? "BTC/USDT";
+
+  return {
+    id: "volatility-mean-reversion",
+    name: "Volatility Mean Reversion",
+    version: "1.0.0",
+    markets: ["crypto", "equity"],
+    symbols: [symbol],
+    timeframes: ["1d"],
+    parameters: {
+      bbPeriod,
+      bbStdDev,
+      rsiPeriod,
+      rsiOversold,
+      rsiOverbought,
+      atrPeriod,
+      atrStopMultiplier,
+      trendFilterPeriod,
+      useTrendFilter,
+      maxSizePct,
+      maxAtrPctFilter,
+    },
+    parameterRanges: {
+      bbPeriod: { min: 10, max: 50, step: 5 },
+      bbStdDev: { min: 1.0, max: 3.0, step: 0.25 },
+      rsiPeriod: { min: 3, max: 21, step: 2 },
+      rsiOversold: { min: 15, max: 35, step: 5 },
+      rsiOverbought: { min: 65, max: 85, step: 5 },
+      atrPeriod: { min: 7, max: 28, step: 7 },
+      atrStopMultiplier: { min: 1.0, max: 3.0, step: 0.5 },
+      trendFilterPeriod: { min: 50, max: 200, step: 50 },
+      useTrendFilter: { min: 0, max: 1, step: 1 },
+      maxSizePct: { min: 20, max: 100, step: 10 },
+      maxAtrPctFilter: { min: 2.0, max: 10.0, step: 1.0 },
+    },
+
+    async onBar(bar: OHLCV, ctx: StrategyContext): Promise<Signal | null> {
+      const bb = ctx.indicators.bollingerBands(bbPeriod, bbStdDev);
+      const rsiValues = ctx.indicators.rsi(rsiPeriod);
+      const atrValues = ctx.indicators.atr(atrPeriod);
+      const sma200 = ctx.indicators.sma(trendFilterPeriod);
+
+      const len = rsiValues.length;
+      if (len < 2) return null;
+
+      const currRsi = rsiValues[len - 1]!;
+      const prevRsi = rsiValues[len - 2]!;
+      const upper = bb.upper[len - 1]!;
+      const lower = bb.lower[len - 1]!;
+      const middle = bb.middle[len - 1]!;
+      const currAtr = atrValues[len - 1]!;
+      const currSma200 = sma200[len - 1]!;
+
+      // NaN check on current values
+      if (
+        Number.isNaN(currRsi) ||
+        Number.isNaN(prevRsi) ||
+        Number.isNaN(upper) ||
+        Number.isNaN(lower) ||
+        Number.isNaN(middle) ||
+        Number.isNaN(currAtr)
+      ) {
+        return null;
+      }
+
+      // Trend filter NaN check (only when enabled)
+      if (useTrendFilter && Number.isNaN(currSma200)) {
+        return null;
+      }
+
+      // Regime filter: skip during crisis
+      if (ctx.regime === "crisis") {
+        return null;
+      }
+
+      // Compute %B = (close - lower) / (upper - lower)
+      const bbWidth = upper - lower;
+      const percentB = bbWidth === 0 ? 0.5 : (bar.close - lower) / bbWidth;
+
+      // ATR as percentage of price
+      const atrPct = (currAtr / bar.close) * 100;
+
+      const hasLong = ctx.portfolio.positions.some((p) => p.side === "long");
+
+      // --- BUY logic ---
+      if (!hasLong) {
+        const belowLower = bar.close < lower;
+        const rsiOversoldCondition = currRsi < rsiOversold;
+        const rsiTurningUp = currRsi > prevRsi;
+        const trendOk = useTrendFilter === 0 || bar.close > currSma200;
+        const atrOk = atrPct < maxAtrPctFilter;
+
+        if (belowLower && rsiOversoldCondition && rsiTurningUp && trendOk && atrOk) {
+          // Confidence components
+          const percentBComponent = 0.2 * (1 - Math.max(percentB, 0));
+          const rsiReversal = Math.min(
+            Math.max((rsiOversold - currRsi) / 20 + (currRsi - prevRsi) / 10, 0),
+            1,
+          );
+          const rsiComponent = 0.15 * rsiReversal;
+          const trendAlignment = useTrendFilter && bar.close > currSma200 ? 1 : 0;
+          const trendComponent = 0.1 * trendAlignment;
+          const confidence = Math.min(0.4 + percentBComponent + rsiComponent + trendComponent, 1);
+
+          const stopLoss = bar.close - atrStopMultiplier * currAtr;
+          const takeProfit = middle;
+          const sizePct = Math.min(maxSizePct, Math.max(20, confidence * 80));
+
+          // Store tracking state in memory
+          ctx.memory.set("holdBars", 0);
+          ctx.memory.set("entryPercentB", percentB);
+
+          return {
+            action: "buy",
+            symbol,
+            sizePct,
+            orderType: "market",
+            reason: `BB lower touch (percentB=${percentB.toFixed(3)}) + RSI oversold (${currRsi.toFixed(1)}) turning up`,
+            confidence,
+            stopLoss,
+            takeProfit,
+          };
+        }
+      }
+
+      // --- SELL logic ---
+      if (hasLong) {
+        // Increment hold bar counter
+        const holdBars = ((ctx.memory.get("holdBars") as number) ?? 0) + 1;
+        ctx.memory.set("holdBars", holdBars);
+
+        // Mean reversion target reached
+        if (bar.close >= middle) {
+          ctx.memory.delete("holdBars");
+          ctx.memory.delete("entryPercentB");
+          return {
+            action: "sell",
+            symbol,
+            sizePct: 100,
+            orderType: "market",
+            reason: `Mean reversion target: price ${bar.close.toFixed(2)} >= BB middle ${middle.toFixed(2)}`,
+            confidence: 0.8,
+          };
+        }
+
+        // Overbought exit
+        if (currRsi > rsiOverbought) {
+          ctx.memory.delete("holdBars");
+          ctx.memory.delete("entryPercentB");
+          return {
+            action: "sell",
+            symbol,
+            sizePct: 100,
+            orderType: "market",
+            reason: `RSI overbought exit: RSI=${currRsi.toFixed(1)} > ${rsiOverbought}`,
+            confidence: 0.75,
+          };
+        }
+
+        // Time stop
+        if (holdBars > 10) {
+          ctx.memory.delete("holdBars");
+          ctx.memory.delete("entryPercentB");
+          return {
+            action: "sell",
+            symbol,
+            sizePct: 100,
+            orderType: "market",
+            reason: `Time stop: held ${holdBars} bars > 10 bar limit`,
+            confidence: 0.6,
+          };
+        }
+      }
+
+      return null;
+    },
+  };
+}