perp-cli 0.6.4 → 0.7.1

package/dist/bot/strategies/grid-mm.js

@@ -0,0 +1,99 @@
+import { registerStrategy } from "../strategy-registry.js";
+export class GridMmStrategy {
+    name = "grid-mm";
+    describe() {
+        return {
+            description: "Enhanced grid market making with per-level profit tracking",
+            params: [
+                { name: "gridSpacing", type: "number", required: true, description: "Spacing between levels in basis points" },
+                { name: "levels", type: "number", required: false, default: 5, description: "Number of levels each side" },
+                { name: "size", type: "number", required: true, description: "Order size per level" },
+                { name: "rebalancePct", type: "number", required: false, default: 3, description: "Rebalance threshold percentage" },
+            ],
+        };
+    }
+    get params() {
+        return this._config;
+    }
+    _config = {};
+    async init(ctx, snapshot) {
+        this._config = ctx.config;
+        ctx.state.set("gridCenter", snapshot.price);
+        ctx.state.set("levelProfits", new Map());
+        ctx.state.set("totalPnl", 0);
+        ctx.state.set("rebalanceCount", 0);
+        const p = this.params;
+        ctx.log(`  [GRID-MM] spacing=${p.gridSpacing}bps, levels=${p.levels}, size=${p.size}, rebalance=${p.rebalancePct}%`);
+    }
+    async onTick(ctx, snapshot) {
+        const params = this.params;
+        const actions = [];
+        const gridCenter = ctx.state.get("gridCenter") ?? snapshot.price;
+        const levels = params.levels || 5;
+        const spacingFrac = params.gridSpacing / 10000;
+        // Check if rebalance needed
+        const deviation = Math.abs(snapshot.price - gridCenter) / gridCenter;
+        if (deviation > (params.rebalancePct || 3) / 100) {
+            const rebalanceCount = (ctx.state.get("rebalanceCount") ?? 0) + 1;
+            ctx.state.set("rebalanceCount", rebalanceCount);
+            ctx.state.set("gridCenter", snapshot.price);
+            ctx.log(`  [GRID-MM] Rebalance #${rebalanceCount}: center moved to $${snapshot.price.toFixed(2)} (deviation: ${(deviation * 100).toFixed(2)}%)`);
+        }
+        const center = ctx.state.get("gridCenter") ?? snapshot.price;
+        // Cancel all existing orders then place fresh grid
+        actions.push({ type: "cancel_all" });
+        // Place bids below center and asks above center (both sides always)
+        for (let i = 1; i <= levels; i++) {
+            const bidPrice = center * (1 - spacingFrac * i);
+            const askPrice = center * (1 + spacingFrac * i);
+            actions.push({
+                type: "place_order",
+                side: "buy",
+                price: bidPrice.toFixed(6),
+                size: String(params.size),
+                orderType: "limit",
+            });
+            actions.push({
+                type: "place_order",
+                side: "sell",
+                price: askPrice.toFixed(6),
+                size: String(params.size),
+                orderType: "limit",
+            });
+        }
+        // Track per-level profit (simplified: estimate from price crossing levels)
+        const prevPrice = ctx.state.get("prevPrice") ?? snapshot.price;
+        const levelProfits = ctx.state.get("levelProfits") ?? new Map();
+        for (let i = 1; i <= levels; i++) {
+            const bidLevel = center * (1 - spacingFrac * i);
+            const askLevel = center * (1 + spacingFrac * i);
+            if (!levelProfits.has(i)) {
+                levelProfits.set(i, { fills: 0, pnl: 0 });
+            }
+            const lp = levelProfits.get(i);
+            // Price crossed bid level downward: bid filled
+            if (prevPrice > bidLevel && snapshot.price <= bidLevel) {
+                lp.fills++;
+                lp.pnl -= bidLevel * params.size; // cost basis
+            }
+            // Price crossed ask level upward: ask filled
+            if (prevPrice < askLevel && snapshot.price >= askLevel) {
+                lp.fills++;
+                lp.pnl += askLevel * params.size; // revenue
+            }
+        }
+        ctx.state.set("prevPrice", snapshot.price);
+        // Log per-level stats periodically
+        if (ctx.tick > 0 && ctx.tick % 20 === 0) {
+            let totalFills = 0;
+            for (const [, lp] of levelProfits)
+                totalFills += lp.fills;
+            ctx.log(`  [GRID-MM] tick=${ctx.tick}, center=$${center.toFixed(2)}, totalFills=${totalFills}`);
+        }
+        return actions;
+    }
+    async onStop(_ctx) {
+        return [{ type: "cancel_all" }];
+    }
+}
+registerStrategy("grid-mm", (_config) => new GridMmStrategy());

