@reefclaw/openclaw-plugin 0.1.5 → 0.1.7

package/portfolio/wave9-admission.js

@@ -0,0 +1,262 @@
+// ⚠️ GENERATED FILE — DO NOT EDIT.
+// Canonical source of truth: shared/src/portfolio/wave9-admission.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.
+import { WAVE9_LONG_STRATEGY, WAVE9_STRATEGY_PRIORITY, WAVE9_SYMBOL_PRIORITY, } from './wave9-policy.js';
+export const WAVE9_ADMISSION_POLICY = Object.freeze({
+    riskPct: 0.5,
+    maxPositions: 4,
+    maxOpenRiskPct: 2,
+    maxGrossExposureMultiple: 1.5,
+    maxPositionUsd: 10_000,
+    feeBps: 5,
+    slippageBps: 10,
+    capEnforcement: 'admission_only_no_forced_deleveraging',
+    riskMeasure: 'fixed_initial_stop_risk_usd',
+});
+function finitePositive(value) {
+    return Number.isFinite(value) && value > 0;
+}
+function nearlyEqual(left, right) {
+    return Math.abs(left - right) <= 1e-9 * Math.max(1, Math.abs(left), Math.abs(right));
+}
+function validatePolicy(policy) {
+    for (const [label, value] of Object.entries({
+        riskPct: policy.riskPct,
+        maxOpenRiskPct: policy.maxOpenRiskPct,
+        maxGrossExposureMultiple: policy.maxGrossExposureMultiple,
+        maxPositionUsd: policy.maxPositionUsd,
+    })) {
+        if (!finitePositive(value))
+            throw new Error(`${label} must be positive and finite`);
+    }
+    if (!Number.isInteger(policy.maxPositions) || policy.maxPositions <= 0) {
+        throw new Error('maxPositions must be a positive integer');
+    }
+    for (const [label, value] of Object.entries({
+        feeBps: policy.feeBps,
+        slippageBps: policy.slippageBps,
+    })) {
+        if (!Number.isFinite(value) || value < 0) {
+            throw new Error(`${label} must be finite and non-negative`);
+        }
+    }
+    if (policy.capEnforcement !== 'admission_only_no_forced_deleveraging'
+        || policy.riskMeasure !== 'fixed_initial_stop_risk_usd') {
+        throw new Error('unsupported Wave 9 admission policy semantics');
+    }
+}
+function rank(value, values, label) {
+    const result = values.indexOf(value);
+    if (result < 0)
+        throw new Error(`${label} is not in the frozen Wave 9 priority`);
+    return result;
+}
+function validateCandidateIdentity(id, eventTime, symbol, strategy, direction) {
+    const eventMs = Date.parse(eventTime);
+    if (!Number.isFinite(eventMs) || new Date(eventMs).toISOString() !== eventTime) {
+        throw new Error('candidate eventTime must be a canonical ISO timestamp');
+    }
+    const expectedId = `${eventTime}|${symbol}|${strategy}|${direction}`;
+    if (id !== expectedId) {
+        throw new Error(`candidate ID does not match its frozen identity: ${id}`);
+    }
+}
+function copyPosition(position) {
+    return { ...position };
+}
+function ledgerFor(positions, policy) {
+    const exitCostRate = (policy.feeBps + policy.slippageBps) / 10_000;
+    return positions.map((position) => ({
+        ...copyPosition(position),
+        estimatedExitCostUsd: position.markPrice * position.quantity * exitCostRate,
+    }));
+}
+function summarize(cashEquityUsd, ledger) {
+    let unrealized = 0;
+    let funding = 0;
+    let exitCosts = 0;
+    let gross = 0;
+    let risk = 0;
+    for (const row of ledger) {
+        unrealized += row.direction === 'LONG'
+            ? (row.markPrice - row.entryPrice) * row.quantity
+            : (row.entryPrice - row.markPrice) * row.quantity;
+        funding += row.accruedFundingUsd;
+        exitCosts += row.estimatedExitCostUsd;
+        gross += Math.abs(row.markPrice * row.quantity);
+        risk += row.dollarRiskUsd;
+    }
+    return { equity: cashEquityUsd + unrealized - funding - exitCosts, gross, risk };
+}
+/**
+ * Apply a same-event candidate batch in the exact frozen priority. The caller
+ * must release stops and completed-daily reversals before invoking this
+ * function, just as the chronological research engine does.
+ */
+export function applyWave9AdmissionBatch(inputState, rawCandidates, policy = WAVE9_ADMISSION_POLICY) {
+    validatePolicy(policy);
+    if (!Number.isFinite(inputState.cashEquityUsd)) {
+        throw new Error('cashEquityUsd must be finite');
+    }
+    const positions = inputState.positions.map(copyPosition);
+    const ids = new Set();
+    for (const position of positions) {
+        if (ids.has(position.candidateId))
+            throw new Error('open candidate IDs must be unique');
+        ids.add(position.candidateId);
+        rank(position.symbol, WAVE9_SYMBOL_PRIORITY, 'open-position symbol');
+        rank(position.strategy, WAVE9_STRATEGY_PRIORITY, 'open-position strategy');
+        const identity = position.candidateId.split('|');
+        if (identity.length !== 4) {
+            throw new Error(`open-position candidate ID is malformed: ${position.candidateId}`);
+        }
+        validateCandidateIdentity(position.candidateId, identity[0], position.symbol, position.strategy, position.direction);
+        if (!finitePositive(position.entryPrice)
+            || !finitePositive(position.quantity)
+            || !finitePositive(position.markPrice)
+            || !finitePositive(position.initialStop)
+            || !Number.isFinite(position.dollarRiskUsd)
+            || position.dollarRiskUsd < 0
+            || !Number.isFinite(position.accruedFundingUsd)) {
+            throw new Error(`invalid open position ${position.candidateId}`);
+        }
+        const expectedDirection = position.strategy === WAVE9_LONG_STRATEGY ? 'LONG' : 'SHORT';
+        const geometryValid = position.direction === expectedDirection
+            && (position.direction === 'LONG'
+                ? position.initialStop < position.entryPrice
+                : position.initialStop > position.entryPrice);
+        if (!geometryValid) {
+            throw new Error(`invalid open-position geometry ${position.candidateId}`);
+        }
+        const expectedRisk = Math.abs(position.entryPrice - position.initialStop)
+            * position.quantity;
+        if (!nearlyEqual(position.dollarRiskUsd, expectedRisk)) {
+            throw new Error(`open-position risk mismatch ${position.candidateId}`);
+        }
+    }
+    if (new Set(positions.map((position) => position.symbol)).size !== positions.length) {
+        throw new Error('Wave 9 allows at most one open position per symbol');
+    }
+    const candidates = rawCandidates.map((candidate) => ({ ...candidate }));
+    const candidateIds = new Set();
+    let batchEventTime;
+    for (const candidate of candidates) {
+        if (candidateIds.has(candidate.id))
+            throw new Error('candidate IDs must be unique');
+        candidateIds.add(candidate.id);
+        validateCandidateIdentity(candidate.id, candidate.eventTime, candidate.symbol, candidate.strategy, candidate.direction);
+        if (batchEventTime === undefined)
+            batchEventTime = candidate.eventTime;
+        if (candidate.eventTime !== batchEventTime) {
+            throw new Error('a Wave 9 admission batch must contain exactly one eventTime');
+        }
+        rank(candidate.symbol, WAVE9_SYMBOL_PRIORITY, 'candidate symbol');
+        rank(candidate.strategy, WAVE9_STRATEGY_PRIORITY, 'candidate strategy');
+    }
+    candidates.sort((left, right) => rank(left.symbol, WAVE9_SYMBOL_PRIORITY, 'candidate symbol')
+        - rank(right.symbol, WAVE9_SYMBOL_PRIORITY, 'candidate symbol')
+        || rank(left.strategy, WAVE9_STRATEGY_PRIORITY, 'candidate strategy')
+            - rank(right.strategy, WAVE9_STRATEGY_PRIORITY, 'candidate strategy')
+        || left.id.localeCompare(right.id));
+    let cashEquityUsd = inputState.cashEquityUsd;
+    const decisions = [];
+    const feeRate = policy.feeBps / 10_000;
+    const slippageRate = policy.slippageBps / 10_000;
+    for (const candidate of candidates) {
+        const decision = {
+            ...candidate,
+            accepted: false,
+            reason: 'invalidSizing',
+        };
+        const expectedDirection = candidate.strategy === WAVE9_LONG_STRATEGY ? 'LONG' : 'SHORT';
+        if (candidate.direction !== expectedDirection
+            || !finitePositive(candidate.referencePrice)
+            || !finitePositive(candidate.stopPrice)) {
+            decision.reason = 'invalidGeometry';
+            decisions.push(decision);
+            continue;
+        }
+        const entryPrice = candidate.direction === 'LONG'
+            ? candidate.referencePrice * (1 + slippageRate)
+            : candidate.referencePrice * (1 - slippageRate);
+        decision.entryPrice = entryPrice;
+        if ((candidate.direction === 'LONG' && candidate.stopPrice >= entryPrice)
+            || (candidate.direction === 'SHORT' && candidate.stopPrice <= entryPrice)) {
+            decision.reason = 'invalidGeometry';
+            decisions.push(decision);
+            continue;
+        }
+        if (positions.some((position) => position.symbol === candidate.symbol)) {
+            decision.reason = 'symbolAlreadyOpen';
+            decisions.push(decision);
+            continue;
+        }
+        if (positions.length >= policy.maxPositions) {
+            decision.reason = 'maxPositions';
+            decisions.push(decision);
+            continue;
+        }
+        const current = summarize(cashEquityUsd, ledgerFor(positions, policy));
+        const riskPerUnit = Math.abs(entryPrice - candidate.stopPrice);
+        const riskBudget = current.equity * policy.riskPct / 100;
+        const quantity = Math.min(riskBudget / riskPerUnit, policy.maxPositionUsd / entryPrice);
+        const notionalUsd = quantity * entryPrice;
+        const riskUsd = quantity * riskPerUnit;
+        Object.assign(decision, { quantity, notionalUsd, riskUsd });
+        if (!finitePositive(quantity) || current.equity <= 0) {
+            decision.reason = 'invalidSizing';
+            decisions.push(decision);
+            continue;
+        }
+        const position = {
+            candidateId: candidate.id,
+            symbol: candidate.symbol,
+            strategy: candidate.strategy,
+            direction: candidate.direction,
+            entryPrice,
+            quantity,
+            markPrice: candidate.referencePrice,
+            initialStop: candidate.stopPrice,
+            dollarRiskUsd: riskUsd,
+            accruedFundingUsd: 0,
+        };
+        const projectedPositions = [...positions, position];
+        const projectedCash = cashEquityUsd - notionalUsd * feeRate;
+        const projectedLedger = ledgerFor(projectedPositions, policy);
+        const projected = summarize(projectedCash, projectedLedger);
+        Object.assign(decision, {
+            projectedCashEquityUsd: projectedCash,
+            projectedLiquidationEquityUsd: projected.equity,
+            projectedGrossExposureUsd: projected.gross,
+            projectedOpenRiskUsd: projected.risk,
+            projectedOpenPositions: projectedPositions.length,
+            projectedPositionLedger: projectedLedger,
+        });
+        if (projected.equity <= 0) {
+            decision.reason = 'invalidSizing';
+        }
+        else if (projected.gross
+            > projected.equity * policy.maxGrossExposureMultiple + 1e-9) {
+            decision.reason = 'maxGrossExposure';
+        }
+        else if (projected.risk
+            > projected.equity * policy.maxOpenRiskPct / 100 + 1e-9) {
+            decision.reason = 'maxOpenRisk';
+        }
+        else {
+            decision.accepted = true;
+            decision.reason = 'accepted';
+            cashEquityUsd = projectedCash;
+            positions.push(position);
+        }
+        decisions.push(decision);
+    }
+    return {
+        decisions,
+        state: { cashEquityUsd, positions: positions.map(copyPosition) },
+    };
+}

