@reefclaw/openclaw-plugin 0.1.0

package/bridge/providers/onboarding-commands.js

@@ -0,0 +1,213 @@
+// Pure command functions for the operator onboarding RPCs (PR2).
+// Matches the shape of emergency-commands.ts: each function takes a context
+// with `http` + `toolMap` and returns a structured outcome. The
+// GatewayProvider's `setTradingMode` / `setExchangeCredentials` methods
+// are thin wrappers that forward their own http + toolMap. Unit tests
+// exercise these functions directly with a mocked http client.
+import { logger } from '../logger.js';
+const TAG = 'onboarding-commands';
+/** Escape a string for a regex literal. Used to scrub secrets from error messages. */
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/** Forward a set_trading_mode invocation to the plugin via HTTP. */
+export async function executeSetTradingMode(ctx, mode, acknowledged) {
+    const tool = ctx.toolMap.set_trading_mode;
+    if (!tool || !ctx.http) {
+        return {
+            ok: false,
+            message: 'set_trading_mode tool not available on gateway',
+            previousMode: 'PAPER',
+            mode: 'PAPER',
+            readiness: 'UNKNOWN',
+        };
+    }
+    try {
+        const result = await ctx.http.invoke(tool, { mode, acknowledged });
+        return result.data;
+    }
+    catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        logger.error(TAG, `set_trading_mode failed: ${reason}`);
+        return {
+            ok: false,
+            message: reason,
+            previousMode: 'PAPER',
+            mode: 'PAPER',
+            readiness: 'UNKNOWN',
+        };
+    }
+}
+/** Forward a test_exchange_credentials invocation to the plugin. The plugin
+ *  does a throwaway read-only call to verify permissions without persisting
+ *  the keys. Error messages are scrubbed of the raw secret before logging
+ *  (same approach as the set path). */
+export async function executeTestExchangeCredentials(ctx, apiKey, secret, testnet) {
+    const tool = ctx.toolMap.test_exchange_credentials;
+    if (!tool || !ctx.http) {
+        return {
+            ok: false,
+            message: 'test_exchange_credentials tool not available on gateway',
+            fingerprint: '(not-set)',
+            canReadBalance: false,
+            canReadPositions: false,
+            balanceUSDT: null,
+            testnet: testnet ?? false,
+            errors: ['tool-not-available'],
+        };
+    }
+    try {
+        const result = await ctx.http.invoke(tool, { apiKey, secret, testnet });
+        return result.data;
+    }
+    catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        const sanitized = reason.replace(new RegExp(escapeRegex(secret), 'g'), '***');
+        logger.error(TAG, `test_exchange_credentials failed: ${sanitized}`);
+        return {
+            ok: false,
+            message: sanitized,
+            fingerprint: '(not-set)',
+            canReadBalance: false,
+            canReadPositions: false,
+            balanceUSDT: null,
+            testnet: testnet ?? false,
+            errors: [sanitized],
+        };
+    }
+}
+/** Forward a clear_exchange_credentials invocation to the plugin. Sends
+ *  `confirm: true` unconditionally — the skill RPC only accepts the call
+ *  at all when the bridge has decided it's legitimate, so the plugin-side
+ *  safety gate is always satisfied when we reach this function. */
+export async function executeClearExchangeCredentials(ctx) {
+    const tool = ctx.toolMap.clear_exchange_credentials;
+    if (!tool || !ctx.http) {
+        return {
+            ok: false,
+            message: 'clear_exchange_credentials tool not available on gateway',
+            modeBefore: 'PAPER',
+            mode: 'PAPER',
+            rolledBackToPaper: false,
+            readiness: 'UNKNOWN',
+        };
+    }
+    try {
+        const result = await ctx.http.invoke(tool, { confirm: true });
+        return result.data;
+    }
+    catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        logger.error(TAG, `clear_exchange_credentials failed: ${reason}`);
+        return {
+            ok: false,
+            message: reason,
+            modeBefore: 'PAPER',
+            mode: 'PAPER',
+            rolledBackToPaper: false,
+            readiness: 'UNKNOWN',
+        };
+    }
+}
+/** Forward a get_bracket_config invocation to the plugin. Returns safe
+ *  defaults if the tool isn't available (bracket feature not enabled or
+ *  plugin is older than v2.7) so the dashboard can still render. */
+export async function executeGetBracketConfig(ctx) {
+    const tool = ctx.toolMap.get_bracket_config;
+    if (!tool || !ctx.http) {
+        return {
+            ok: false,
+            message: 'get_bracket_config tool not available on gateway',
+            mode: 'off',
+            requireStopLoss: true,
+            requireTakeProfit: true,
+        };
+    }
+    try {
+        const result = await ctx.http.invoke(tool, {});
+        if ('error' in result.data) {
+            return {
+                ok: false,
+                message: result.data.error,
+                mode: 'off',
+                requireStopLoss: true,
+                requireTakeProfit: true,
+            };
+        }
+        return { ok: true, ...result.data };
+    }
+    catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        logger.error(TAG, `get_bracket_config failed: ${reason}`);
+        return {
+            ok: false,
+            message: reason,
+            mode: 'off',
+            requireStopLoss: true,
+            requireTakeProfit: true,
+        };
+    }
+}
+/** Forward a set_bracket_requirement invocation to the plugin. The plugin
+ *  side enforces flag + boolean validation; the skill layer just forwards. */
+export async function executeSetBracketRequirement(ctx, flag, value) {
+    const tool = ctx.toolMap.set_bracket_requirement;
+    if (!tool || !ctx.http) {
+        return {
+            ok: false,
+            flag,
+            previousValue: true,
+            value,
+            error: 'set_bracket_requirement tool not available on gateway',
+        };
+    }
+    try {
+        const result = await ctx.http.invoke(tool, { flag, value });
+        return result.data;
+    }
+    catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        logger.error(TAG, `set_bracket_requirement failed: ${reason}`);
+        return {
+            ok: false,
+            flag,
+            previousValue: true,
+            value,
+            error: reason,
+        };
+    }
+}
+/** Forward a set_exchange_credentials invocation to the plugin via HTTP.
+ *  The raw secret is sent once over TLS and never retained here — no
+ *  caching, no log lines with the raw value. Errors are scrubbed of the
+ *  secret before logging in case it ever appears in an error chain. */
+export async function executeSetExchangeCredentials(ctx, apiKey, secret, testnet) {
+    const tool = ctx.toolMap.set_exchange_credentials;
+    if (!tool || !ctx.http) {
+        return {
+            ok: false,
+            message: 'set_exchange_credentials tool not available on gateway',
+            fingerprint: '(not-set)',
+            reconnected: false,
+            mode: 'PAPER',
+            readiness: 'UNKNOWN',
+        };
+    }
+    try {
+        const result = await ctx.http.invoke(tool, { apiKey, secret, testnet });
+        return result.data;
+    }
+    catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        const sanitized = reason.replace(new RegExp(escapeRegex(secret), 'g'), '***');
+        logger.error(TAG, `set_exchange_credentials failed: ${sanitized}`);
+        return {
+            ok: false,
+            message: sanitized,
+            fingerprint: '(not-set)',
+            reconnected: false,
+            mode: 'PAPER',
+            readiness: 'UNKNOWN',
+        };
+    }
+}

