@reefclaw/connect 0.1.0

package/assets/shared/signals/conditions/types.d.ts

@@ -0,0 +1,65 @@
+import type { MarketContext, Direction } from '../types.js';
+/** Result from evaluating a single condition */
+export interface ConditionResult {
+    met: boolean;
+    value: number;
+    threshold: number;
+    description: string;
+}
+/** Shared context passed between conditions in a single evaluation.
+ *  Some conditions produce data needed by entry/stop rules (e.g., sweep level). */
+export interface ConditionContext {
+    sweepLevel?: number;
+    recentLow?: number;
+    recentHigh?: number;
+    sweptDirection?: Direction | null;
+    ema21?: number;
+}
+/** A condition function: takes market context + params, returns result */
+export type ConditionFn = (ctx: MarketContext, params: Record<string, number>, direction: Direction | null, condCtx: ConditionContext) => ConditionResult;
+/** Config for a single condition in a strategy */
+export interface ConditionConfig {
+    type: string;
+    params: Record<string, number>;
+}
+/** Entry zone calculation rule */
+export interface EntryRuleConfig {
+    type: 'ema_offset' | 'sweep_range' | 'atr_offset';
+    params: Record<string, number>;
+}
+/** Stop level calculation rule */
+export interface StopRuleConfig {
+    type: 'swing_atr' | 'recent_extreme_atr' | 'fixed_atr';
+    params: Record<string, number>;
+}
+/** Direction determination rule */
+export type DirectionRule = 'from_regime' | 'from_sweep' | 'from_funding' | 'fixed_long' | 'fixed_short';
+/** Primary timeframe a strategy operates on. Default '1h' (the only
+ *  timeframe the live engine fetched before Phase B). When set to '4h' or
+ *  '1d', the strategy adapter will only re-evaluate the strategy when a new
+ *  bar at that timeframe has closed since the last evaluation, and
+ *  conditions inside the strategy are expected to read from
+ *  ctx.ohlcv4h/ohlcv1d rather than ctx.ohlcv1h. */
+export type PrimaryTimeframe = '1h' | '4h' | '1d';
+/** Full declarative strategy configuration (stored as JSON in DB) */
+export interface StrategyConfig {
+    name: string;
+    description: string;
+    version: number;
+    regimeWhitelist: string[];
+    minConfidence: number;
+    directionRule: DirectionRule;
+    conditions: ConditionConfig[];
+    entryRule: EntryRuleConfig;
+    stopRule: StopRuleConfig;
+    targetRMultiples: number[];
+    expiryMs?: number;
+    cooldownMs?: number;
+    /** Higher-timeframe gating. When set, the strategy is only re-evaluated
+     *  on closed bars of that timeframe. Defaults to '1h'. */
+    primaryTimeframe?: PrimaryTimeframe;
+    /** Conditions that, if ANY are met, cause the strategy to be skipped this
+     *  tick. Evaluated before the main `conditions` list. Used for global
+     *  filters like "skip if BTC daily RSI > 70". */
+    skipIf?: ConditionConfig[];
+}

package/assets/shared/signals/conditions/types.js

@@ -0,0 +1,8 @@
+// Condition-library + strategy-config types — canonical source of truth shared
+// by the intel signal engine and the plugin-side evaluator (facts-out). The
+// DB/backtest-only types (StrategyBacktestResult, BacktestResultMap, StrategyRow)
+// stay intel-side in intelligence/src/signals/conditions/types.ts, which
+// re-exports everything here.
+//
+// PURE TYPES ONLY — erase at runtime.
+export {};

package/assets/shared/signals/direction-rules.d.ts

@@ -0,0 +1,3 @@
+import type { MarketContext, Direction } from './types.js';
+import type { ConditionContext, DirectionRule } from './conditions/types.js';
+export declare function resolveDirection(rule: DirectionRule, ctx: MarketContext, condCtx: ConditionContext): Direction | null;

package/assets/shared/signals/direction-rules.js

@@ -0,0 +1,18 @@
+// Direction determination rules for declarative strategies.
+export function resolveDirection(rule, ctx, condCtx) {
+    switch (rule) {
+        case 'from_regime':
+            return ctx.regime === 'TREND_UP' ? 'LONG' : ctx.regime === 'TREND_DOWN' ? 'SHORT' : null;
+        case 'from_sweep':
+            return condCtx.sweptDirection ?? null;
+        case 'from_funding':
+            // funding_extreme condition sets sweptDirection to the contra direction
+            return condCtx.sweptDirection ?? null;
+        case 'fixed_long':
+            return 'LONG';
+        case 'fixed_short':
+            return 'SHORT';
+        default:
+            return null;
+    }
+}

