@reefclaw/connect 0.1.10 → 0.1.12

package/assets/plugin/simulator/realistic-fills.js

@@ -1,175 +0,0 @@
-// Phase 9a: Realistic fill simulation.
-// Order book-aware VWAP fills, latency modeling, maker/taker fees.
-import { DEFAULT_SIMULATION_CONFIG, priceToBps } from './types.js';
-/**
- * Walk the order book to compute a volume-weighted average fill price.
- *
- * For BUY: walks asks (sellers) from best ask upward.
- * For SELL: walks bids (buyers) from best bid downward.
- *
- * If the order exceeds available depth, the remainder fills at the worst
- * available price + 10 bps penalty (simulating thin-book impact).
- *
- * @returns { vwap, levelsConsumed, fillRatio } where fillRatio < 1 only
- * if we want to model partial fills (currently always fills completely).
- */
-export function computeBookAwareFillPrice(side, amount, orderbook) {
-    const levels = side === 'buy' ? orderbook.asks : orderbook.bids;
-    if (levels.length === 0) {
-        // No book data — caller should fall back to random slippage
-        return { vwap: 0, levelsConsumed: 0 };
-    }
-    let remaining = amount;
-    let totalCost = 0;
-    let levelsConsumed = 0;
-    for (const [price, quantity] of levels) {
-        if (remaining <= 0)
-            break;
-        const fillQty = Math.min(remaining, quantity);
-        totalCost += fillQty * price;
-        remaining -= fillQty;
-        levelsConsumed++;
-    }
-    if (remaining > 0) {
-        // Order exceeds available depth — fill remainder at worst price + penalty
-        const worstPrice = levels[levels.length - 1][0];
-        const penaltyMultiplier = side === 'buy' ? 1.001 : 0.999; // 10 bps penalty
-        totalCost += remaining * worstPrice * penaltyMultiplier;
-        remaining = 0;
-    }
-    const vwap = totalCost / amount;
-    return { vwap, levelsConsumed };
-}
-/**
- * Simulate latency-induced price drift.
- *
- * During the latency window, the price can move against the trader.
- * The drift is proportional to latency duration and current volatility.
- *
- * @param basePrice The VWAP price before latency adjustment
- * @param side Order side (buy drift is positive, sell drift is negative)
- * @param latencyMs Simulated latency in milliseconds
- * @param volFactor Current volatility factor (1.0 = normal, >1 = elevated)
- * @returns { adjustedPrice, latencyImpactBps }
- */
-export function applyLatencyDrift(basePrice, side, latencyMs, volFactor) {
-    if (latencyMs <= 0) {
-        return { adjustedPrice: basePrice, latencyImpactBps: 0 };
-    }
-    // Base drift: up to 1 bps for 200ms latency, scaled by volatility
-    // Uses a random factor for direction — 70% of the time price moves against trader
-    const maxLatencyMs = 200;
-    const maxDriftBps = 1.0;
-    const latencyRatio = Math.min(latencyMs / maxLatencyMs, 1.0);
-    const randomFactor = Math.random();
-    // 70% adverse, 30% favorable (market more often moves against you in the latency window)
-    const adverseProb = 0.7;
-    const driftDirection = randomFactor < adverseProb ? 1 : -1;
-    const driftMagnitude = latencyRatio * maxDriftBps * volFactor * Math.random();
-    const driftBps = driftMagnitude * driftDirection;
-    // BUY: adverse = price goes UP (pay more)
-    // SELL: adverse = price goes DOWN (receive less)
-    const signedDriftBps = side === 'buy' ? driftBps : -driftBps;
-    const adjustedPrice = basePrice * (1 + signedDriftBps / 10_000);
-    return { adjustedPrice, latencyImpactBps: signedDriftBps };
-}
-/**
- * Generate a random simulated latency within the configured range.
- */
-export function generateLatency(config) {
-    const { minMs, maxMs } = config.latency;
-    return minMs + Math.random() * (maxMs - minMs);
-}
-/**
- * Compute the fee rate based on order type (maker vs taker).
- * Market orders = taker. Limit orders = maker.
- */
-export function getFeeRate(orderType, config) {
-    return orderType === 'market' ? config.fees.takerRate : config.fees.makerRate;
-}
-/**
- * Compute a complete realistic fill for a market order.
- *
- * Combines: orderbook VWAP + latency drift + appropriate fee rate.
- * Falls back to simple random slippage if no orderbook is available.
- *
- * @returns fillPrice and ExecutionQuality metrics
- */
-export function computeRealisticMarketFill(side, amount, decisionPrice, orderbook, volFactor, config = DEFAULT_SIMULATION_CONFIG) {
-    const latencyMs = generateLatency(config);
-    const feeRate = getFeeRate('market', config);
-    let fillPrice;
-    let marketImpactBps;
-    let latencyImpactBps;
-    let bookLevelsConsumed;
-    let bookDepthAvailable;
-    if (orderbook && orderbook.asks.length > 0 && orderbook.bids.length > 0) {
-        // Book-aware VWAP fill
-        const { vwap, levelsConsumed } = computeBookAwareFillPrice(side, amount, orderbook);
-        bookLevelsConsumed = levelsConsumed;
-        bookDepthAvailable = true;
-        // Market impact: VWAP vs mid-price
-        const midPrice = (orderbook.bids[0][0] + orderbook.asks[0][0]) / 2;
-        marketImpactBps = priceToBps(vwap, midPrice);
-        // For sells, impact is negative (received less), so take absolute for the metric
-        // but keep signed for the actual price
-        // Apply latency drift on top of VWAP
-        const latencyResult = applyLatencyDrift(vwap, side, latencyMs, volFactor);
-        fillPrice = latencyResult.adjustedPrice;
-        latencyImpactBps = latencyResult.latencyImpactBps;
-    }
-    else {
-        // Fallback: random slippage (same as old behavior but with latency)
-        bookLevelsConsumed = 0;
-        bookDepthAvailable = false;
-        // Random 0-2 bps base slippage + latency drift
-        const baseBps = Math.random() * 2;
-        const signedBps = side === 'buy' ? baseBps : -baseBps;
-        const basePrice = decisionPrice * (1 + signedBps / 10_000);
-        marketImpactBps = signedBps;
-        const latencyResult = applyLatencyDrift(basePrice, side, latencyMs, volFactor);
-        fillPrice = latencyResult.adjustedPrice;
-        latencyImpactBps = latencyResult.latencyImpactBps;
-    }
-    // Total slippage vs decision price
-    const slippageBps = priceToBps(fillPrice, decisionPrice);
-    const notional = amount * fillPrice;
-    const feePaid = notional * feeRate;
-    const executionQuality = {
-        decisionPrice,
-        fillPrice,
-        slippageBps,
-        marketImpactBps,
-        latencyMs,
-        latencyImpactBps,
-        fillRatio: 1.0, // Market orders always fill completely
-        feeRate,
-        feePaid,
-        bookLevelsConsumed,
-        bookDepthAvailable,
-    };
-    return { fillPrice, executionQuality };
-}
-/**
- * Compute execution quality metrics for a limit order fill.
- * Limit orders fill at the limit price (maker) with no market impact.
- */
-export function computeLimitFillQuality(side, amount, limitPrice, decisionPrice, config = DEFAULT_SIMULATION_CONFIG) {
-    const feeRate = getFeeRate('limit', config);
-    const notional = amount * limitPrice;
-    const feePaid = notional * feeRate;
-    const slippageBps = priceToBps(limitPrice, decisionPrice);
-    return {
-        decisionPrice,
-        fillPrice: limitPrice,
-        slippageBps,
-        marketImpactBps: 0, // Limit orders provide liquidity, no market impact
-        latencyMs: 0,
-        latencyImpactBps: 0,
-        fillRatio: 1.0,
-        feeRate,
-        feePaid,
-        bookLevelsConsumed: 0,
-        bookDepthAvailable: false, // N/A for limits
-    };
-}