package/bridge/providers/risk-calculator.d.ts

@@ -0,0 +1,96 @@
+import type { RiskLimits, RiskBreach, RiskUpdatePayload } from '../types.js';
+import type { CcxtPosition } from '../gateway/poller.js';
+export declare const DEFAULT_RISK_LIMITS: RiskLimits;
+/** Multipliers applied to base limits per regime. Values < 1 tighten limits. */
+export declare const REGIME_LIMIT_PROFILES: Record<string, Partial<{
+    positionSize: number;
+    grossExposure: number;
+    netExposure: number;
+    description: string;
+}>>;
+/** Apply regime-conditional adjustments to limits. */
+export declare function applyRegimeAdjustment(baseLimits: RiskLimits, regime: string): RiskLimits;
+export declare const DRAWDOWN_ZONE_THRESHOLDS: {
+    readonly YELLOW: -0.01;
+    readonly ORANGE: -0.02;
+    readonly RED: -0.025;
+};
+export type DrawdownZone = 'GREEN' | 'YELLOW' | 'ORANGE' | 'RED';
+/** State snapshot needed to compute equity. */
+export interface EquityState {
+    balanceTotal: number;
+    positions: CcxtPosition[];
+    lastTickerPrice: number | null;
+}
+/** State snapshot needed to compute full risk metrics. */
+export interface RiskState {
+    balanceTotal: number;
+    positions: CcxtPosition[];
+    lastTickerPrice: number | null;
+    sessionStartNav: number;
+    orderTimestamps: number[];
+    cancelTimestamps: number[];
+    atrData?: {
+        currentAtr: number;
+        baselineAtr: number;
+    };
+    regime?: string;
+    realizedPnlToday?: number;
+}
+/** Result of computeRiskMetrics including pruned timestamp arrays. */
+export interface RiskMetricsResult {
+    metrics: RiskUpdatePayload['metrics'];
+    prunedOrderTimestamps: number[];
+    prunedCancelTimestamps: number[];
+}
+/** Compute volatility factor from current ATR vs baseline. Clamped [0.5, 3.0]. */
+export declare function computeVolFactor(state: {
+    currentAtr: number;
+    baselineAtr: number;
+}): number;
+/** Apply volatility adjustment to base limits. Tightens position/exposure, leaves loss/rate unchanged. */
+export declare function applyVolatilityAdjustment(baseLimits: RiskLimits, volFactor: number): RiskLimits;
+/** Determine drawdown zone from drawdown ratio (e.g. -0.015 = -1.5%). */
+export declare function getDrawdownZone(drawdownRatio: number): DrawdownZone;
+/** Human-readable message for a drawdown zone. */
+export declare function getDrawdownZoneMessage(zone: DrawdownZone, ratio: number): string;
+/**
+ * Compute true equity: wallet + entry_notional (margin held) + unrealized P&L per position.
+ *
+ * The paper trading simulator deducts entry_notional from the wallet when opening
+ * ANY position (long or short). To recover true equity we add back the margin and
+ * the unrealized P&L.
+ *
+ * The old formula (wallet + |current_notional|) worked for longs but INVERTED the
+ * P&L direction for shorts: a losing short increased |notional| and showed phantom profit.
+ */
+export declare function computeEquity(state: EquityState): number;
+/**
+ * Compute signed notional value of a position.
+ * Positive for long, negative for short.
+ */
+export declare function computePositionNotional(pos: CcxtPosition, lastTickerPrice: number | null): number;
+/**
+ * Count events within the last RATE_WINDOW_MS.
+ * Returns the count and a new filtered array (does NOT mutate input).
+ */
+export declare function countRecentEvents(timestamps: number[]): {
+    count: number;
+    filtered: number[];
+};
+/**
+ * Detect risk limit breaches from current metrics.
+ */
+export declare function detectBreaches(metrics: {
+    grossExposure: number;
+    netExposure: number;
+    dailyDrawdown: number;
+    dailyLoss?: number;
+    ordersPerMinute: number;
+    cancelsPerMinute: number;
+}, limits: RiskLimits): RiskBreach[];
+/**
+ * Compute full risk metrics from a state snapshot.
+ * Returns metrics + pruned timestamp arrays for the caller to store.
+ */
+export declare function computeRiskMetrics(state: RiskState): RiskMetricsResult;