package/assets/shared/signals/entry-rules.d.ts

@@ -0,0 +1,6 @@
+import type { MarketContext, Direction } from './types.js';
+import type { EntryRuleConfig, ConditionContext } from './conditions/types.js';
+export declare function computeEntry(rule: EntryRuleConfig, ctx: MarketContext, direction: Direction, condCtx: ConditionContext): {
+    low: number;
+    high: number;
+};

package/assets/shared/signals/entry-rules.js

@@ -0,0 +1,26 @@
+// Entry zone calculation for declarative strategies.
+import { computeEMA } from '../shared/indicators.js';
+export function computeEntry(rule, ctx, direction, condCtx) {
+    switch (rule.type) {
+        case 'ema_offset': {
+            const period = rule.params.period ?? 21;
+            const atrFraction = (rule.params.atrFraction ?? 0.3) * ctx.atr14;
+            const ema = condCtx.ema21 && period === 21
+                ? condCtx.ema21
+                : computeEMA(ctx.ohlcv1h.map(b => b.close), period);
+            return { low: ema - atrFraction, high: ema + atrFraction };
+        }
+        case 'sweep_range': {
+            const sweepLevel = condCtx.sweepLevel ?? ctx.currentPrice;
+            return direction === 'LONG'
+                ? { low: sweepLevel, high: ctx.currentPrice }
+                : { low: ctx.currentPrice, high: sweepLevel };
+        }
+        case 'atr_offset': {
+            const atrFraction = (rule.params.atrFraction ?? 0.2) * ctx.atr14;
+            return { low: ctx.currentPrice - atrFraction, high: ctx.currentPrice + atrFraction };
+        }
+        default:
+            return { low: ctx.currentPrice - ctx.atr14 * 0.3, high: ctx.currentPrice + ctx.atr14 * 0.3 };
+    }
+}

package/assets/shared/signals/indicators-extended.d.ts

@@ -0,0 +1,52 @@
+export interface OhlcvInput {
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+}
+export interface MACDResult {
+    line: number;
+    signal: number;
+    histogram: number;
+    crossover: 'bullish' | 'bearish' | 'none';
+}
+export interface BollingerResult {
+    upper: number;
+    middle: number;
+    lower: number;
+    bandwidth: number;
+    percentB: number;
+}
+export interface StochRSIResult {
+    k: number;
+    d: number;
+}
+export interface IchimokuResult {
+    tenkan: number;
+    kijun: number;
+    senkouA: number;
+    senkouB: number;
+    chikou: number;
+    cloudPosition: 'above' | 'below' | 'inside';
+}
+export interface SupertrendResult {
+    value: number;
+    direction: 'bullish' | 'bearish';
+}
+export declare function computeMACD(closes: number[], fast?: number, slow?: number, signal?: number): MACDResult;
+export declare function computeBollingerBands(closes: number[], period?: number, stdDev?: number): BollingerResult;
+export declare function computeVWAP(bars: OhlcvInput[]): number;
+export declare function computeStochRSI(closes: number[], rsiPeriod?: number, stochPeriod?: number, kSmooth?: number, dSmooth?: number): StochRSIResult;
+export declare function computeADX(highs: number[], lows: number[], closes: number[], period?: number): {
+    adx: number;
+    plusDI: number;
+    minusDI: number;
+};
+export declare function computeIchimoku(highs: number[], lows: number[], closes: number[], tenkanPeriod?: number, kijunPeriod?: number, senkouBPeriod?: number): IchimokuResult;
+export declare function computeOBV(closes: number[], volumes: number[]): {
+    obv: number;
+    slope: 'rising' | 'falling' | 'flat';
+};
+export declare function computeSupertrend(highs: number[], lows: number[], closes: number[], period?: number, multiplier?: number): SupertrendResult;
+export declare function computeWilliamsR(highs: number[], lows: number[], closes: number[], period?: number): number;

package/assets/shared/signals/indicators-extended.js