package/assets/plugin/simulator/types.d.ts

@@ -1,224 +0,0 @@
-export interface FillError {
-    orderId: string;
-    symbol: string;
-    error: string;
-    timestamp: string;
-}
-/** Simulation configuration for realistic fills. */
-export interface SimulationConfig {
-    fees: {
-        makerRate: number;
-        takerRate: number;
-    };
-    latency: {
-        minMs: number;
-        maxMs: number;
-    };
-    partialFills: {
-        enabled: boolean;
-    };
-}
-export declare const DEFAULT_SIMULATION_CONFIG: SimulationConfig;
-/** Order book depth snapshot for realistic fill simulation. */
-export interface OrderBookDepth {
-    bids: [number, number][];
-    asks: [number, number][];
-    timestamp: number;
-}
-/** Per-fill execution quality metrics (attached to Trade records). */
-export interface ExecutionQuality {
-    decisionPrice: number;
-    fillPrice: number;
-    slippageBps: number;
-    marketImpactBps: number;
-    latencyMs: number;
-    latencyImpactBps: number;
-    fillRatio: number;
-    feeRate: number;
-    feePaid: number;
-    bookLevelsConsumed: number;
-    bookDepthAvailable: boolean;
-}
-export interface SimulatorState {
-    version: string;
-    config: {
-        startingBalance: number;
-        quoteCurrency: string;
-    };
-    wallet: Wallet;
-    positions: Position[];
-    openOrders: Order[];
-    tradeHistory: Trade[];
-    sessionStartNav?: number;
-    sessionDate?: string;
-    /** Cumulative execution quality stats for the session. */
-    executionStats?: ExecutionStats;
-    /** Epoch-ms stamp of the last in-memory mutation. Set on every
-     *  emitStateChanged and persisted. Used by replaceState() to refuse a disk
-     *  snapshot OLDER than the live in-memory state (which would revert a
-     *  just-applied, not-yet-flushed mutation). Same host clock across both
-     *  processes, so it is cross-process comparable. */
-    savedAt?: number;
-}
-/** Cumulative execution quality stats across all trades in a session. */
-export interface ExecutionStats {
-    totalTrades: number;
-    totalSlippageBps: number;
-    totalFeesPaid: number;
-    worstSlippageBps: number;
-    avgSlippageBps: number;
-    avgLatencyMs: number;
-}
-export interface Wallet {
-    [currency: string]: CurrencyBalance;
-}
-export interface CurrencyBalance {
-    total: number;
-    available: number;
-    locked: number;
-}
-/** Who initiated a position close. Default (undefined) = 'agent'.
- *  - `stop_watcher`: paper-mode watcher fired the stop
- *  - `bracket_attach_failed`: LiveAdapter auto-flattened when bracket submission exhausted retries
- *  - `exchange_stop` / `exchange_target`: exchange-native STOP_MARKET / TAKE_PROFIT_MARKET triggered on Binance
- *  - `cancelled_auto`: bracket reconciler cleaned up after detecting the position closed externally
- *  - `operator` / `agent` / `emergency`: explicit initiator */
-export type CloseReason = 'agent' | 'stop_watcher' | 'emergency' | 'operator' | 'bracket_attach_failed' | 'exchange_stop' | 'exchange_target' | 'cancelled_auto' | 'wave9_signal_reversal' | 'liquidated' | 'adl' | 'venue_delisted';
-/** The agent's stated profit-realization plan, pinned at entry. PURE DATA /
- *  indication — the plugin does NOT enforce it; it is surfaced back so the agent
- *  can hold to its own plan instead of re-litigating. The agent fills the parts
- *  relevant to its plan; `note` is always allowed as a free-text summary. See
- *  the 2026-06-05 governing principle in docs/POSITION_MANAGEMENT_PLAN.md
- *  (tools + indication + learning; force only the safety floor). */
-export interface RealizationRule {
-    type: 'fixed_target' | 'trail' | 'scale' | 'manual';
-    targetPrice?: number;
-    trailAfterR?: number;
-    trailDistanceR?: number;
-    scale?: Array<{
-        atR: number;
-        fraction: number;
-    }>;
-    note?: string;
-}
-/** Optional metadata attached at entry time — persisted in state.json.
- *  Most fields are immutable after entry. The MFE block + closeReason are the
- *  exceptions: MFE updates on every mark-price tick; closeReason is set at the
- *  moment of close. */
-export interface PositionMetadata {
-    setupType?: string;
-    missionId?: string;
-    candidateId?: string;
-    strategy?: 'tsmom_28d_long_flat_reversal_1d' | 'tsmom_28d_short_flat_reversal_1d';
-    accruedFundingUsd?: number;
-    fundingThroughTime?: string;
-    thesis?: string;
-    stopPrice?: number;
-    targetPrice?: number;
-    regime?: string;
-    regimeConfidence?: number;
-    scorecardVerdict?: 'STRONG_GO' | 'GO' | 'MARGINAL' | 'NO_GO';
-    confluenceScore?: number;
-    closeReason?: CloseReason;
-    /** Price at which the entry thesis is INVALIDATED — the agent's pinned "I am
-     *  wrong here" level (distinct from the protective stopPrice). Surfaced back
-     *  as indication each heartbeat so the agent holds to its own plan instead of
-     *  re-litigating. NOT enforced — the only forced thing is that a protective
-     *  stop exists. */
-    invalidationPrice?: number;
-    /** The agent's stated profit-realization plan, pinned at entry (indication,
-     *  not an enforced mechanic). */
-    realizationRule?: RealizationRule;
-    /** Entry price as it was at the moment of the FIRST fill, frozen. MFE-in-R is
-     *  denominated against this (and originalStopPrice), never against the
-     *  position's running averaged entryPrice — otherwise a scale-in would
-     *  retroactively shrink an already-achieved excursion. Seeded on the new/flip
-     *  fill; preserved through scale-ins. */
-    originalEntryPrice?: number;
-    /** Stop price as it was at the moment of fill, frozen. R-multiples are
-     *  always denominated against this value, never against current stopPrice
-     *  (which can ratchet). If the position opened without a stop, this is
-     *  undefined and `mfeR` stays undefined. */
-    originalStopPrice?: number;
-    /** Highest favourable mark price seen since entry. For longs: max(mark);
-     *  for shorts: min(mark). Updated on every mark-price tick. Seeded to
-     *  entryPrice on first observation. */
-    mfePeakPrice?: number;
-    /** Maximum favourable excursion expressed in R-multiples, where
-     *  R = |entryPrice − originalStopPrice|. Undefined if originalStopPrice
-     *  is undefined. Always non-negative; recedes only via give-back semantics
-     *  in `giveBackRatio`, never directly. */
-    mfeR?: number;
-    /** Fraction of MFE peak relative to current mark, in [0, 1+]. Defined as
-     *  `(mfePeakPriceR - currentR) / mfePeakPriceR`, only meaningful when
-     *  `mfePeakPriceR > 0`. Undefined when MFE has never been favourable. */
-    giveBackRatio?: number;
-}
-export interface Position {
-    symbol: string;
-    side: 'long' | 'short';
-    entryPrice: number;
-    quantity: number;
-    openedAt: string;
-    metadata?: PositionMetadata;
-    /** Cumulative open-side fees paid to establish (and add to) this position,
-     *  in quote currency. Carried through to Trade records on close so realized
-     *  P&L can include BOTH sides of the roundtrip. Older records without this
-     *  field are treated as 0 at read time. */
-    openFee?: number;
-}
-export interface Order {
-    id: string;
-    symbol: string;
-    side: 'buy' | 'sell';
-    type: 'market' | 'limit';
-    status: 'open' | 'closed' | 'canceled';
-    amount: number;
-    price: number | null;
-    filled: number;
-    average: number | null;
-    cost: number;
-    fee: {
-        cost: number;
-        currency: string;
-    };
-    createdAt: string;
-    /** Entry metadata pinned to a RESTING limit order (stopPrice, thesis,
-     *  invalidation, realizationRule, …). Lives on the Order — NOT only in the
-     *  in-memory pendingOrderMetadata cache — so it is serialized in state.json
-     *  and survives a restart / two-process reload. Without this, a resting limit
-     *  that fills after a restart opened a position with no protective stop. */
-    metadata?: PositionMetadata;
-}
-export interface Trade {
-    id: string;
-    orderId: string;
-    symbol: string;
-    side: 'buy' | 'sell';
-    entryPrice: number;
-    exitPrice: number;
-    quantity: number;
-    realizedPnl: number;
-    /** CLOSE-side fee only. For backward compatibility. */
-    fee: number;
-    /** OPEN-side fee share attributable to the closed quantity (proportional for
-     *  partial closes). Added Apr 2026 — older records will be undefined and must
-     *  be treated as 0 by readers. Total roundtrip fee = `fee + (openFee ?? 0)`. */
-    openFee?: number;
-    openedAt: string;
-    closedAt: string;
-    executionQuality?: ExecutionQuality;
-    /** Entry metadata carried from the closing position. */
-    metadata?: PositionMetadata;
-}
-/** Max trades to keep in history (circular buffer) */
-export declare const MAX_TRADE_HISTORY = 1000;
-/** Fee rate for simulated trades (0.1% = Binance default) */
-export declare const FEE_RATE = 0.001;
-/**
- * Convert a price difference to basis points.
- * Positive = actual > reference (paid more / received more).
- */
-export declare function priceToBps(actual: number, reference: number): number;
-/** Default state for a fresh plugin */
-export declare function createDefaultState(startingBalance: number, quoteCurrency: string): SimulatorState;

