@reefclaw/connect 0.1.10 → 0.1.12

package/assets/plugin/portfolio/wave9-policy.js

@@ -1,183 +0,0 @@
-// ⚠️ GENERATED FILE — DO NOT EDIT.
-// Canonical source of truth: shared/src/portfolio/wave9-policy.ts
-// Regenerate: node scripts/sync-shared-code.mjs  (enforced by shared-code-sync.test.ts)
-//
-// This copy exists because this package builds with tsc and deploys as a
-// self-contained tree that strips workspace deps, so it cannot import
-// @reefclaw/shared runtime code across the deploy boundary.
-// Canonical frozen Wave 9 daily signal policy used by the default-off runtime parity
-// observer. This deliberately calls the same generated condition registry and
-// ATR implementation as the intelligence backtest instead of reimplementing
-// momentum semantics in the plugin.
-import { computeATR } from '../shared/indicators.js';
-import { evaluateConditions } from '../signals/conditions/registry.js';
-export const DAY_MS = 24 * 60 * 60 * 1_000;
-export const WAVE9_LOOKBACK_DAYS = 28;
-export const WAVE9_ATR_PERIOD = 14;
-export const WAVE9_ATR_MULTIPLE = 3;
-export const WAVE9_CONTEXT_BARS = 250;
-export const WAVE9_LONG_STRATEGY = 'tsmom_28d_long_flat_reversal_1d';
-export const WAVE9_SHORT_STRATEGY = 'tsmom_28d_short_flat_reversal_1d';
-export const WAVE9_SYMBOL_PRIORITY = [
-    'BTCUSDT',
-    'ETHUSDT',
-    'SOLUSDT',
-    'BNBUSDT',
-    'XRPUSDT',
-    'DOGEUSDT',
-    'ADAUSDT',
-    'LINKUSDT',
-];
-export const WAVE9_STRATEGY_PRIORITY = [
-    WAVE9_LONG_STRATEGY,
-    WAVE9_SHORT_STRATEGY,
-];
-function requireFinitePositive(value, label) {
-    if (!Number.isFinite(value) || value <= 0) {
-        throw new Error(`${label} must be a positive finite number`);
-    }
-}
-/**
- * Return the exact completed-daily context visible at a UTC daily boundary.
- * The function is intentionally fail-closed: unordered, duplicated, gapped,
- * non-UTC, or stale candles are rejected rather than silently repaired.
- */
-export function completedDailyContext(rawBars, eventTime) {
-    const eventMs = eventTime.getTime();
-    if (!Number.isFinite(eventMs) || eventMs % DAY_MS !== 0) {
-        throw new Error('Wave 9 evaluation time must be a finite UTC daily boundary');
-    }
-    let previous = Number.NEGATIVE_INFINITY;
-    for (const [index, bar] of rawBars.entries()) {
-        const time = bar.time.getTime();
-        if (!Number.isFinite(time) || time % DAY_MS !== 0) {
-            throw new Error(`daily bar ${index} is not aligned to UTC midnight`);
-        }
-        if (time <= previous) {
-            throw new Error('daily bars must be strictly chronological and unique');
-        }
-        previous = time;
-        requireFinitePositive(bar.open, `daily bar ${index} open`);
-        requireFinitePositive(bar.high, `daily bar ${index} high`);
-        requireFinitePositive(bar.low, `daily bar ${index} low`);
-        requireFinitePositive(bar.close, `daily bar ${index} close`);
-        if (!Number.isFinite(bar.volume) || bar.volume < 0) {
-            throw new Error(`daily bar ${index} volume must be finite and non-negative`);
-        }
-        if (bar.high < Math.max(bar.open, bar.close) || bar.low > Math.min(bar.open, bar.close)) {
-            throw new Error(`daily bar ${index} has invalid OHLC geometry`);
-        }
-    }
-    const completed = rawBars
-        .filter((bar) => bar.time.getTime() + DAY_MS <= eventMs)
-        .slice(-WAVE9_CONTEXT_BARS);
-    if (completed.length <= WAVE9_LOOKBACK_DAYS + 1) {
-        throw new Error(`Wave 9 requires at least ${WAVE9_LOOKBACK_DAYS + 2} completed daily bars`);
-    }
-    const expectedLastOpen = eventMs - DAY_MS;
-    const lastOpen = completed[completed.length - 1].time.getTime();
-    if (lastOpen !== expectedLastOpen) {
-        throw new Error(`latest completed daily bar must open at ${new Date(expectedLastOpen).toISOString()}`);
-    }
-    for (let index = 1; index < completed.length; index++) {
-        const prior = completed[index - 1].time.getTime();
-        const current = completed[index].time.getTime();
-        if (current - prior !== DAY_MS) {
-            throw new Error(`daily history has a gap between ${completed[index - 1].time.toISOString()} and ${completed[index].time.toISOString()}`);
-        }
-    }
-    return completed.map((bar) => ({ ...bar, time: new Date(bar.time) }));
-}
-function makeContext(bars, atr14) {
-    const latest = bars[bars.length - 1];
-    return {
-        symbol: 'WAVE9',
-        timestamp: new Date(latest.time.getTime() + DAY_MS),
-        ohlcv1h: bars,
-        ohlcv5m: [],
-        ohlcv4h: [],
-        ohlcv1d: bars,
-        currentPrice: latest.close,
-        atr14,
-        obImbalance: 0.5,
-        fundingRates: [],
-        fundingMean: 0,
-        fundingStd: 0.0001,
-        oiValues: [],
-        liqNearEntry: 0,
-        tradeFlow: [],
-        regime: 'UNKNOWN',
-        regimeConfidence: 0,
-    };
-}
-function conditionMet(context, type, params, direction) {
-    const result = evaluateConditions([{ type, params }], context, direction);
-    if (result.conditions.length !== 1 || result.conditions[0].name !== type) {
-        throw new Error(`canonical condition registry did not evaluate ${type}`);
-    }
-    return result.conditions[0].met;
-}
-/** Evaluate the exact Wave 9 entry-transition and signal-reversal semantics. */
-export function evaluateWave9Daily(rawBars, eventTime) {
-    const bars = completedDailyContext(rawBars, eventTime);
-    const highs = bars.map((bar) => bar.high);
-    const lows = bars.map((bar) => bar.low);
-    const closes = bars.map((bar) => bar.close);
-    const atr14 = computeATR(highs, lows, closes, WAVE9_ATR_PERIOD);
-    requireFinitePositive(atr14, 'Wave 9 daily ATR(14)');
-    const context = makeContext(bars, atr14);
-    const currentClose = closes[closes.length - 1];
-    const currentPrior = closes[closes.length - 1 - WAVE9_LOOKBACK_DAYS];
-    const previousClose = closes[closes.length - 2];
-    const previousPrior = closes[closes.length - 2 - WAVE9_LOOKBACK_DAYS];
-    const currentReturn = (currentClose - currentPrior) / currentPrior;
-    const previousReturn = (previousClose - previousPrior) / previousPrior;
-    if (!Number.isFinite(currentReturn) || !Number.isFinite(previousReturn)) {
-        throw new Error('Wave 9 momentum inputs are not finite');
-    }
-    const longEntry = conditionMet(context, 'return_momentum_zero_cross', { tfHours: 24, lookback: WAVE9_LOOKBACK_DAYS, dirSign: 1 }, 'LONG');
-    const shortEntry = conditionMet(context, 'return_momentum_zero_cross', { tfHours: 24, lookback: WAVE9_LOOKBACK_DAYS, dirSign: -1 }, 'SHORT');
-    const exitLong = conditionMet(context, 'return_momentum', {
-        tfHours: 24,
-        lookback: WAVE9_LOOKBACK_DAYS,
-        minReturnPct: 0,
-        maxAbsReturnPct: 0,
-        dirSign: -1,
-        mode: 1,
-    }, 'SHORT');
-    const exitShort = conditionMet(context, 'return_momentum', {
-        tfHours: 24,
-        lookback: WAVE9_LOOKBACK_DAYS,
-        minReturnPct: 0,
-        maxAbsReturnPct: 0,
-        dirSign: 1,
-        mode: 1,
-    }, 'LONG');
-    const entries = [];
-    if (longEntry) {
-        entries.push({
-            strategy: WAVE9_LONG_STRATEGY,
-            direction: 'LONG',
-            stopPrice: currentClose - atr14 * WAVE9_ATR_MULTIPLE,
-        });
-    }
-    if (shortEntry) {
-        entries.push({
-            strategy: WAVE9_SHORT_STRATEGY,
-            direction: 'SHORT',
-            stopPrice: currentClose + atr14 * WAVE9_ATR_MULTIPLE,
-        });
-    }
-    return {
-        eventTime: eventTime.toISOString(),
-        completedDailyOpen: bars[bars.length - 1].time.toISOString(),
-        currentReturn,
-        previousReturn,
-        atr14,
-        referencePrice: currentClose,
-        entries,
-        exitLong,
-        exitShort,
-        sourceBarCount: bars.length,
-    };
-}