package/portfolio/wave9-policy.d.ts

@@ -0,0 +1,36 @@
+import type { Direction, OhlcvBar } from '../signals/types.js';
+export declare const DAY_MS: number;
+export declare const WAVE9_LOOKBACK_DAYS = 28;
+export declare const WAVE9_ATR_PERIOD = 14;
+export declare const WAVE9_ATR_MULTIPLE = 3;
+export declare const WAVE9_CONTEXT_BARS = 250;
+export declare const WAVE9_LONG_STRATEGY = "tsmom_28d_long_flat_reversal_1d";
+export declare const WAVE9_SHORT_STRATEGY = "tsmom_28d_short_flat_reversal_1d";
+export type Wave9StrategyName = typeof WAVE9_LONG_STRATEGY | typeof WAVE9_SHORT_STRATEGY;
+export declare const WAVE9_SYMBOL_PRIORITY: readonly ["BTCUSDT", "ETHUSDT", "SOLUSDT", "BNBUSDT", "XRPUSDT", "DOGEUSDT", "ADAUSDT", "LINKUSDT"];
+export declare const WAVE9_STRATEGY_PRIORITY: readonly ["tsmom_28d_long_flat_reversal_1d", "tsmom_28d_short_flat_reversal_1d"];
+export interface Wave9EntrySignal {
+    strategy: Wave9StrategyName;
+    direction: Direction;
+    stopPrice: number;
+}
+export interface Wave9DailyDecision {
+    eventTime: string;
+    completedDailyOpen: string;
+    currentReturn: number;
+    previousReturn: number;
+    atr14: number;
+    referencePrice: number;
+    entries: Wave9EntrySignal[];
+    exitLong: boolean;
+    exitShort: boolean;
+    sourceBarCount: 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 declare function completedDailyContext(rawBars: readonly OhlcvBar[], eventTime: Date): OhlcvBar[];
+/** Evaluate the exact Wave 9 entry-transition and signal-reversal semantics. */
+export declare function evaluateWave9Daily(rawBars: readonly OhlcvBar[], eventTime: Date): Wave9DailyDecision;

package/portfolio/wave9-policy.js

@@ -0,0 +1,183 @@
+// ⚠️ 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/signals/conditions/registry.js

@@ -160,11 +160,20 @@ register('price_sweep', (ctx, params, _dir, condCtx) => {
             sweepLevel = nearestHigh;
         }
     }
-    // Store in shared context for entry/stop rules and direction
+    // Store in shared context for entry/stop rules and direction.
+    // sweptDirection is written non-destructively, like the funding_extreme /
+    // cvd_divergence setters: only when a sweep actually resolved a side. An
+    // unconditional write (including null on a no-sweep bar) clobbered a
+    // direction set by an earlier condition in the same evaluation, so a
+    // from_sweep/from_funding strategy listing price_sweep AFTER another
+    // setter could never fire.
     condCtx.sweepLevel = sweepLevel;
     condCtx.recentLow = recentLow;
     condCtx.recentHigh = recentHigh;
-    condCtx.sweptDirection = sweptLow ? 'LONG' : sweptHigh ? 'SHORT' : null;
+    if (sweptLow)
+        condCtx.sweptDirection = 'LONG';
+    else if (sweptHigh)
+        condCtx.sweptDirection = 'SHORT';
     const met = sweptLow || sweptHigh;
     return {
         met,
@@ -777,6 +786,56 @@ register('return_momentum', (ctx, params, direction) => {
             : `${lookback}-bar ${tfHours}h return ${(ret * 100).toFixed(2)}% fails ${label} threshold ${(minReturnPct * 100).toFixed(1)}%${capText}`,
     };
 });
+// Strict return-momentum episode transition. Unlike return_momentum, this is
+// an event rather than a level: it fires once when the lookback return crosses
+// zero (or an explicit threshold), then remains false until the sign resets.
+// That makes stop-outs and capacity-rejected entries naturally lock out for
+// the rest of the same momentum episode.
+register('return_momentum_zero_cross', (ctx, params, direction) => {
+    const lookback = Math.max(1, Math.floor(params.lookback ?? 28));
+    const thresholdPct = Math.max(0, params.thresholdPct ?? 0);
+    const dirSign = params.dirSign ?? 0;
+    const tfHours = params.tfHours ?? 24;
+    const bars = pickBars(ctx, tfHours);
+    if (bars.length <= lookback + 1) {
+        return {
+            met: false,
+            value: 0,
+            threshold: thresholdPct * 100,
+            description: `Insufficient ${tfHours}h bars for return_momentum_zero_cross`,
+        };
+    }
+    const currentClose = bars[bars.length - 1].close;
+    const currentPrior = bars[bars.length - 1 - lookback].close;
+    const previousClose = bars[bars.length - 2].close;
+    const previousPrior = bars[bars.length - 2 - lookback].close;
+    const currentReturn = currentPrior > 0
+        ? (currentClose - currentPrior) / currentPrior
+        : Number.NaN;
+    const previousReturn = previousPrior > 0
+        ? (previousClose - previousPrior) / previousPrior
+        : Number.NaN;
+    const sign = dirSign !== 0
+        ? Math.sign(dirSign)
+        : direction === 'LONG' ? 1 : direction === 'SHORT' ? -1 : 0;
+    const met = Number.isFinite(currentReturn)
+        && Number.isFinite(previousReturn)
+        && (sign > 0
+            ? previousReturn <= thresholdPct && currentReturn > thresholdPct
+            : sign < 0
+                ? previousReturn >= -thresholdPct && currentReturn < -thresholdPct
+                : false);
+    return {
+        met,
+        value: Number.isFinite(currentReturn)
+            ? Math.round(currentReturn * 10000) / 100
+            : 0,
+        threshold: thresholdPct * 100,
+        description: Number.isFinite(currentReturn) && Number.isFinite(previousReturn)
+            ? `${lookback}-bar ${tfHours}h return moved from ${(previousReturn * 100).toFixed(2)}% to ${(currentReturn * 100).toFixed(2)}%`
+            : `Invalid ${tfHours}h prices for return_momentum_zero_cross`,
+    };
+});
 // ─── 32. rsi_multi_pivot_divergence ──────────────────────────────────
 // Strict N-pivot RSI divergence: price makes successively lower lows (or
 // higher highs) while RSI makes the opposite, with optional volume dry-up

package/signals/strategy-adapter.js

@@ -170,15 +170,25 @@ export function adaptStrategy(config, gateNamespace) {
             const { conditions: pass1, condCtx } = evaluateConditions(config.conditions, ectx, null);
             // Determine direction
             const direction = resolveDirection(config.directionRule, ectx, condCtx);
-            // Pass 2: re-evaluate direction-sensitive conditions now that we know direction
-            // (orderbook_imbalance and funding_contrarian behave differently per direction)
-            const directionSensitive = new Set(['orderbook_imbalance', 'funding_contrarian', 'funding_extreme_skip', 'funding_position_ok', 'return_momentum']);
-            const hasDirSensitive = config.conditions.some(c => directionSensitive.has(c.type));
+            // Pass 2: once the direction is known, re-evaluate the FULL condition
+            // array with it. Many registry conditions branch on `direction`
+            // (orderbook_imbalance, funding_contrarian, macd_crossover,
+            // bollinger_breakout, vwap_position, stoch_rsi_extreme, ichimoku_cloud,
+            // supertrend_direction, …) and their pass-1 result was computed against
+            // direction=null — typically the permissive either-side branch. A
+            // hand-curated allowlist here (the pre-fix 5-type set) silently drifted
+            // out of sync with the registry, so non-listed direction-dependent
+            // conditions kept their permissive pass-1 result forever (e.g. a
+            // fixed_long strategy's macd_crossover accepted a BEARISH crossover).
+            // Pass 2 always evaluated the whole array anyway — use it wholesale.
+            // Direction-insensitive conditions are pure functions of (ctx, params)
+            // and return identical results in both passes; entry/stop computation
+            // below deliberately keeps pass 1's condCtx (setter values don't depend
+            // on direction).
             let finalConditions = pass1;
-            if (direction && hasDirSensitive) {
+            if (direction) {
                 const { conditions: pass2 } = evaluateConditions(config.conditions, ectx, direction);
-                // Merge: use pass2 results for direction-sensitive, pass1 for others
-                finalConditions = pass1.map((c, i) => directionSensitive.has(config.conditions[i].type) ? pass2[i] : c);
+                finalConditions = pass2;
             }
             const allMet = finalConditions.every(c => c.met);
             let trade;

package/simulator/exchange-simulator.d.ts

@@ -79,6 +79,18 @@ export declare class ExchangeSimulator extends EventEmitter {
      *  reload never regresses the agent's give-back signal. */
     replaceState(newState: SimulatorState): void;
     getState(): SimulatorState;
+    /** Default max quote age a NEW-exposure fill may price against (issue #202).
+     *  Generous vs the 5s paper feed cadence; env RC_PAPER_MAX_QUOTE_AGE_MS
+     *  overrides. */
+    static readonly DEFAULT_MAX_QUOTE_AGE_MS = 45000;
+    private maxQuoteAgeMs;
+    /** Quote age from the ticker's own timestamp. A missing/invalid timestamp
+     *  reads as age 0 (fail-open — the guard cannot fire on it). */
+    private quoteAgeMs;
+    /** Reject fills that would OPEN or GROW exposure on a stale quote. Risk-
+     *  reducing fills (closes/partials against an existing position) are always
+     *  allowed — blocking a close on a broken feed compounds the risk. */
+    private assertQuoteFresh;
     private shouldFillLimit;
     private executeMarketFill;
     private executeLimitFill;