package/assets/plugin/simulator/types.js

@@ -1,43 +0,0 @@
-// Internal simulator state types.
-// These are persisted to state.json — must be JSON-serializable.
-export const DEFAULT_SIMULATION_CONFIG = {
-    fees: {
-        makerRate: 0.0002, // 0.02% Binance Futures maker
-        takerRate: 0.0004, // 0.04% Binance Futures taker
-    },
-    latency: {
-        minMs: 50,
-        maxMs: 200,
-    },
-    partialFills: {
-        enabled: true,
-    },
-};
-/** Max trades to keep in history (circular buffer) */
-export const MAX_TRADE_HISTORY = 1000;
-/** Fee rate for simulated trades (0.1% = Binance default) */
-export const FEE_RATE = 0.001;
-/**
- * Convert a price difference to basis points.
- * Positive = actual > reference (paid more / received more).
- */
-export function priceToBps(actual, reference) {
-    return ((actual - reference) / reference) * 10_000;
-}
-/** Default state for a fresh plugin */
-export function createDefaultState(startingBalance, quoteCurrency) {
-    return {
-        version: '1',
-        config: { startingBalance, quoteCurrency },
-        wallet: {
-            [quoteCurrency]: {
-                total: startingBalance,
-                available: startingBalance,
-                locked: 0,
-            },
-        },
-        positions: [],
-        openOrders: [],
-        tradeHistory: [],
-    };
-}