package/assets/plugin/risk/pre-trade-check.d.ts

@@ -1,38 +0,0 @@
-import type { DrawdownZone, PreTradeRiskLimits, PreTradeResult, ProposedOrder, PortfolioSnapshot, PreTradeOptions } from './pre-trade-types.js';
-export declare function getDefaultPreTradeLimits(): PreTradeRiskLimits;
-/** @deprecated Use getDefaultPreTradeLimits() for dynamic values */
-export declare const DEFAULT_PRE_TRADE_LIMITS: PreTradeRiskLimits;
-export declare function getDrawdownThresholds(): {
-    YELLOW: number;
-    ORANGE: number;
-    RED: number;
-};
-export declare const DRAWDOWN_ZONE_THRESHOLDS: {
-    readonly YELLOW: -0.01;
-    readonly ORANGE: -0.02;
-    readonly RED: -0.025;
-};
-/** Determine drawdown zone from drawdown ratio (e.g. -0.015 = -1.5%). */
-export declare function getDrawdownZone(drawdownRatio: number): DrawdownZone;
-/** Compute volatility factor from current ATR vs baseline. Clamped [0.5, 3.0]. */
-export declare function computeVolFactor(currentAtr: number, baselineAtr: number): number;
-/** Adjust a limit value by volatility factor. Higher vol = tighter limit. */
-export declare function adjustLimitByVol(defaultLimit: number, volFactor: number): number;
-/** Check if an order is closing an existing position (partial or full). */
-export declare function isClosingOrder(order: ProposedOrder, positions: PortfolioSnapshot['positions']): boolean;
-export declare const EQUITY_FLOOR: {
-    /** Max single-position notional as a fraction of equity.
-     *  Raised 0.25 → 0.40 on 2026-04-20 so small live accounts ($186) can fit
-     *  BTC's ~$75 min-lot. Still protects against all-in entries. Tracked for
-     *  promotion to operator-configurable trading param in the next session. */
-    readonly MAX_POSITION_PCT: 0.4;
-    /** Max per-trade risk (expected loss) as a fraction of equity. */
-    readonly MAX_PER_TRADE_LOSS_PCT: 0.02;
-    /** Presumed adverse move when an order has no explicit stopPrice. */
-    readonly NO_STOP_ASSUMED_ADVERSE: 0.05;
-};
-export declare function preTradeRiskCheck(order: ProposedOrder, portfolio: PortfolioSnapshot, limits?: PreTradeRiskLimits, options?: PreTradeOptions): PreTradeResult;
-/** Count consecutive losses from the end of a trade history array. */
-export declare function computeConsecutiveLosses(trades: Array<{
-    realizedPnl: number;
-}>): number;