@@ -0,0 +1,284 @@
+// Extended indicator computations for Phase 13 — Expanded Indicators.
+// Wraps technicalindicators library + custom implementations.
+// All functions take OHLCV arrays (oldest first) and return latest values.
+import { computeATRSeries, computeRSI, mean, computeStd } from './indicators.js';
+// ─── MACD (12, 26, 9) ──────────────────────────────────────────────────
+export function computeMACD(closes, fast = 12, slow = 26, signal = 9) {
+    if (closes.length < slow + signal) {
+        return { line: 0, signal: 0, histogram: 0, crossover: 'none' };
+    }
+    // Compute full EMA series (both aligned to start at index `slow - 1`)
+    const emaFastSeries = emaSeries(closes, fast);
+    const emaSlowSeries = emaSeries(closes, slow);
+    // Align: fast series starts earlier, so take the tail matching slow series length
+    const offset = emaFastSeries.length - emaSlowSeries.length;
+    const macdLine = [];
+    for (let i = 0; i < emaSlowSeries.length; i++) {
+        macdLine.push(emaFastSeries[i + offset] - emaSlowSeries[i]);
+    }
+    // Signal line = EMA of MACD line
+    const signalSeries = emaSeries(macdLine, signal);
+    const sigOffset = macdLine.length - signalSeries.length;
+    const currentLine = macdLine[macdLine.length - 1];
+    const currentSignal = signalSeries[signalSeries.length - 1];
+    const prevLine = macdLine.length >= 2 ? macdLine[macdLine.length - 2] : currentLine;
+    const prevSignalIdx = signalSeries.length >= 2 ? signalSeries.length - 2 : signalSeries.length - 1;
+    const prevSignal = signalSeries[prevSignalIdx];
+    let crossover = 'none';
+    if (prevLine <= prevSignal && currentLine > currentSignal)
+        crossover = 'bullish';
+    else if (prevLine >= prevSignal && currentLine < currentSignal)
+        crossover = 'bearish';
+    return {
+        line: currentLine,
+        signal: currentSignal,
+        histogram: currentLine - currentSignal,
+        crossover,
+    };
+}
+// ─── Bollinger Bands (20, 2σ) ───────────────────────────────────────────
+export function computeBollingerBands(closes, period = 20, stdDev = 2) {
+    if (closes.length < period) {
+        const p = closes[closes.length - 1] ?? 0;
+        return { upper: p, middle: p, lower: p, bandwidth: 0, percentB: 0.5 };
+    }
+    const slice = closes.slice(-period);
+    const middle = mean(slice);
+    const std = computeStd(slice);
+    const upper = middle + stdDev * std;
+    const lower = middle - stdDev * std;
+    const bandwidth = middle > 0 ? ((upper - lower) / middle) * 100 : 0;
+    const price = closes[closes.length - 1];
+    const percentB = upper !== lower ? (price - lower) / (upper - lower) : 0.5;
+    return { upper, middle, lower, bandwidth, percentB };
+}
+// ─── VWAP ───────────────────────────────────────────────────────────────
+export function computeVWAP(bars) {
+    if (bars.length === 0)
+        return 0;
+    let cumVolume = 0;
+    let cumTPxVol = 0;
+    for (const bar of bars) {
+        const tp = (bar.high + bar.low + bar.close) / 3;
+        cumVolume += bar.volume;
+        cumTPxVol += tp * bar.volume;
+    }
+    return cumVolume > 0 ? cumTPxVol / cumVolume : bars[bars.length - 1].close;
+}
+// ─── Stochastic RSI (14, 14, 3, 3) ─────────────────────────────────────
+export function computeStochRSI(closes, rsiPeriod = 14, stochPeriod = 14, kSmooth = 3, dSmooth = 3) {
+    if (closes.length < rsiPeriod + stochPeriod + dSmooth) {
+        return { k: 50, d: 50 };
+    }
+    // Compute RSI series
+    const rsiValues = [];
+    for (let i = rsiPeriod + 1; i <= closes.length; i++) {
+        rsiValues.push(computeRSI(closes.slice(0, i), rsiPeriod));
+    }
+    if (rsiValues.length < stochPeriod)
+        return { k: 50, d: 50 };
+    // Stochastic of RSI
+    const rawK = [];
+    for (let i = stochPeriod - 1; i < rsiValues.length; i++) {
+        const window = rsiValues.slice(i - stochPeriod + 1, i + 1);
+        const min = Math.min(...window);
+        const max = Math.max(...window);
+        rawK.push(max !== min ? ((rsiValues[i] - min) / (max - min)) * 100 : 50);
+    }
+    // %K = SMA of raw stochastic
+    const kValues = sma(rawK, kSmooth);
+    // %D = SMA of %K
+    const dValues = sma(kValues, dSmooth);
+    return {
+        k: Math.round(kValues[kValues.length - 1] ?? 50),
+        d: Math.round(dValues[dValues.length - 1] ?? 50),
+    };
+}
+// ─── ADX (14) ───────────────────────────────────────────────────────────
+export function computeADX(highs, lows, closes, period = 14) {
+    if (highs.length < period * 2 + 1) {
+        return { adx: 0, plusDI: 0, minusDI: 0 };
+    }
+    const plusDM = [];
+    const minusDM = [];
+    const tr = [];
+    for (let i = 1; i < highs.length; i++) {
+        const upMove = highs[i] - highs[i - 1];
+        const downMove = lows[i - 1] - lows[i];
+        plusDM.push(upMove > downMove && upMove > 0 ? upMove : 0);
+        minusDM.push(downMove > upMove && downMove > 0 ? downMove : 0);
+        tr.push(Math.max(highs[i] - lows[i], Math.abs(highs[i] - closes[i - 1]), Math.abs(lows[i] - closes[i - 1])));
+    }
+    // Smooth with Wilder's smoothing (equivalent to EMA with alpha=1/period)
+    const smoothPlusDM = wilderSmooth(plusDM, period);
+    const smoothMinusDM = wilderSmooth(minusDM, period);
+    const smoothTR = wilderSmooth(tr, period);
+    // +DI and -DI series
+    const plusDISeries = [];
+    const minusDISeries = [];
+    for (let i = 0; i < smoothTR.length; i++) {
+        plusDISeries.push(smoothTR[i] > 0 ? (smoothPlusDM[i] / smoothTR[i]) * 100 : 0);
+        minusDISeries.push(smoothTR[i] > 0 ? (smoothMinusDM[i] / smoothTR[i]) * 100 : 0);
+    }
+    // DX series
+    const dxSeries = [];
+    for (let i = 0; i < plusDISeries.length; i++) {
+        const sum = plusDISeries[i] + minusDISeries[i];
+        dxSeries.push(sum > 0 ? (Math.abs(plusDISeries[i] - minusDISeries[i]) / sum) * 100 : 0);
+    }
+    // ADX = Wilder smooth of DX
+    const adxSeries = wilderSmooth(dxSeries, period);
+    return {
+        adx: Math.round(adxSeries[adxSeries.length - 1] ?? 0),
+        plusDI: Math.round(plusDISeries[plusDISeries.length - 1] ?? 0),
+        minusDI: Math.round(minusDISeries[minusDISeries.length - 1] ?? 0),
+    };
+}
+// ─── Ichimoku Cloud ─────────────────────────────────────────────────────
+export function computeIchimoku(highs, lows, closes, tenkanPeriod = 9, kijunPeriod = 26, senkouBPeriod = 52) {
+    const n = highs.length;
+    if (n < senkouBPeriod) {
+        const p = closes[n - 1] ?? 0;
+        return { tenkan: p, kijun: p, senkouA: p, senkouB: p, chikou: p, cloudPosition: 'inside' };
+    }
+    const midpoint = (arr, period, end) => {
+        const slice = arr.slice(Math.max(0, end - period + 1), end + 1);
+        return (Math.max(...slice) + Math.min(...slice)) / 2;
+    };
+    const tenkan = midpoint(highs.concat().map((h, i) => Math.max(h, lows[i])), tenkanPeriod, n - 1);
+    const kijun = midpoint(highs.concat().map((h, i) => Math.max(h, lows[i])), kijunPeriod, n - 1);
+    // Recalculate properly using highs and lows separately
+    const tenkanH = Math.max(...highs.slice(-tenkanPeriod));
+    const tenkanL = Math.min(...lows.slice(-tenkanPeriod));
+    const tenkanVal = (tenkanH + tenkanL) / 2;
+    const kijunH = Math.max(...highs.slice(-kijunPeriod));
+    const kijunL = Math.min(...lows.slice(-kijunPeriod));
+    const kijunVal = (kijunH + kijunL) / 2;
+    const senkouA = (tenkanVal + kijunVal) / 2;
+    const senkouBH = Math.max(...highs.slice(-senkouBPeriod));
+    const senkouBL = Math.min(...lows.slice(-senkouBPeriod));
+    const senkouB = (senkouBH + senkouBL) / 2;
+    const chikou = closes[n - 1]; // Current close (projected back 26 periods)
+    const price = closes[n - 1];
+    const cloudTop = Math.max(senkouA, senkouB);
+    const cloudBottom = Math.min(senkouA, senkouB);
+    const cloudPosition = price > cloudTop ? 'above' : price < cloudBottom ? 'below' : 'inside';
+    return { tenkan: tenkanVal, kijun: kijunVal, senkouA, senkouB, chikou, cloudPosition };
+}
+// ─── OBV (On-Balance Volume) ────────────────────────────────────────────
+export function computeOBV(closes, volumes) {
+    if (closes.length < 2)
+        return { obv: 0, slope: 'flat' };
+    let obv = 0;
+    const obvSeries = [0];
+    for (let i = 1; i < closes.length; i++) {
+        if (closes[i] > closes[i - 1])
+            obv += volumes[i];
+        else if (closes[i] < closes[i - 1])
+            obv -= volumes[i];
+        obvSeries.push(obv);
+    }
+    // Slope over last 10 bars
+    const lookback = Math.min(10, obvSeries.length);
+    const recent = obvSeries.slice(-lookback);
+    const first = recent[0];
+    const last = recent[recent.length - 1];
+    const threshold = Math.abs(first) * 0.01; // 1% threshold
+    const slope = last - first > threshold ? 'rising' : last - first < -threshold ? 'falling' : 'flat';
+    return { obv, slope };
+}
+// ─── Supertrend (10, 3) ─────────────────────────────────────────────────
+export function computeSupertrend(highs, lows, closes, period = 10, multiplier = 3) {
+    const atrSeries = computeATRSeries(highs, lows, closes, period);
+    if (atrSeries.length === 0) {
+        return { value: closes[closes.length - 1] ?? 0, direction: 'bullish' };
+    }
+    // ATR series starts at index 1 (needs previous close for TR)
+    // Align: atrSeries[i] corresponds to bar index i+1
+    let upperBand = 0;
+    let lowerBand = 0;
+    let supertrend = 0;
+    let direction = 'bullish';
+    for (let i = 0; i < atrSeries.length; i++) {
+        const barIdx = i + 1; // offset for TR calculation
+        const hl2 = (highs[barIdx] + lows[barIdx]) / 2;
+        const atr = atrSeries[i];
+        const basicUpper = hl2 + multiplier * atr;
+        const basicLower = hl2 - multiplier * atr;
+        upperBand = i > 0 && basicUpper < upperBand && closes[barIdx - 1] > upperBand ? upperBand : basicUpper;
+        lowerBand = i > 0 && basicLower > lowerBand && closes[barIdx - 1] < lowerBand ? lowerBand : basicLower;
+        if (i === 0) {
+            supertrend = closes[barIdx] > upperBand ? lowerBand : upperBand;
+            direction = closes[barIdx] > upperBand ? 'bullish' : 'bearish';
+        }
+        else {
+            if (direction === 'bullish') {
+                if (closes[barIdx] < lowerBand) {
+                    direction = 'bearish';
+                    supertrend = upperBand;
+                }
+                else {
+                    supertrend = lowerBand;
+                }
+            }
+            else {
+                if (closes[barIdx] > upperBand) {
+                    direction = 'bullish';
+                    supertrend = lowerBand;
+                }
+                else {
+                    supertrend = upperBand;
+                }
+            }
+        }
+    }
+    return { value: supertrend, direction };
+}
+// ─── Williams %R (14) ───────────────────────────────────────────────────
+export function computeWilliamsR(highs, lows, closes, period = 14) {
+    if (highs.length < period)
+        return -50;
+    const recentHighs = highs.slice(-period);
+    const recentLows = lows.slice(-period);
+    const hh = Math.max(...recentHighs);
+    const ll = Math.min(...recentLows);
+    const close = closes[closes.length - 1];
+    return hh !== ll ? ((hh - close) / (hh - ll)) * -100 : -50;
+}
+// ─── Helper: EMA series ─────────────────────────────────────────────────
+function emaSeries(data, period) {
+    if (data.length === 0)
+        return [];
+    if (data.length < period)
+        return [data[data.length - 1]];
+    const k = 2 / (period + 1);
+    const result = [];
+    let ema = mean(data.slice(0, period));
+    result.push(ema);
+    for (let i = period; i < data.length; i++) {
+        ema = data[i] * k + ema * (1 - k);
+        result.push(ema);
+    }
+    return result;
+}
+// ─── Helper: SMA series ─────────────────────────────────────────────────
+function sma(data, period) {
+    if (data.length < period)
+        return data.length > 0 ? [mean(data)] : [];
+    const result = [];
+    for (let i = period - 1; i < data.length; i++) {
+        result.push(mean(data.slice(i - period + 1, i + 1)));
+    }
+    return result;
+}
+// ─── Helper: Wilder's smoothing ─────────────────────────────────────────
+function wilderSmooth(data, period) {
+    if (data.length < period)
+        return [];
+    const result = [];
+    result.push(mean(data.slice(0, period)));
+    for (let i = period; i < data.length; i++) {
+        result.push((result[result.length - 1] * (period - 1) + data[i]) / period);
+    }
+    return result;
+}