package/assets/plugin/strategy/builtin-strategies.d.ts

@@ -1,2 +0,0 @@
-import type { StrategyConfig } from './evaluator.js';
-export declare const BUILTIN_STRATEGIES: StrategyConfig[];

package/assets/plugin/strategy/builtin-strategies.js

@@ -1,113 +0,0 @@
-// LEGACY strategy configs — used ONLY as fixtures by the local-evaluator
-// tests (strategy/__tests__/evaluator.test.ts). NOT seeded anywhere and NOT
-// part of the product catalog: the shipped catalog lives in
-// intelligence/src/signals/strategy-store.ts (exactly two template
-// strategies since the 2026-07-06 trim — see CLAUDE.md), and the plugin's
-// local evaluator (signals.evaluator, default 'central') receives its
-// strategy set from the intel service, not from this file.
-export const BUILTIN_STRATEGIES = [
-    {
-        name: 'trend_continuation',
-        description: 'Pullback entry in an established trend. Waits for price to pull back to EMA20, with MACD confirming direction, ADX showing trend strength, VWAP alignment, and non-crowded funding.',
-        version: 4,
-        regimeWhitelist: ['TREND_UP', 'TREND_DOWN'],
-        minConfidence: 0.50,
-        directionRule: 'from_regime',
-        conditions: [
-            { type: 'ema_proximity', params: { period: 20, maxDistPct: 0.01 } },
-            { type: 'macd_crossover', params: {} },
-            { type: 'adx_trending', params: { minAdx: 25 } },
-            { type: 'vwap_position', params: {} },
-            { type: 'funding_not_crowded', params: { maxZScore: 2 } },
-            { type: 'oi_slope', params: { lookbackSlots: 16, minSlope: 0 } },
-        ],
-        entryRule: { type: 'ema_offset', params: { period: 20, atrFraction: 0.3 } },
-        stopRule: { type: 'swing_atr', params: { swingCount: 3, atrFraction: 0.5 } },
-        targetRMultiples: [1.5, 2.5, 3.5],
-    },
-    {
-        name: 'mean_reversion',
-        description: 'Snap-back trade from extreme in a range-bound market. StochRSI at extreme, Bollinger breakout (overextended), contrarian funding, and elevated open interest show the setup is crowded and due to revert.',
-        version: 4,
-        regimeWhitelist: ['RANGE_TIGHT'],
-        minConfidence: 0.45,
-        directionRule: 'from_funding',
-        conditions: [
-            { type: 'stoch_rsi_extreme', params: { oversold: 20, overbought: 80 } },
-            { type: 'bollinger_breakout', params: {} },
-            { type: 'funding_contrarian', params: { maxZScore: 1.5 } },
-            { type: 'oi_elevated', params: { elevationRatio: 1.1 } },
-        ],
-        entryRule: { type: 'atr_offset', params: { atrFraction: 0.2 } },
-        stopRule: { type: 'fixed_atr', params: { atrMultiple: 1.5 } },
-        targetRMultiples: [1.5, 2.5],
-    },
-    {
-        name: 'breakout',
-        description: 'Volatility compression followed by expansion. Bollinger squeeze (tight bandwidth), ADX confirming trend building, Supertrend aligned, volume supporting the move.',
-        version: 4,
-        regimeWhitelist: ['RANGE_TIGHT', 'TREND_UP', 'TREND_DOWN', 'VOLATILITY_EXPANSION'],
-        minConfidence: 0.45,
-        directionRule: 'from_regime',
-        conditions: [
-            { type: 'bollinger_squeeze', params: { maxBandwidth: 3.0 } },
-            { type: 'adx_trending', params: { minAdx: 20 } },
-            { type: 'supertrend_direction', params: {} },
-            { type: 'vwap_position', params: {} },
-        ],
-        entryRule: { type: 'atr_offset', params: { atrFraction: 0.15 } },
-        stopRule: { type: 'swing_atr', params: { swingCount: 3, atrFraction: 0.5 } },
-        targetRMultiples: [1.5, 2.5],
-    },
-    {
-        name: 'sweep_reversal',
-        description: 'Liquidity grab reversal in a wide range. Price sweeps a key level, order flow shows absorption, OBV diverges (smart money accumulating), and funding is contrarian.',
-        version: 4,
-        regimeWhitelist: ['RANGE_WIDE'],
-        minConfidence: 0.40,
-        directionRule: 'from_sweep',
-        conditions: [
-            { type: 'price_sweep', params: { swingLookback: 5, recentBars: 10 } },
-            { type: 'order_flow_absorption', params: { maxRatio: 0.3 } },
-            { type: 'funding_contrarian', params: { maxZScore: 1.5 } },
-            { type: 'obv_divergence', params: {} },
-        ],
-        entryRule: { type: 'sweep_range', params: {} },
-        stopRule: { type: 'recent_extreme_atr', params: { atrFraction: 0.3 } },
-        targetRMultiples: [1.5, 2.5],
-    },
-    {
-        name: 'funding_reversion',
-        description: 'Mean reversion when funding hits extreme levels. Extreme funding (>2σ) indicates a crowded trade, elevated OI confirms positioning, price near a level adds confluence.',
-        version: 4,
-        regimeWhitelist: ['RANGE_TIGHT', 'RANGE_WIDE', 'TREND_UP', 'TREND_DOWN', 'VOLATILITY_EXPANSION'],
-        minConfidence: 0.40,
-        directionRule: 'from_funding',
-        conditions: [
-            { type: 'funding_extreme', params: { minZScore: 2 } },
-            { type: 'oi_elevated', params: { elevationRatio: 1.1 } },
-            { type: 'price_at_level', params: { maxDistPct: 0.005 } },
-            { type: 'stoch_rsi_extreme', params: { oversold: 20, overbought: 80 } },
-        ],
-        entryRule: { type: 'atr_offset', params: { atrFraction: 0.2 } },
-        stopRule: { type: 'fixed_atr', params: { atrMultiple: 1.5 } },
-        targetRMultiples: [1.5, 2.5],
-    },
-    {
-        name: 'momentum_divergence',
-        description: 'Trend exhaustion trade. MACD divergence (price vs momentum), OBV divergence (volume vs price), Ichimoku weakening, RSI not extreme. Catches the end of a trend before it reverses.',
-        version: 4,
-        regimeWhitelist: ['TREND_UP', 'TREND_DOWN'],
-        minConfidence: 0.42,
-        directionRule: 'from_regime',
-        conditions: [
-            { type: 'macd_divergence', params: {} },
-            { type: 'obv_divergence', params: {} },
-            { type: 'ichimoku_cloud', params: {} },
-            { type: 'stoch_rsi_extreme', params: { oversold: 30, overbought: 70 } },
-        ],
-        entryRule: { type: 'atr_offset', params: { atrFraction: 0.3 } },
-        stopRule: { type: 'swing_atr', params: { swingCount: 3, atrFraction: 0.5 } },
-        targetRMultiples: [1.5, 2.5, 3.5],
-    },
-];

package/assets/plugin/strategy/condition-registry.d.ts

@@ -1,3 +0,0 @@
-import type { SymbolFact, ConditionEvalResult } from './evaluator.js';
-export type ConditionEvalFn = (fact: SymbolFact, params: Record<string, number>) => ConditionEvalResult;
-export declare const CONDITION_EVALUATORS: Map<string, ConditionEvalFn>;