package/assets/plugin/risk/pre-trade-check.js

@@ -1,345 +0,0 @@
-// Pre-trade risk gate — pure function.
-// Validates a proposed order against portfolio limits, drawdown zones, and volatility.
-// Lives in the plugin (synchronous access to simulator state).
-import { getCachedTradingParams } from '../trading-params-cache.js';
-// ---- Default pre-trade limits (now read from trading params cache) ----
-export function getDefaultPreTradeLimits() {
-    const tp = getCachedTradingParams();
-    return {
-        maxPositionSize: tp.maxPositionSize,
-        maxOpenPositions: tp.maxOpenPositions,
-        maxGrossExposure: tp.maxGrossExposure,
-        maxPerTradeLoss: tp.maxPerTradeLoss,
-    };
-}
-/** @deprecated Use getDefaultPreTradeLimits() for dynamic values */
-export const DEFAULT_PRE_TRADE_LIMITS = {
-    maxPositionSize: 10_000,
-    maxOpenPositions: 5,
-    maxGrossExposure: 1.5,
-    maxPerTradeLoss: 500,
-};
-// ---- Drawdown zone thresholds (now read from trading params cache) ----
-export function getDrawdownThresholds() {
-    const tp = getCachedTradingParams();
-    return {
-        YELLOW: tp.drawdownYellow,
-        ORANGE: tp.drawdownOrange,
-        RED: tp.drawdownRed,
-    };
-}
-export const DRAWDOWN_ZONE_THRESHOLDS = {
-    YELLOW: -0.01, // -1%
-    ORANGE: -0.02, // -2%
-    RED: -0.025, // -2.5%
-};
-// ---- Pure helpers ----
-/** Determine drawdown zone from drawdown ratio (e.g. -0.015 = -1.5%). */
-export function getDrawdownZone(drawdownRatio) {
-    const thresholds = getDrawdownThresholds();
-    if (drawdownRatio <= thresholds.RED)
-        return 'RED';
-    if (drawdownRatio <= thresholds.ORANGE)
-        return 'ORANGE';
-    if (drawdownRatio <= thresholds.YELLOW)
-        return 'YELLOW';
-    return 'GREEN';
-}
-/** Compute volatility factor from current ATR vs baseline. Clamped [0.5, 3.0]. */
-export function computeVolFactor(currentAtr, baselineAtr) {
-    if (baselineAtr <= 0 || currentAtr <= 0)
-        return 1.0;
-    return Math.max(0.5, Math.min(3.0, currentAtr / baselineAtr));
-}
-/** Adjust a limit value by volatility factor. Higher vol = tighter limit. */
-export function adjustLimitByVol(defaultLimit, volFactor) {
-    if (volFactor <= 1.0)
-        return defaultLimit;
-    return defaultLimit / volFactor;
-}
-/** Check if an order is closing an existing position (partial or full). */
-export function isClosingOrder(order, positions) {
-    const pos = positions.find(p => p.symbol === order.symbol);
-    if (!pos)
-        return false;
-    // Sell against a long = closing; buy against a short = closing
-    return (pos.side === 'long' && order.side === 'sell') ||
-        (pos.side === 'short' && order.side === 'buy');
-}
-// ---- Main pre-trade gate ----
-// ---- Equity-proportional floors (safety net for tiny accounts) ----
-// These are independent of the configurable trading params and exist so that
-// a $10,000 static `maxPositionSize` default can't allow a $289 account to
-// open an $8,000 position. They shrink the effective caps relative to current
-// equity; the tighter of (absolute limit, equity-proportional floor) wins.
-export const EQUITY_FLOOR = {
-    /** Max single-position notional as a fraction of equity.
-     *  Raised 0.25 → 0.40 on 2026-04-20 so small live accounts ($186) can fit
-     *  BTC's ~$75 min-lot. Still protects against all-in entries. Tracked for
-     *  promotion to operator-configurable trading param in the next session. */
-    MAX_POSITION_PCT: 0.40,
-    /** Max per-trade risk (expected loss) as a fraction of equity. */
-    MAX_PER_TRADE_LOSS_PCT: 0.02,
-    /** Presumed adverse move when an order has no explicit stopPrice. */
-    NO_STOP_ASSUMED_ADVERSE: 0.05,
-};
-export function preTradeRiskCheck(order, portfolio, limits = DEFAULT_PRE_TRADE_LIMITS, options = {}) {
-    const violations = [];
-    const volFactor = options.volFactor ?? 1.0;
-    // Caller-provided equity is authoritative; fall back to local compute for
-    // legacy test callers that don't supply it.
-    const currentEquity = portfolio.equity ?? computePortfolioEquity(portfolio);
-    // Drawdown anchor: prefer sessionStartNav, fall back to current equity.
-    const nav = portfolio.sessionStartNav > 0 ? portfolio.sessionStartNav : currentEquity;
-    const drawdownRatio = nav > 0 ? (currentEquity - nav) / nav : 0;
-    const zone = getDrawdownZone(drawdownRatio);
-    // Classify the order against any same-symbol position BEFORE the zone gates:
-    //   - pure reduce / full close  → "closing": exempt from entry gates (exits
-    //     must always work, even in RED/ORANGE).
-    //   - flip (over-close)         → closes the old leg AND opens a NEW opposite
-    //     leg; the NEW leg must clear every entry gate (drawdown zone, size,
-    //     gross, per-trade-loss, bracket requirement). Previously a flip took the
-    //     exit exemption and opened unchecked, possibly oversized, stop-less
-    //     exposure — even in the RED zone (M6).
-    //   - same-direction add (scale-in) / fresh entry → full entry checks (M5).
-    // Emergency flatten bypasses this function entirely (EmergencyControls → adapter.createOrder).
-    const closingPos = portfolio.positions.find(p => p.symbol === order.symbol &&
-        ((p.side === 'long' && order.side === 'sell') || (p.side === 'short' && order.side === 'buy')));
-    const flipAmount = closingPos ? order.amount - closingPos.quantity : 0;
-    const isFlip = closingPos != null && flipAmount > 1e-9 * Math.max(closingPos.quantity, 1);
-    const closing = closingPos != null && !isFlip; // reduce/close, opens no new exposure
-    // The leg that opens new exposure and must clear the entry gates. For a flip
-    // it's ONLY the excess beyond the closed position; otherwise the whole order.
-    // stopPrice/targetPrice carry over so the per-trade-loss and live
-    // bracket-requirement gates evaluate against the new leg's real stop.
-    const entryOrder = isFlip ? { ...order, amount: flipAmount } : order;
-    // Bracket requirement gates — only apply to entries (not closes) when the
-    // caller explicitly passes `bracketEnforcement`. Closes are exempt so
-    // operators can always exit, even if the entry broke the policy.
-    if (!closing && options.bracketEnforcement) {
-        const { requireStopLoss, requireTakeProfit } = options.bracketEnforcement;
-        if (requireStopLoss && (order.stopPrice === undefined || !(order.stopPrice > 0))) {
-            violations.push({
-                rule: 'requireStopLoss',
-                message: 'Live trades require a stopPrice. Disable requireStopLoss in Trading Parameters to override (not recommended).',
-                current: 0,
-                limit: 1,
-            });
-        }
-        if (requireTakeProfit && (order.targetPrice === undefined || !(order.targetPrice > 0))) {
-            violations.push({
-                rule: 'requireTakeProfit',
-                message: 'Live trades require a target_price. Disable requireTakeProfit in Trading Parameters to override.',
-                current: 0,
-                limit: 1,
-            });
-        }
-        if (violations.length > 0) {
-            return {
-                allowed: false,
-                violations,
-                drawdownZone: zone,
-                effectiveMaxPositionSize: 0,
-            };
-        }
-    }
-    // Exits are always allowed regardless of drawdown zone
-    if (closing) {
-        const effectiveMax = computeEffectivePositionSize(limits.maxPositionSize, volFactor, zone);
-        return {
-            allowed: true,
-            violations: [],
-            drawdownZone: zone,
-            effectiveMaxPositionSize: effectiveMax,
-        };
-    }
-    // RED zone: reject new entries (exits already handled above)
-    if (zone === 'RED') {
-        violations.push({
-            rule: 'drawdownZone',
-            message: `RED zone (${(drawdownRatio * 100).toFixed(2)}% drawdown) — new entries rejected`,
-            current: drawdownRatio,
-            limit: DRAWDOWN_ZONE_THRESHOLDS.RED,
-        });
-        return {
-            allowed: false,
-            violations,
-            drawdownZone: zone,
-            effectiveMaxPositionSize: 0,
-        };
-    }
-    // ORANGE zone: only exits allowed (already handled above)
-    if (zone === 'ORANGE') {
-        violations.push({
-            rule: 'drawdownZone',
-            message: `ORANGE zone (${(drawdownRatio * 100).toFixed(2)}% drawdown) — new entries blocked, exits only`,
-            current: drawdownRatio,
-            limit: DRAWDOWN_ZONE_THRESHOLDS.ORANGE,
-        });
-        return {
-            allowed: false,
-            violations,
-            drawdownZone: zone,
-            effectiveMaxPositionSize: 0,
-        };
-    }
-    // ---- Entry checks (GREEN/YELLOW) ----
-    const streak = options.consecutiveLosses ?? 0;
-    const tp = getCachedTradingParams();
-    // Equity-proportional floor — shrinks the static cap on small accounts.
-    // A $10k default `maxPositionSize` is useless on a $289 account; cap to
-    // `EQUITY_FLOOR.MAX_POSITION_PCT` of current equity. The tighter of the two wins.
-    const equityPositionCap = currentEquity > 0
-        ? currentEquity * EQUITY_FLOOR.MAX_POSITION_PCT
-        : limits.maxPositionSize;
-    const scaledMaxPositionSize = Math.min(limits.maxPositionSize, equityPositionCap);
-    let effectiveMaxPositionSize = computeEffectivePositionSize(scaledMaxPositionSize, volFactor, zone);
-    // Graduated size reduction on loss streaks (never a hard block — that creates deadlocks)
-    // Ensure correct ordering: the harsher reduction (0.25x) needs the higher threshold
-    const quarterThreshold = Math.max(tp.lossStreakQuarterSize, tp.lossStreakHalfSize);
-    const halfThreshold = Math.min(tp.lossStreakQuarterSize, tp.lossStreakHalfSize);
-    if (streak >= quarterThreshold) {
-        effectiveMaxPositionSize *= 0.25;
-    }
-    else if (streak >= halfThreshold) {
-        effectiveMaxPositionSize *= 0.5;
-    }
-    // 1. Position size check — against the RESULTING position notional, not just
-    //    this order's increment. A same-direction scale-in must include the
-    //    existing leg, or repeated small adds each pass individually yet build a
-    //    position far beyond the per-symbol cap (M5). A flip's resulting position
-    //    is only the new opposite leg (the old leg is closed), so the existing
-    //    notional is NOT added there.
-    const entryNotional = entryOrder.amount * order.price;
-    const sameSymbolPos = portfolio.positions.find(p => p.symbol === order.symbol);
-    const isScaleIn = sameSymbolPos != null &&
-        ((sameSymbolPos.side === 'long' && order.side === 'buy') ||
-            (sameSymbolPos.side === 'short' && order.side === 'sell'));
-    const existingNotional = isScaleIn && sameSymbolPos
-        ? sameSymbolPos.quantity * (sameSymbolPos.markPrice ?? sameSymbolPos.entryPrice)
-        : 0;
-    const resultingNotional = existingNotional + entryNotional;
-    if (resultingNotional > effectiveMaxPositionSize) {
-        violations.push({
-            rule: 'positionSize',
-            message: `Resulting position notional $${resultingNotional.toFixed(2)} (existing $${existingNotional.toFixed(2)} + order $${entryNotional.toFixed(2)}) exceeds effective max $${effectiveMaxPositionSize.toFixed(2)} (equity $${currentEquity.toFixed(2)}, cap ${(EQUITY_FLOOR.MAX_POSITION_PCT * 100).toFixed(0)}% of equity)`,
-            current: resultingNotional,
-            limit: effectiveMaxPositionSize,
-        });
-    }
-    // 2. Open positions count (would a new symbol exceed limit?)
-    const existingSymbols = new Set(portfolio.positions.map(p => p.symbol));
-    if (!existingSymbols.has(order.symbol)) {
-        const newCount = existingSymbols.size + 1;
-        if (newCount > limits.maxOpenPositions) {
-            violations.push({
-                rule: 'openPositions',
-                message: `New position would bring count to ${newCount}, max is ${limits.maxOpenPositions}`,
-                current: newCount,
-                limit: limits.maxOpenPositions,
-            });
-        }
-    }
-    // 3. Projected gross exposure. On a flip the closed leg leaves the book, so
-    //    net it out — otherwise the projection double-counts the position we close.
-    if (nav > 0) {
-        const currentGross = computeGrossExposure(portfolio);
-        const closedLegNotional = isFlip && closingPos
-            ? closingPos.quantity * (closingPos.markPrice ?? closingPos.entryPrice)
-            : 0;
-        const projectedGross = currentGross - closedLegNotional + entryNotional;
-        const projectedRatio = projectedGross / nav;
-        const effectiveMaxGross = adjustLimitByVol(limits.maxGrossExposure, volFactor);
-        if (projectedRatio > effectiveMaxGross) {
-            violations.push({
-                rule: 'grossExposure',
-                message: `Projected gross exposure ${projectedRatio.toFixed(2)}x exceeds limit ${effectiveMaxGross.toFixed(2)}x`,
-                current: projectedRatio,
-                limit: effectiveMaxGross,
-            });
-        }
-    }
-    // 4. Per-trade loss check — MANDATORY (was previously opt-in on stopPrice).
-    // Without a stop, we presume a 5% adverse move as the worst-case loss. This
-    // prevents the gate from waving through stopless entries on thin accounts.
-    if (!closing) {
-        // Use the opening leg's amount/notional (the flip's new leg, or the whole
-        // order for a fresh entry/scale-in) so the flip's new exposure is gated.
-        const expectedLoss = order.stopPrice != null
-            ? Math.abs(order.price - order.stopPrice) * entryOrder.amount
-            : entryNotional * EQUITY_FLOOR.NO_STOP_ASSUMED_ADVERSE;
-        const equityLossCap = currentEquity > 0
-            ? currentEquity * EQUITY_FLOOR.MAX_PER_TRADE_LOSS_PCT
-            : limits.maxPerTradeLoss;
-        const scaledPerTradeLoss = Math.min(limits.maxPerTradeLoss, equityLossCap);
-        if (expectedLoss > scaledPerTradeLoss) {
-            const stopNote = order.stopPrice != null
-                ? `stop @ ${order.stopPrice}`
-                : `no stop — assumed ${(EQUITY_FLOOR.NO_STOP_ASSUMED_ADVERSE * 100).toFixed(0)}% adverse move`;
-            violations.push({
-                rule: 'perTradeLoss',
-                message: `Expected loss $${expectedLoss.toFixed(2)} (${stopNote}) exceeds per-trade limit $${scaledPerTradeLoss.toFixed(2)} (${(EQUITY_FLOOR.MAX_PER_TRADE_LOSS_PCT * 100).toFixed(0)}% of equity $${currentEquity.toFixed(2)})`,
-                current: expectedLoss,
-                limit: scaledPerTradeLoss,
-            });
-        }
-    }
-    return {
-        allowed: violations.length === 0,
-        violations,
-        drawdownZone: zone,
-        effectiveMaxPositionSize,
-    };
-}
-// ---- Exported helpers ----
-/** Count consecutive losses from the end of a trade history array. */
-export function computeConsecutiveLosses(trades) {
-    let streak = 0;
-    for (let i = trades.length - 1; i >= 0; i--) {
-        if (trades[i].realizedPnl < 0) {
-            streak++;
-        }
-        else {
-            break;
-        }
-    }
-    return streak;
-}
-// ---- Internal helpers ----
-function computeEffectivePositionSize(baseMax, volFactor, zone) {
-    let effective = adjustLimitByVol(baseMax, volFactor);
-    if (zone === 'YELLOW') {
-        effective *= 0.5; // YELLOW halves position sizes
-    }
-    return effective;
-}
-function computePortfolioEquity(portfolio) {
-    let equity = portfolio.walletTotal;
-    for (const pos of portfolio.positions) {
-        const mark = pos.markPrice ?? pos.entryPrice;
-        const pnl = pos.side === 'long'
-            ? (mark - pos.entryPrice) * pos.quantity
-            : (pos.entryPrice - mark) * pos.quantity;
-        if (portfolio.isLive) {
-            // Live Binance: wallet already includes margin — add only unrealized P&L.
-            equity += pnl;
-        }
-        else {
-            // Paper simulator (SPOT-collateral model): the full entry notional was
-            // deducted from wallet at open and is released on close, so we must add
-            // it back here. Same formula for longs and shorts — the previous
-            // `-qty*mark` short branch was arithmetically wrong and underrepresented
-            // equity by 2*entry*qty whenever the account held a short.
-            equity += pos.entryPrice * pos.quantity + pnl;
-        }
-    }
-    return equity;
-}
-function computeGrossExposure(portfolio) {
-    let gross = 0;
-    for (const pos of portfolio.positions) {
-        const price = pos.markPrice ?? pos.entryPrice;
-        gross += Math.abs(pos.quantity * price);
-    }
-    return gross;
-}