package/bridge/providers/risk-calculator.js

@@ -0,0 +1,369 @@
+// Pure risk calculation functions extracted from GatewayProvider.
+// All functions are stateless — they take snapshots and return results.
+// ---- Default risk limits (configurable in future phases) ----
+export const DEFAULT_RISK_LIMITS = {
+    position: {
+        maxPositionSize: 10_000,
+        maxOpenPositions: 5,
+        maxGrossExposure: 1.5,
+        maxNetExposure: 1.5,
+    },
+    loss: {
+        maxDailyDrawdown: -0.03,
+        maxPerTradeLoss: -500,
+        maxDailyLoss: -2000,
+    },
+    rate: { maxOrdersPerMinute: 60, maxCancelsPerMinute: 30 },
+};
+// ---- Regime-conditional limit multipliers (Phase 9e) ----
+/** Multipliers applied to base limits per regime. Values < 1 tighten limits. */
+export const REGIME_LIMIT_PROFILES = {
+    TREND_UP: { positionSize: 1.0, grossExposure: 1.0, netExposure: 1.0, description: 'Standard limits — trending up' },
+    TREND_DOWN: { positionSize: 1.0, grossExposure: 1.0, netExposure: 1.0, description: 'Standard limits — trending down' },
+    RANGE_TIGHT: { positionSize: 0.5, grossExposure: 0.7, netExposure: 0.7, description: 'Tighter positions — less edge in tight ranges' },
+    RANGE_WIDE: { positionSize: 0.5, grossExposure: 0.5, netExposure: 0.5, description: 'Significantly tighter — choppy markets burn capital' },
+    VOLATILITY_EXPANSION: { positionSize: 0.6, grossExposure: 0.7, netExposure: 0.7, description: 'Smaller positions — vol needs room' },
+    AVOID: { positionSize: 0, grossExposure: 1, netExposure: 1, description: 'No new entries — regime classified as AVOID' },
+    UNKNOWN: { positionSize: 0.8, grossExposure: 0.8, netExposure: 0.8, description: 'Cautious — regime unknown' },
+};
+/** Apply regime-conditional adjustments to limits. */
+export function applyRegimeAdjustment(baseLimits, regime) {
+    const profile = REGIME_LIMIT_PROFILES[regime];
+    if (!profile)
+        return baseLimits;
+    return {
+        position: {
+            maxPositionSize: baseLimits.position.maxPositionSize * (profile.positionSize ?? 1),
+            maxOpenPositions: baseLimits.position.maxOpenPositions,
+            maxGrossExposure: baseLimits.position.maxGrossExposure * (profile.grossExposure ?? 1),
+            maxNetExposure: baseLimits.position.maxNetExposure * (profile.netExposure ?? 1),
+        },
+        loss: baseLimits.loss,
+        rate: baseLimits.rate,
+    };
+}
+// ---- Drawdown zone thresholds ----
+export const DRAWDOWN_ZONE_THRESHOLDS = {
+    YELLOW: -0.01, // -1%
+    ORANGE: -0.02, // -2%
+    RED: -0.025, // -2.5%
+};
+// ---- Rate tracking window ----
+const RATE_WINDOW_MS = 60_000; // 1 minute
+// ---- Volatility + drawdown pure functions ----
+/** Compute volatility factor from current ATR vs baseline. Clamped [0.5, 3.0]. */
+export function computeVolFactor(state) {
+    if (state.baselineAtr <= 0 || state.currentAtr <= 0)
+        return 1.0;
+    return Math.max(0.5, Math.min(3.0, state.currentAtr / state.baselineAtr));
+}
+/** Apply volatility adjustment to base limits. Tightens position/exposure, leaves loss/rate unchanged. */
+export function applyVolatilityAdjustment(baseLimits, volFactor) {
+    if (volFactor <= 1.0)
+        return baseLimits;
+    return {
+        position: {
+            maxPositionSize: baseLimits.position.maxPositionSize / volFactor,
+            maxOpenPositions: baseLimits.position.maxOpenPositions,
+            maxGrossExposure: baseLimits.position.maxGrossExposure / volFactor,
+            maxNetExposure: baseLimits.position.maxNetExposure / volFactor,
+        },
+        loss: baseLimits.loss,
+        rate: baseLimits.rate,
+    };
+}
+/** Determine drawdown zone from drawdown ratio (e.g. -0.015 = -1.5%). */
+export function getDrawdownZone(drawdownRatio) {
+    if (drawdownRatio <= DRAWDOWN_ZONE_THRESHOLDS.RED)
+        return 'RED';
+    if (drawdownRatio <= DRAWDOWN_ZONE_THRESHOLDS.ORANGE)
+        return 'ORANGE';
+    if (drawdownRatio <= DRAWDOWN_ZONE_THRESHOLDS.YELLOW)
+        return 'YELLOW';
+    return 'GREEN';
+}
+/** Human-readable message for a drawdown zone. */
+export function getDrawdownZoneMessage(zone, ratio) {
+    const pct = (ratio * 100).toFixed(2);
+    switch (zone) {
+        case 'GREEN': return `Green zone (${pct}%) — full trading`;
+        case 'YELLOW': return `Yellow zone (${pct}%) — position sizes halved`;
+        case 'ORANGE': return `Orange zone (${pct}%) — new entries blocked, exits only`;
+        case 'RED': return `Red zone (${pct}%) — all orders rejected, auto-flatten`;
+    }
+}
+// ---- Pure functions ----
+/**
+ * Compute true equity: wallet + entry_notional (margin held) + unrealized P&L per position.
+ *
+ * The paper trading simulator deducts entry_notional from the wallet when opening
+ * ANY position (long or short). To recover true equity we add back the margin and
+ * the unrealized P&L.
+ *
+ * The old formula (wallet + |current_notional|) worked for longs but INVERTED the
+ * P&L direction for shorts: a losing short increased |notional| and showed phantom profit.
+ */
+export function computeEquity(state) {
+    let equity = state.balanceTotal;
+    for (const pos of state.positions) {
+        const contracts = Math.abs(pos.contracts ?? 0);
+        const contractSize = pos.contractSize ?? 1;
+        const entryPrice = pos.entryPrice ?? 0;
+        // Add back margin deducted from wallet at position open
+        equity += contracts * contractSize * entryPrice;
+        // Add unrealized P&L (correctly signed: positive when profitable)
+        equity += pos.unrealizedPnl ?? 0;
+    }
+    return equity;
+}
+/**
+ * Compute signed notional value of a position.
+ * Positive for long, negative for short.
+ */
+export function computePositionNotional(pos, lastTickerPrice) {
+    const sign = pos.side === 'short' ? -1 : 1;
+    // Prefer exchange-provided notional
+    if (typeof pos.notional === 'number' && pos.notional !== 0) {
+        return sign * Math.abs(pos.notional);
+    }
+    // Compute from contracts * contractSize * price
+    const contracts = pos.contracts ?? 0;
+    const contractSize = pos.contractSize ?? 1;
+    const price = pos.markPrice ?? pos.entryPrice ?? lastTickerPrice ?? 0;
+    return sign * contracts * contractSize * price;
+}
+/**
+ * Count events within the last RATE_WINDOW_MS.
+ * Returns the count and a new filtered array (does NOT mutate input).
+ */
+export function countRecentEvents(timestamps) {
+    const cutoff = Date.now() - RATE_WINDOW_MS;
+    const filtered = timestamps.filter((ts) => ts >= cutoff);
+    return { count: filtered.length, filtered };
+}
+/**
+ * Detect risk limit breaches from current metrics.
+ */
+export function detectBreaches(metrics, limits) {
+    const breaches = [];
+    const now = new Date().toISOString();
+    // Gross exposure
+    if (metrics.grossExposure > limits.position.maxGrossExposure) {
+        breaches.push({
+            metric: 'grossExposure',
+            limit: limits.position.maxGrossExposure,
+            current: metrics.grossExposure,
+            level: 'CRITICAL',
+            action: 'ALERT',
+            timestamp: now,
+        });
+    }
+    else if (metrics.grossExposure > limits.position.maxGrossExposure * 0.8) {
+        breaches.push({
+            metric: 'grossExposure',
+            limit: limits.position.maxGrossExposure,
+            current: metrics.grossExposure,
+            level: 'WARNING',
+            action: 'ALERT',
+            timestamp: now,
+        });
+    }
+    // Net exposure
+    if (Math.abs(metrics.netExposure) > limits.position.maxNetExposure) {
+        breaches.push({
+            metric: 'netExposure',
+            limit: limits.position.maxNetExposure,
+            current: metrics.netExposure,
+            level: 'CRITICAL',
+            action: 'ALERT',
+            timestamp: now,
+        });
+    }
+    else if (Math.abs(metrics.netExposure) > limits.position.maxNetExposure * 0.8) {
+        breaches.push({
+            metric: 'netExposure',
+            limit: limits.position.maxNetExposure,
+            current: metrics.netExposure,
+            level: 'WARNING',
+            action: 'ALERT',
+            timestamp: now,
+        });
+    }
+    // Daily drawdown (negative values — breach when current is more negative than limit)
+    if (metrics.dailyDrawdown < limits.loss.maxDailyDrawdown) {
+        breaches.push({
+            metric: 'dailyDrawdown',
+            limit: limits.loss.maxDailyDrawdown,
+            current: metrics.dailyDrawdown,
+            level: 'CRITICAL',
+            action: 'AUTO_PAUSE',
+            timestamp: now,
+        });
+    }
+    // Order rate
+    if (metrics.ordersPerMinute > limits.rate.maxOrdersPerMinute) {
+        breaches.push({
+            metric: 'ordersPerMinute',
+            limit: limits.rate.maxOrdersPerMinute,
+            current: metrics.ordersPerMinute,
+            level: 'CRITICAL',
+            action: 'AUTO_PAUSE',
+            timestamp: now,
+        });
+    }
+    // Cancel rate
+    if (metrics.cancelsPerMinute > limits.rate.maxCancelsPerMinute) {
+        breaches.push({
+            metric: 'cancelsPerMinute',
+            limit: limits.rate.maxCancelsPerMinute,
+            current: metrics.cancelsPerMinute,
+            level: 'CRITICAL',
+            action: 'AUTO_PAUSE',
+            timestamp: now,
+        });
+    }
+    // Daily loss (negative values — breach when realized loss exceeds limit)
+    if (metrics.dailyLoss != null && metrics.dailyLoss < limits.loss.maxDailyLoss) {
+        breaches.push({
+            metric: 'dailyLoss',
+            limit: limits.loss.maxDailyLoss,
+            current: metrics.dailyLoss,
+            level: 'CRITICAL',
+            action: 'AUTO_PAUSE',
+            timestamp: now,
+        });
+    }
+    return breaches;
+}
+/**
+ * Compute full risk metrics from a state snapshot.
+ * Returns metrics + pruned timestamp arrays for the caller to store.
+ */
+export function computeRiskMetrics(state) {
+    // Use equity (wallet + position notionals) for NAV
+    const currentEquity = computeEquity({
+        balanceTotal: state.balanceTotal,
+        positions: state.positions,
+        lastTickerPrice: state.lastTickerPrice,
+    });
+    const nav = state.sessionStartNav > 0 ? state.sessionStartNav : (currentEquity > 0 ? currentEquity : 1);
+    // Compute position metrics
+    const positionSizes = {};
+    let grossExposure = 0;
+    let netExposure = 0;
+    for (const pos of state.positions) {
+        const signedNotional = computePositionNotional(pos, state.lastTickerPrice);
+        const absNotional = Math.abs(signedNotional);
+        if (absNotional > 0) {
+            positionSizes[pos.symbol] = absNotional;
+            grossExposure += absNotional;
+            netExposure += signedNotional;
+        }
+    }
+    // Normalize by NAV
+    const grossRatio = nav > 0 ? grossExposure / nav : 0;
+    const netRatio = nav > 0 ? netExposure / nav : 0;
+    // Daily drawdown: (current equity - session start NAV) / session start NAV
+    const dailyDrawdown = state.sessionStartNav > 0
+        ? (currentEquity - state.sessionStartNav) / state.sessionStartNav
+        : 0;
+    // Prune and count rate events (non-mutating)
+    const orderResult = countRecentEvents(state.orderTimestamps);
+    const cancelResult = countRecentEvents(state.cancelTimestamps);
+    // Volatility adjustment (when ATR data is available)
+    let adjustedLimits = DEFAULT_RISK_LIMITS;
+    let effectiveLimits;
+    let volatilityInfo;
+    let volFactor = 1.0;
+    if (state.atrData && state.atrData.currentAtr > 0 && state.atrData.baselineAtr > 0) {
+        volFactor = computeVolFactor(state.atrData);
+        const adjusted = volFactor > 1.0;
+        if (adjusted) {
+            adjustedLimits = applyVolatilityAdjustment(DEFAULT_RISK_LIMITS, volFactor);
+        }
+        volatilityInfo = {
+            atr14: state.atrData.currentAtr,
+            baselineAtr: state.atrData.baselineAtr,
+            volFactor: +volFactor.toFixed(3),
+            adjusted,
+        };
+    }
+    // Regime-conditional adjustment (Phase 9e) — applied on top of vol adjustment
+    let regimeInfo;
+    if (state.regime && state.regime !== 'UNKNOWN') {
+        const profile = REGIME_LIMIT_PROFILES[state.regime];
+        if (profile) {
+            const regimeAdjusted = applyRegimeAdjustment(adjustedLimits, state.regime);
+            const isAdjusted = state.regime !== 'TREND_UP' && state.regime !== 'TREND_DOWN';
+            if (isAdjusted) {
+                adjustedLimits = regimeAdjusted;
+            }
+            regimeInfo = {
+                regime: state.regime,
+                description: profile.description ?? state.regime,
+                adjusted: isAdjusted,
+            };
+        }
+    }
+    if (adjustedLimits !== DEFAULT_RISK_LIMITS) {
+        effectiveLimits = adjustedLimits;
+    }
+    // Drawdown zone
+    const drawdownZone = getDrawdownZone(dailyDrawdown);
+    const drawdownZoneMessage = getDrawdownZoneMessage(drawdownZone, dailyDrawdown);
+    // Detect breaches using effective limits (vol + regime adjusted) when available
+    const limitsForBreaches = effectiveLimits ?? DEFAULT_RISK_LIMITS;
+    const dailyLoss = state.realizedPnlToday ?? 0;
+    const breaches = detectBreaches({
+        grossExposure: grossRatio,
+        netExposure: netRatio,
+        dailyDrawdown,
+        dailyLoss,
+        ordersPerMinute: orderResult.count,
+        cancelsPerMinute: cancelResult.count,
+    }, limitsForBreaches);
+    // Add zone-specific breaches
+    if (drawdownZone === 'ORANGE' || drawdownZone === 'RED') {
+        breaches.push({
+            metric: 'drawdownZone',
+            limit: drawdownZone === 'RED' ? DRAWDOWN_ZONE_THRESHOLDS.RED : DRAWDOWN_ZONE_THRESHOLDS.ORANGE,
+            current: dailyDrawdown,
+            level: 'CRITICAL',
+            action: drawdownZone === 'RED' ? 'AUTO_PAUSE' : 'REJECT_ORDER',
+            timestamp: new Date().toISOString(),
+        });
+    }
+    else if (drawdownZone === 'YELLOW') {
+        breaches.push({
+            metric: 'drawdownZone',
+            limit: DRAWDOWN_ZONE_THRESHOLDS.YELLOW,
+            current: dailyDrawdown,
+            level: 'WARNING',
+            action: 'ALERT',
+            timestamp: new Date().toISOString(),
+        });
+    }
+    return {
+        metrics: {
+            limits: DEFAULT_RISK_LIMITS,
+            utilization: {
+                currentPositionSize: positionSizes,
+                openPositionCount: state.positions.filter((p) => computePositionNotional(p, state.lastTickerPrice) !== 0).length,
+                grossExposure: +grossRatio.toFixed(4),
+                netExposure: +netRatio.toFixed(4),
+                dailyDrawdown: +dailyDrawdown.toFixed(6),
+                dailyLoss: state.realizedPnlToday ?? 0,
+                ordersPerMinute: orderResult.count,
+                cancelsPerMinute: cancelResult.count,
+            },
+            activeBreaches: breaches,
+            effectiveLimits,
+            volatility: volatilityInfo,
+            drawdownZone,
+            drawdownZoneMessage,
+            regime: regimeInfo,
+        },
+        prunedOrderTimestamps: orderResult.filtered,
+        prunedCancelTimestamps: cancelResult.filtered,
+    };
+}