package/dist/bot/strategies/grid-strategy.d.ts

@@ -0,0 +1,39 @@
+import type { Strategy, StrategyContext, StrategyAction, EnrichedSnapshot } from "../strategy-types.js";
+export declare class GridStrategy implements Strategy {
+    readonly name = "grid";
+    describe(): {
+        description: string;
+        params: ({
+            name: string;
+            type: "number";
+            required: boolean;
+            description: string;
+            default?: undefined;
+        } | {
+            name: string;
+            type: "string";
+            required: boolean;
+            default: string;
+            description: string;
+        } | {
+            name: string;
+            type: "number";
+            required: boolean;
+            default: number;
+            description: string;
+        } | {
+            name: string;
+            type: "boolean";
+            required: boolean;
+            default: boolean;
+            description: string;
+        })[];
+    };
+    private get params();
+    private _config;
+    init(ctx: StrategyContext, snapshot: EnrichedSnapshot): Promise<void>;
+    onTick(ctx: StrategyContext, snapshot: EnrichedSnapshot): Promise<StrategyAction[]>;
+    onStop(_ctx: StrategyContext): Promise<StrategyAction[]>;
+    /** Build initial grid order actions */
+    private buildGridOrders;
+}

package/dist/bot/strategies/grid-strategy.js

@@ -0,0 +1,176 @@
+import { registerStrategy } from "../strategy-registry.js";
+export class GridStrategy {
+    name = "grid";
+    describe() {
+        return {
+            description: "Grid trading with fixed intervals",
+            params: [
+                { name: "grids", type: "number", required: true, description: "Number of grid lines" },
+                { name: "size", type: "number", required: true, description: "Total position size" },
+                { name: "side", type: "string", required: false, default: "neutral", description: "long | short | neutral" },
+                { name: "range_mode", type: "string", required: false, default: "auto", description: "auto | fixed" },
+                { name: "range_pct", type: "number", required: false, default: 3, description: "Auto range +/- percentage" },
+                { name: "upper", type: "number", required: false, description: "Fixed mode upper bound" },
+                { name: "lower", type: "number", required: false, description: "Fixed mode lower bound" },
+                { name: "rebalance", type: "boolean", required: false, default: true, description: "Auto-rebalance on range exit" },
+                { name: "rebalance_cooldown", type: "number", required: false, default: 60, description: "Seconds between rebalances" },
+                { name: "leverage", type: "number", required: false, description: "Leverage multiplier" },
+            ],
+        };
+    }
+    get params() {
+        return this._config;
+    }
+    _config = {};
+    async init(ctx, snapshot) {
+        this._config = ctx.config;
+        const params = this.params;
+        // Determine price range
+        if (params.range_mode === "auto") {
+            const pct = params.range_pct ?? 3;
+            const upper = snapshot.price * (1 + pct / 100);
+            const lower = snapshot.price * (1 - pct / 100);
+            ctx.state.set("gridUpper", upper);
+            ctx.state.set("gridLower", lower);
+            ctx.log(`  [GRID] Auto range: $${lower.toFixed(2)} - $${upper.toFixed(2)} (+/-${pct}%)`);
+        }
+        else {
+            if (!params.upper || !params.lower)
+                throw new Error("Fixed grid requires upper and lower");
+            ctx.state.set("gridUpper", params.upper);
+            ctx.state.set("gridLower", params.lower);
+        }
+        ctx.state.set("gridOrders", new Map());
+    }
+    async onTick(ctx, snapshot) {
+        const params = this.params;
+        const actions = [];
+        const gridOrders = ctx.state.get("gridOrders");
+        const gridUpper = ctx.state.get("gridUpper");
+        const gridLower = ctx.state.get("gridLower");
+        // First tick: set leverage + place initial grid
+        if (ctx.tick === 0) {
+            if (params.leverage) {
+                actions.push({ type: "set_leverage", leverage: params.leverage });
+            }
+            return [...actions, ...this.buildGridOrders(ctx, snapshot.price)];
+        }
+        if (params.grids < 2)
+            throw new Error("Grid requires at least 2 grid lines");
+        const step = (gridUpper - gridLower) / (params.grids - 1);
+        const sizePerGrid = params.size / params.grids;
+        // Check for fills
+        try {
+            const openOrders = await ctx.adapter.getOpenOrders();
+            const openIds = new Set(openOrders.filter(o => o.symbol.toUpperCase() === ctx.symbol.toUpperCase()).map(o => o.orderId));
+            // Build filled order IDs from order history for accurate fill detection
+            let filledIds = null;
+            try {
+                const history = await ctx.adapter.getOrderHistory(100);
+                filledIds = new Set(history.filter(o => o.status === "filled").map(o => o.orderId));
+            }
+            catch { /* non-critical -- fall back to assuming fills */ }
+            let newFills = 0;
+            for (const [idx, orderId] of gridOrders.entries()) {
+                if (!openIds.has(orderId)) {
+                    // Verify the order was actually filled (not just cancelled)
+                    if (filledIds && !filledIds.has(orderId)) {
+                        ctx.log(`  [GRID] Order ${orderId} missing -- likely cancelled, skipping`);
+                        gridOrders.delete(idx);
+                        continue;
+                    }
+                    // Order filled -- place opposite order
+                    newFills++;
+                    // Determine new side and price
+                    const oldPrice = gridLower + step * idx;
+                    const wasBuy = oldPrice < snapshot.price;
+                    const newSide = wasBuy ? "sell" : "buy";
+                    const newPrice = wasBuy ? oldPrice + step : oldPrice - step;
+                    if (newPrice >= gridLower && newPrice <= gridUpper) {
+                        actions.push({
+                            type: "place_order",
+                            side: newSide,
+                            price: newPrice.toFixed(2),
+                            size: String(sizePerGrid),
+                            orderType: "limit",
+                        });
+                        // We'll update gridOrders when the action is executed
+                        // For now mark this index as pending -- use a sentinel
+                        gridOrders.set(idx, `pending-${idx}`);
+                    }
+                    else {
+                        gridOrders.delete(idx);
+                    }
+                }
+            }
+            if (newFills > 0) {
+                ctx.log(`  [GRID] ${newFills} fill(s) detected`);
+            }
+        }
+        catch { /* retry next loop */ }
+        // Auto-rebalance if price exits range
+        if (params.rebalance) {
+            const lastRebalance = ctx.state.get("lastRebalance") ?? 0;
+            const outOfRange = snapshot.price > gridUpper || snapshot.price < gridLower;
+            const cooldownOk = Date.now() - lastRebalance > params.rebalance_cooldown * 1000;
+            if (outOfRange && cooldownOk) {
+                const pct = params.range_pct ?? 3;
+                const newUpper = snapshot.price * (1 + pct / 100);
+                const newLower = snapshot.price * (1 - pct / 100);
+                ctx.state.set("gridUpper", newUpper);
+                ctx.state.set("gridLower", newLower);
+                ctx.state.set("lastRebalance", Date.now());
+                const rebalanceCount = (ctx.state.get("rebalanceCount") ?? 0) + 1;
+                ctx.state.set("rebalanceCount", rebalanceCount);
+                ctx.log(`  [GRID] Rebalance #${rebalanceCount}: price $${snapshot.price.toFixed(2)} outside range -> new $${newLower.toFixed(2)} - $${newUpper.toFixed(2)}`);
+                // Cancel all and rebuild
+                actions.push({ type: "cancel_all" });
+                gridOrders.clear();
+                return [...actions, ...this.buildGridOrders(ctx, snapshot.price)];
+            }
+        }
+        return actions;
+    }
+    async onStop(_ctx) {
+        return [{ type: "cancel_all" }];
+    }
+    /** Build initial grid order actions */
+    buildGridOrders(ctx, currentPrice) {
+        const params = this.params;
+        const gridUpper = ctx.state.get("gridUpper");
+        const gridLower = ctx.state.get("gridLower");
+        if (params.grids < 2)
+            throw new Error("Grid requires at least 2 grid lines");
+        const step = (gridUpper - gridLower) / (params.grids - 1);
+        const sizePerGrid = params.size / params.grids;
+        const actions = [];
+        // Cancel existing orders first
+        const gridOrders = ctx.state.get("gridOrders");
+        if (gridOrders.size > 0) {
+            actions.push({ type: "cancel_all" });
+            gridOrders.clear();
+        }
+        for (let i = 0; i < params.grids; i++) {
+            const price = gridLower + step * i;
+            let side;
+            if (params.side === "long")
+                side = "buy";
+            else if (params.side === "short")
+                side = "sell";
+            else
+                side = price < currentPrice ? "buy" : "sell";
+            actions.push({
+                type: "place_order",
+                side,
+                price: price.toFixed(2),
+                size: String(sizePerGrid),
+                orderType: "limit",
+            });
+            // Mark grid index with pending sentinel -- engine updates after execution
+            gridOrders.set(i, `pending-${i}`);
+        }
+        ctx.log(`  [GRID] Placing ${params.grids} orders (step: $${step.toFixed(2)}, size: ${sizePerGrid.toFixed(6)})`);
+        return actions;
+    }
+}
+registerStrategy("grid", (_config) => new GridStrategy());