package/assets/shared/signals/indicators.d.ts

@@ -0,0 +1,15 @@
+export declare function computeEMA(data: number[], period: number): number;
+export declare function computeATR(highs: number[], lows: number[], closes: number[], period: number): number;
+export declare function computeATRSeries(highs: number[], lows: number[], closes: number[], period: number): number[];
+export declare function computeRSI(closes: number[], period: number): number;
+export declare function linearSlope(y: number[], x?: number[]): number;
+export declare function computeStd(data: number[]): number;
+export declare function mean(data: number[]): number;
+/** Find swing highs and lows from OHLCV bars (simple pivot-point method). */
+export declare function findSwingPoints(bars: {
+    high: number;
+    low: number;
+}[], lookback?: number): {
+    highs: number[];
+    lows: number[];
+};

package/assets/shared/signals/indicators.js

@@ -0,0 +1,107 @@
+// Shared indicator computation helpers.
+// Used by both regime feature engineering and signal condition evaluation.
+export function computeEMA(data, period) {
+    if (data.length < period)
+        return data[data.length - 1] ?? 0;
+    const k = 2 / (period + 1);
+    let ema = mean(data.slice(0, period));
+    for (let i = period; i < data.length; i++) {
+        ema = data[i] * k + ema * (1 - k);
+    }
+    return ema;
+}
+export function computeATR(highs, lows, closes, period) {
+    const series = computeATRSeries(highs, lows, closes, period);
+    return series[series.length - 1] ?? 0;
+}
+export function computeATRSeries(highs, lows, closes, period) {
+    if (highs.length < 2)
+        return [];
+    const tr = [];
+    for (let i = 1; i < highs.length; i++) {
+        tr.push(Math.max(highs[i] - lows[i], Math.abs(highs[i] - closes[i - 1]), Math.abs(lows[i] - closes[i - 1])));
+    }
+    const atr = [];
+    atr[0] = mean(tr.slice(0, period));
+    for (let i = 1; i < tr.length; i++) {
+        atr[i] = (atr[i - 1] * (period - 1) + tr[i]) / period;
+    }
+    return atr;
+}
+export function computeRSI(closes, period) {
+    if (closes.length < period + 1)
+        return 50;
+    const changes = [];
+    for (let i = 1; i < closes.length; i++) {
+        changes.push(closes[i] - closes[i - 1]);
+    }
+    let avgGain = 0;
+    let avgLoss = 0;
+    for (let i = 0; i < period; i++) {
+        if (changes[i] > 0)
+            avgGain += changes[i];
+        else
+            avgLoss -= changes[i];
+    }
+    avgGain /= period;
+    avgLoss /= period;
+    for (let i = period; i < changes.length; i++) {
+        const gain = changes[i] > 0 ? changes[i] : 0;
+        const loss = changes[i] < 0 ? -changes[i] : 0;
+        avgGain = (avgGain * (period - 1) + gain) / period;
+        avgLoss = (avgLoss * (period - 1) + loss) / period;
+    }
+    if (avgLoss === 0)
+        return 100;
+    const rs = avgGain / avgLoss;
+    return 100 - 100 / (1 + rs);
+}
+export function linearSlope(y, x) {
+    const n = y.length;
+    if (n < 2)
+        return 0;
+    const xs = x ?? Array.from({ length: n }, (_, i) => i);
+    const mx = mean(xs);
+    const my = mean(y);
+    let num = 0;
+    let den = 0;
+    for (let i = 0; i < n; i++) {
+        num += (xs[i] - mx) * (y[i] - my);
+        den += (xs[i] - mx) ** 2;
+    }
+    return den > 0 ? num / den : 0;
+}
+export function computeStd(data) {
+    if (data.length < 2)
+        return 0;
+    const avg = mean(data);
+    const variance = data.reduce((s, v) => s + (v - avg) ** 2, 0) / (data.length - 1);
+    return Math.sqrt(variance);
+}
+export function mean(data) {
+    if (data.length === 0)
+        return 0;
+    return data.reduce((s, v) => s + v, 0) / data.length;
+}
+/** Find swing highs and lows from OHLCV bars (simple pivot-point method). */
+export function findSwingPoints(bars, lookback = 5) {
+    const highs = [];
+    const lows = [];
+    for (let i = lookback; i < bars.length - lookback; i++) {
+        let isHigh = true;
+        let isLow = true;
+        for (let j = i - lookback; j <= i + lookback; j++) {
+            if (j === i)
+                continue;
+            if (bars[j].high >= bars[i].high)
+                isHigh = false;
+            if (bars[j].low <= bars[i].low)
+                isLow = false;
+        }
+        if (isHigh)
+            highs.push(bars[i].high);
+        if (isLow)
+            lows.push(bars[i].low);
+    }
+    return { highs, lows };
+}