package/assets/plugin/risk/pre-trade-types.d.ts

@@ -1,60 +0,0 @@
-export type DrawdownZone = 'GREEN' | 'YELLOW' | 'ORANGE' | 'RED';
-export interface PreTradeRiskLimits {
-    maxPositionSize: number;
-    maxOpenPositions: number;
-    maxGrossExposure: number;
-    maxPerTradeLoss: number;
-}
-export interface ProposedOrder {
-    symbol: string;
-    side: 'buy' | 'sell';
-    type: 'market' | 'limit';
-    amount: number;
-    price: number;
-    stopPrice?: number;
-    targetPrice?: number;
-}
-export interface PortfolioSnapshot {
-    positions: Array<{
-        symbol: string;
-        side: 'long' | 'short';
-        quantity: number;
-        entryPrice: number;
-        markPrice?: number;
-    }>;
-    walletTotal: number;
-    walletAvailable: number;
-    sessionStartNav: number;
-    /** Mark-to-market total account value. If provided, takes precedence over
-     *  the gate's own equity computation — the caller's value is authoritative
-     *  because it has access to the real simulator/exchange state. When absent
-     *  (legacy test callers), the gate falls back to an internal computation. */
-    equity?: number;
-    /** Paper simulator deducts notional from wallet at entry — equity = wallet + position value.
-     *  Live Binance wallet already includes margin — equity = wallet + unrealized PnL only. */
-    isLive?: boolean;
-}
-export interface PreTradeViolation {
-    rule: string;
-    message: string;
-    current: number;
-    limit: number;
-}
-export interface PreTradeResult {
-    allowed: boolean;
-    violations: PreTradeViolation[];
-    drawdownZone: DrawdownZone;
-    effectiveMaxPositionSize: number;
-}
-export interface PreTradeOptions {
-    volFactor?: number;
-    consecutiveLosses?: number;
-    /** When true, the gate rejects entries without a stopPrice and/or targetPrice
-     *  based on the flags below. Only meaningful in live mode with bracket orders
-     *  enabled — in paper/off mode the stop-watcher handles protection and these
-     *  flags don't apply (gate ignores them). */
-    bracketEnforcement?: {
-        requireStopLoss: boolean;
-        requireTakeProfit: boolean;
-    };
-}