package/dist/bot/strategies/hedge-agent.d.ts

@@ -0,0 +1,25 @@
+import type { Strategy, StrategyContext, StrategyAction, EnrichedSnapshot } from "../strategy-types.js";
+export declare class HedgeAgentStrategy implements Strategy {
+    readonly name = "hedge-agent";
+    private _config;
+    private get params();
+    describe(): {
+        description: string;
+        params: ({
+            name: string;
+            type: "number";
+            required: boolean;
+            description: string;
+            default?: undefined;
+        } | {
+            name: string;
+            type: "number";
+            required: boolean;
+            default: number;
+            description: string;
+        })[];
+    };
+    init(ctx: StrategyContext, _snapshot: EnrichedSnapshot): Promise<void>;
+    onTick(ctx: StrategyContext, snapshot: EnrichedSnapshot): Promise<StrategyAction[]>;
+    onStop(_ctx: StrategyContext): Promise<StrategyAction[]>;
+}

package/dist/bot/strategies/hedge-agent.js

@@ -0,0 +1,79 @@
+import { registerStrategy } from "../strategy-registry.js";
+export class HedgeAgentStrategy {
+    name = "hedge-agent";
+    _config = {};
+    get params() {
+        return {
+            maxNotionalUsd: Number(this._config.maxNotionalUsd ?? 1000),
+            hedgeRatio: Number(this._config.hedgeRatio ?? 0.5),
+            checkIntervalTicks: Number(this._config.checkIntervalTicks ?? 5),
+        };
+    }
+    describe() {
+        return {
+            description: "Monitors portfolio net notional and hedges when exposure exceeds threshold",
+            params: [
+                { name: "maxNotionalUsd", type: "number", required: true, description: "Max net notional USD before hedging" },
+                { name: "hedgeRatio", type: "number", required: false, default: 0.5, description: "Fraction of excess exposure to hedge (0–1)" },
+                { name: "checkIntervalTicks", type: "number", required: false, default: 5, description: "Ticks between exposure checks" },
+            ],
+        };
+    }
+    async init(ctx, _snapshot) {
+        this._config = ctx.config;
+        ctx.state.set("lastNetNotional", 0);
+        ctx.log(`  [HEDGE-AGENT] maxNotional=$${this.params.maxNotionalUsd} ` +
+            `hedgeRatio=${this.params.hedgeRatio} checkInterval=${this.params.checkIntervalTicks}ticks`);
+    }
+    async onTick(ctx, snapshot) {
+        const { maxNotionalUsd, hedgeRatio, checkIntervalTicks } = this.params;
+        // Only check every N ticks
+        if (ctx.tick % checkIntervalTicks !== 0) {
+            return [{ type: "noop" }];
+        }
+        let positions;
+        try {
+            positions = await ctx.adapter.getPositions();
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            ctx.log(`  [HEDGE-AGENT] Failed to fetch positions: ${msg}`);
+            return [{ type: "noop" }];
+        }
+        // Calculate net notional: long = positive, short = negative
+        let netNotional = 0;
+        for (const pos of positions) {
+            const size = parseFloat(pos.size);
+            const mark = parseFloat(pos.markPrice) || snapshot.price;
+            const notional = size * mark;
+            netNotional += pos.side === "long" ? notional : -notional;
+        }
+        ctx.state.set("lastNetNotional", netNotional);
+        ctx.log(`  [HEDGE-AGENT] net notional: $${netNotional.toFixed(2)} (limit: $${maxNotionalUsd})`);
+        const absNet = Math.abs(netNotional);
+        if (absNet <= maxNotionalUsd) {
+            return [{ type: "noop" }];
+        }
+        const excess = absNet - maxNotionalUsd;
+        const hedgeNotional = excess * hedgeRatio;
+        const hedgeSize = hedgeNotional / snapshot.price;
+        // Hedge on the opposite side to reduce net exposure
+        const hedgeSide = netNotional > 0 ? "sell" : "buy";
+        ctx.log(`  [HEDGE-AGENT] Excess $${excess.toFixed(2)} — placing ${hedgeSide} hedge ` +
+            `size=${hedgeSize.toFixed(6)} at market`);
+        return [
+            {
+                type: "place_order",
+                side: hedgeSide,
+                price: snapshot.price.toFixed(6),
+                size: hedgeSize.toFixed(6),
+                orderType: "market",
+                reduceOnly: false,
+            },
+        ];
+    }
+    async onStop(_ctx) {
+        return [{ type: "cancel_all" }];
+    }
+}
+registerStrategy("hedge-agent", (_config) => new HedgeAgentStrategy());