package/assets/shared/signals/serialize-context.d.ts

@@ -0,0 +1,4 @@
+import type { MarketContext } from './types.js';
+export declare function serializeContext(ctx: MarketContext): string;
+/** Parse a streamed context and rehydrate every Date field. Throws on bad JSON. */
+export declare function deserializeContext(raw: string): MarketContext;

package/assets/shared/signals/serialize-context.js

@@ -0,0 +1,41 @@
+// Matched (de)serializer for streaming a MarketContext over the fact stream
+// (facts-out step 4). Canonical runtime code shared by the intel broadcaster
+// and the plugin subscriber so the wire round-trip is byte-identical.
+//
+// The Date rehydration is the same hazard guarded in the Redis context-cache:
+// JSON.parse returns Date fields (timestamp, every ohlcv*[].time,
+// tradeFlow[].bucket, globalContext.btcRsi14_1d_at) as STRINGS — handing the
+// strategy evaluator string-dates would corrupt indicators. deserializeContext
+// restores them. serialize is plain JSON (Dates → ISO via Date#toJSON).
+export function serializeContext(ctx) {
+    return JSON.stringify(ctx);
+}
+function reviveBars(bars) {
+    if (!Array.isArray(bars))
+        return undefined;
+    return bars.map((b) => ({ ...b, time: new Date(b.time) }));
+}
+/** Parse a streamed context and rehydrate every Date field. Throws on bad JSON. */
+export function deserializeContext(raw) {
+    const o = JSON.parse(raw);
+    o.timestamp = new Date(o.timestamp);
+    const oh1 = reviveBars(o.ohlcv1h);
+    if (oh1)
+        o.ohlcv1h = oh1;
+    const oh5 = reviveBars(o.ohlcv5m);
+    if (oh5)
+        o.ohlcv5m = oh5;
+    const oh4 = reviveBars(o.ohlcv4h);
+    if (oh4)
+        o.ohlcv4h = oh4;
+    const oh1d = reviveBars(o.ohlcv1d);
+    if (oh1d)
+        o.ohlcv1d = oh1d;
+    if (Array.isArray(o.tradeFlow)) {
+        o.tradeFlow = o.tradeFlow.map((t) => ({ ...t, bucket: new Date(t.bucket) }));
+    }
+    if (o.globalContext?.btcRsi14_1d_at) {
+        o.globalContext.btcRsi14_1d_at = new Date(o.globalContext.btcRsi14_1d_at);
+    }
+    return o;
+}

package/assets/shared/signals/stop-rules.d.ts

@@ -0,0 +1,3 @@
+import type { MarketContext, Direction } from './types.js';
+import type { StopRuleConfig, ConditionContext } from './conditions/types.js';
+export declare function computeStop(rule: StopRuleConfig, ctx: MarketContext, direction: Direction, condCtx: ConditionContext): number;