package/assets/plugin/risk/pre-trade-types.js

@@ -1,3 +0,0 @@
-// Pre-trade risk gate types.
-// Used by preTradeRiskCheck() to validate orders before they reach the simulator.
-export {};

package/assets/plugin/shadow/shadow-tracker.d.ts

@@ -1,36 +0,0 @@
-import { EventEmitter } from 'node:events';
-import type { BinancePrivateApi } from '../ccxt/binance-private.js';
-import type { ExchangeSimulator } from '../simulator/exchange-simulator.js';
-import type { ShadowComparison, ShadowMetrics, ShadowConfig } from './types.js';
-/**
- * ShadowTracker hooks into the ExchangeSimulator to compute
- * shadow estimates for every paper fill.
- *
- * Events emitted:
- * - 'shadowComparison': ShadowComparison — after each fill comparison
- */
-export declare class ShadowTracker extends EventEmitter {
-    private privateApi;
-    private simulator;
-    private metrics;
-    private config;
-    private recentComparisons;
-    private active;
-    constructor(privateApi: BinancePrivateApi, simulator: ExchangeSimulator, config?: ShadowConfig, existingMetrics?: ShadowMetrics);
-    /** Start listening for simulator fill events. */
-    start(): void;
-    /** Stop listening. */
-    stop(): void;
-    /** Get current shadow metrics. */
-    getMetrics(): ShadowMetrics;
-    /** Get recent comparisons. */
-    getRecentComparisons(): ShadowComparison[];
-    /** Check if shadow mode criteria are met for mode upgrade. */
-    isReadyForUpgrade(): {
-        ready: boolean;
-        reasons: string[];
-    };
-    private onFill;
-    private computeShadowComparison;
-    private updateMetrics;
-}