package/dist/bot/strategies/liquidation-mm.d.ts

@@ -0,0 +1,25 @@
+import type { Strategy, StrategyContext, StrategyAction, EnrichedSnapshot } from "../strategy-types.js";
+export declare class LiquidationMmStrategy implements Strategy {
+    readonly name = "liquidation-mm";
+    describe(): {
+        description: string;
+        params: ({
+            name: string;
+            type: "number";
+            required: boolean;
+            description: string;
+            default?: undefined;
+        } | {
+            name: string;
+            type: "number";
+            required: boolean;
+            default: number;
+            description: string;
+        })[];
+    };
+    private get params();
+    private _config;
+    init(ctx: StrategyContext, snapshot: EnrichedSnapshot): Promise<void>;
+    onTick(ctx: StrategyContext, snapshot: EnrichedSnapshot): Promise<StrategyAction[]>;
+    onStop(_ctx: StrategyContext): Promise<StrategyAction[]>;
+}

package/dist/bot/strategies/liquidation-mm.js

@@ -0,0 +1,108 @@
+import { registerStrategy } from "../strategy-registry.js";
+export class LiquidationMmStrategy {
+    name = "liquidation-mm";
+    describe() {
+        return {
+            description: "Cascade liquidity provider that widens spread and increases size on OI drops",
+            params: [
+                { name: "normalSpread", type: "number", required: true, description: "Normal mode spread in basis points" },
+                { name: "cascadeSpread", type: "number", required: true, description: "Cascade mode spread in basis points" },
+                { name: "cascadeOiDropPct", type: "number", required: false, default: 5, description: "OI drop % to trigger cascade mode" },
+                { name: "size", type: "number", required: true, description: "Base order size" },
+                { name: "cascadeMultiplier", type: "number", required: false, default: 3, description: "Size multiplier in cascade mode" },
+            ],
+        };
+    }
+    get params() {
+        return this._config;
+    }
+    _config = {};
+    async init(ctx, snapshot) {
+        this._config = ctx.config;
+        ctx.state.set("prevOi", parseFloat(snapshot.openInterest) || 0);
+        ctx.state.set("cascadeMode", false);
+        ctx.state.set("cascadeTicks", 0);
+        const p = this.params;
+        ctx.log(`  [LIQUIDATION-MM] normalSpread=${p.normalSpread}bps, cascadeSpread=${p.cascadeSpread}bps, oiDrop=${p.cascadeOiDropPct || 5}%, mult=${p.cascadeMultiplier || 3}x`);
+    }
+    async onTick(ctx, snapshot) {
+        const params = this.params;
+        const actions = [];
+        actions.push({ type: "cancel_all" });
+        const currentOi = parseFloat(snapshot.openInterest) || 0;
+        const prevOi = ctx.state.get("prevOi") ?? currentOi;
+        let cascadeMode = ctx.state.get("cascadeMode") ?? false;
+        let cascadeTicks = ctx.state.get("cascadeTicks") ?? 0;
+        // Detect cascade: OI drop exceeds threshold
+        const oiDropThreshold = (params.cascadeOiDropPct || 5) / 100;
+        if (prevOi > 0 && currentOi > 0) {
+            const oiChange = (currentOi - prevOi) / prevOi;
+            if (oiChange < -oiDropThreshold) {
+                if (!cascadeMode) {
+                    ctx.log(`  [LIQUIDATION-MM] CASCADE triggered: OI drop ${(oiChange * 100).toFixed(2)}% (threshold: -${(oiDropThreshold * 100).toFixed(1)}%)`);
+                }
+                cascadeMode = true;
+                cascadeTicks = 0; // reset decay timer
+            }
+        }
+        // Cascade mode decays after 10 ticks
+        if (cascadeMode) {
+            cascadeTicks++;
+            if (cascadeTicks > 10) {
+                ctx.log(`  [LIQUIDATION-MM] CASCADE ended after ${cascadeTicks} ticks`);
+                cascadeMode = false;
+                cascadeTicks = 0;
+            }
+        }
+        ctx.state.set("prevOi", currentOi);
+        ctx.state.set("cascadeMode", cascadeMode);
+        ctx.state.set("cascadeTicks", cascadeTicks);
+        // Select parameters based on mode
+        const spreadBps = cascadeMode ? params.cascadeSpread : params.normalSpread;
+        const spreadFrac = spreadBps / 10000;
+        const size = cascadeMode ? params.size * (params.cascadeMultiplier || 3) : params.size;
+        const mid = snapshot.price;
+        const bidPrice = mid * (1 - spreadFrac / 2);
+        const askPrice = mid * (1 + spreadFrac / 2);
+        actions.push({
+            type: "place_order",
+            side: "buy",
+            price: bidPrice.toFixed(6),
+            size: String(size),
+            orderType: "limit",
+        });
+        actions.push({
+            type: "place_order",
+            side: "sell",
+            price: askPrice.toFixed(6),
+            size: String(size),
+            orderType: "limit",
+        });
+        // In cascade mode, add extra levels for deeper liquidity
+        if (cascadeMode) {
+            for (let i = 2; i <= 3; i++) {
+                const deepBid = mid * (1 - spreadFrac * i / 2);
+                const deepAsk = mid * (1 + spreadFrac * i / 2);
+                actions.push({
+                    type: "place_order",
+                    side: "buy",
+                    price: deepBid.toFixed(6),
+                    size: String(size * 0.5),
+                    orderType: "limit",
+                });
+                actions.push({
+                    type: "place_order",
+                    side: "sell",
+                    price: deepAsk.toFixed(6),
+                    size: String(size * 0.5),
+                    orderType: "limit",
+                });
+            }
+        }
+        return actions;
+    }
+    async onStop(_ctx) {
+        return [{ type: "cancel_all" }];
+    }
+}
+registerStrategy("liquidation-mm", (_config) => new LiquidationMmStrategy());

package/dist/bot/strategies/mean-reversion.d.ts

@@ -0,0 +1,35 @@
+import type { Strategy, StrategyContext, StrategyAction, EnrichedSnapshot } from "../strategy-types.js";
+/**
+ * Mean reversion strategy.
+ * Entry: price deviates > threshold from SMA, confirmed by Bollinger Band touch.
+ *   - Buy when price touches lower band (oversold).
+ *   - Sell when price touches upper band (overbought).
+ * Exit: price returns to SMA (the mean).
+ */
+export declare class MeanReversionStrategy implements Strategy {
+    readonly name = "mean-reversion";
+    private _config;
+    describe(): {
+        description: string;
+        params: ({
+            name: string;
+            type: "number";
+            required: boolean;
+            default: number;
+            description: string;
+        } | {
+            name: string;
+            type: "number";
+            required: boolean;
+            description: string;
+            default?: undefined;
+        })[];
+    };
+    private get smaPeriod();
+    private get bollingerStdDev();
+    private get entryThreshold();
+    private get size();
+    init(ctx: StrategyContext, _snapshot: EnrichedSnapshot): Promise<void>;
+    onTick(ctx: StrategyContext, snapshot: EnrichedSnapshot): Promise<StrategyAction[]>;
+    onStop(ctx: StrategyContext): Promise<StrategyAction[]>;
+}