@reefclaw/openclaw-plugin 0.1.4 → 0.1.6

package/onboarding/runtime.js

@@ -55,6 +55,8 @@ export class PluginRuntime {
      *  stops fire and NAV/uPnL stay live for non-dashboard symbols). Lives for
      *  the runtime's lifetime; started in paper, stopped in live. */
     _marketFeed;
+    operationLock;
+    wave9LiveLifecycleHooks;
     /** Reconnect is serialized — a second caller waits for the first to finish
      *  so we never tear down an adapter that's mid-rebuild. */
     reconnectInFlight = null;
@@ -64,11 +66,21 @@ export class PluginRuntime {
         this.simulator = initial.simulator;
         this._stopWatcher = initial.stopWatcher ?? null;
         this._marketFeed = initial.marketFeed ?? null;
+        this.operationLock = initial.operationLock;
     }
     get adapter() { return this._adapter; }
     get mode() { return this._mode; }
     get stopWatcher() { return this._stopWatcher; }
     get marketFeed() { return this._marketFeed; }
+    setWave9LiveLifecycleHooks(hooks) {
+        this.wave9LiveLifecycleHooks = hooks;
+        if (this._adapter instanceof LiveAdapter) {
+            hooks?.configureLiveAdapter?.(this._adapter);
+        }
+        if (this._stopWatcher) {
+            hooks?.configurePositionWatcher?.(this._stopWatcher, this._adapter);
+        }
+    }
     /**
      * Swap the current adapter for a new one built from `next`. The old
      * adapter's background loops are stopped before the new one is wired in.
@@ -82,7 +94,9 @@ export class PluginRuntime {
         if (this.reconnectInFlight) {
             await this.reconnectInFlight;
         }
-        const run = this.doReconnect(next, deps);
+        const run = this.operationLock
+            ? this.operationLock.withAccountLock('runtime-reconnect', () => this.doReconnect(next, deps))
+            : this.doReconnect(next, deps);
         this.reconnectInFlight = run.finally(() => {
             this.reconnectInFlight = null;
         });
@@ -117,6 +131,11 @@ export class PluginRuntime {
             microLive: next.microLive,
             simulator: this.simulator,
         });
+        // Install autonomous protection callbacks before initialization can emit
+        // user-data or bracket-reconciler events.
+        if (fresh instanceof LiveAdapter) {
+            this.wave9LiveLifecycleHooks?.configureLiveAdapter?.(fresh);
+        }
         // 4. Fire async init for live adapters (non-blocking — readiness flips
         //    INIT_PENDING → READY/DEGRADED/BLOCKED on its own).
         if (fresh instanceof LiveAdapter) {
@@ -134,7 +153,8 @@ export class PluginRuntime {
         this._mode = next.mode;
         deps.adapterDeps.adapter = fresh;
         // 6. Start a new stop-watcher bound to the new adapter.
-        const watcher = new PositionWatcher(fresh);
+        const watcher = new PositionWatcher(fresh, undefined, this.operationLock);
+        this.wave9LiveLifecycleHooks?.configurePositionWatcher?.(watcher, fresh);
         watcher.start();
         this._stopWatcher = watcher;
         // 7. Paper market feed follows the mode: run it when the new adapter is

package/openclaw.plugin.json

@@ -36,6 +36,7 @@
       "get_market_intel",
       "get_regime",
       "get_signals",
+      "get_wave9_status",
       "get_analytics",
       "get_orderbook",
       "get_volume_profile",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reefclaw/openclaw-plugin",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "ReefClaw trading plugin for OpenClaw \u2014 paper trading with real Binance market data, plus the ReefClaw dashboard connector (supervised by OpenClaw, no service manager needed). Install: /plugins install clawhub:@reefclaw/openclaw-plugin",
   "type": "module",
   "main": "index.js",

package/persistence/state-manager.d.ts

@@ -39,4 +39,28 @@ export declare class StateManager {
     loadSync(): SimulatorState | null;
     /** Synchronous load-or-create-default — for use in synchronous plugin register(). */
     loadOrDefaultSync(startingBalance: number, quoteCurrency: string): SimulatorState;
+    private saveSyncSafe;
 }
+export interface PaperQuoteMigrationResult {
+    state: SimulatorState;
+    migrated: boolean;
+    fromQuote: string;
+    releasedPositions: number;
+    droppedOrders: number;
+}
+/** Migrate a persisted paper state whose quote currency no longer matches the
+ *  configured venue's (issue #174 — e.g. a USDT wallet after switching to the
+ *  USDC-quoted hyperliquid venue). Pure; returns the input untouched when the
+ *  quotes already match.
+ *
+ *  Semantics (equity-preserving):
+ *  - Open positions are released at their entry price: opening deducted the
+ *    full entry notional from the wallet (spot-collateral model), so that
+ *    notional is credited back before the position rows — which reference the
+ *    OLD venue's symbols and are unpriceable on the new one — are dropped.
+ *  - Unfilled open orders never debited the wallet (fills do) — just dropped.
+ *  - Balances carry 1:1 (USDT↔USDC are both dollar stables; paper precision),
+ *    merging into any existing balance under the new quote.
+ *  - Trade history is kept (display-only). savedAt is bumped so the other
+ *    process's replaceState() staleness guard accepts the migrated snapshot. */
+export declare function migratePaperQuoteCurrency(state: SimulatorState, expectedQuote: string): PaperQuoteMigrationResult;

package/persistence/state-manager.js

@@ -144,11 +144,26 @@ export class StateManager {
     /** Synchronous load-or-create-default — for use in synchronous plugin register(). */
     loadOrDefaultSync(startingBalance, quoteCurrency) {
         const loaded = this.loadSync();
-        if (loaded)
-            return loaded;
+        if (loaded) {
+            // Venue switch heal (issue #174): a persisted wallet quoted in the OLD
+            // venue's currency reads as $0 equity on the new venue. Migrate 1:1
+            // (USDT↔USDC), preserving total equity exactly.
+            const mig = migratePaperQuoteCurrency(loaded, quoteCurrency);
+            if (mig.migrated) {
+                logger.info(TAG, `Paper wallet quote migrated ${mig.fromQuote} → ${quoteCurrency} (venue switch): ` +
+                    `released ${mig.releasedPositions} open position(s) at entry price, ` +
+                    `dropped ${mig.droppedOrders} unfilled order(s), balances carried 1:1`);
+                this.saveSyncSafe(mig.state, 'migrated');
+            }
+            return mig.state;
+        }
         const state = createDefaultState(startingBalance, quoteCurrency);
         logger.info(TAG, `Initialized default state: ${startingBalance} ${quoteCurrency}`);
         // Save synchronously so state persists immediately
+        this.saveSyncSafe(state, 'initial');
+        return state;
+    }
+    saveSyncSafe(state, label) {
         try {
             const dir = dirname(this.statePath);
             if (!existsSync(dir)) {
@@ -157,8 +172,51 @@ export class StateManager {
             writeFileSync(this.statePath, JSON.stringify(state, null, 2), 'utf-8');
         }
         catch (err) {
-            logger.error(TAG, `Failed to save initial state: ${err instanceof Error ? err.message : String(err)}`);
+            logger.error(TAG, `Failed to save ${label} state: ${err instanceof Error ? err.message : String(err)}`);
         }
-        return state;
     }
 }
+/** Migrate a persisted paper state whose quote currency no longer matches the
+ *  configured venue's (issue #174 — e.g. a USDT wallet after switching to the
+ *  USDC-quoted hyperliquid venue). Pure; returns the input untouched when the
+ *  quotes already match.
+ *
+ *  Semantics (equity-preserving):
+ *  - Open positions are released at their entry price: opening deducted the
+ *    full entry notional from the wallet (spot-collateral model), so that
+ *    notional is credited back before the position rows — which reference the
+ *    OLD venue's symbols and are unpriceable on the new one — are dropped.
+ *  - Unfilled open orders never debited the wallet (fills do) — just dropped.
+ *  - Balances carry 1:1 (USDT↔USDC are both dollar stables; paper precision),
+ *    merging into any existing balance under the new quote.
+ *  - Trade history is kept (display-only). savedAt is bumped so the other
+ *    process's replaceState() staleness guard accepts the migrated snapshot. */
+export function migratePaperQuoteCurrency(state, expectedQuote) {
+    const fromQuote = state.config?.quoteCurrency ?? 'USDT';
+    if (fromQuote === expectedQuote) {
+        return { state, migrated: false, fromQuote, releasedPositions: 0, droppedOrders: 0 };
+    }
+    const next = JSON.parse(JSON.stringify(state));
+    next.config = { ...next.config, quoteCurrency: expectedQuote };
+    const old = next.wallet[fromQuote] ?? { total: 0, available: 0, locked: 0 };
+    let releasedPositions = 0;
+    for (const pos of next.positions ?? []) {
+        const notional = pos.entryPrice * pos.quantity;
+        if (Number.isFinite(notional) && notional > 0) {
+            old.total += notional;
+            old.available += notional;
+        }
+        releasedPositions++;
+    }
+    const droppedOrders = (next.openOrders ?? []).length;
+    next.positions = [];
+    next.openOrders = [];
+    const target = next.wallet[expectedQuote] ?? { total: 0, available: 0, locked: 0 };
+    target.total += old.total;
+    target.available += old.available;
+    target.locked += old.locked;
+    next.wallet[expectedQuote] = target;
+    delete next.wallet[fromQuote];
+    next.savedAt = Date.now();
+    return { state: next, migrated: true, fromQuote, releasedPositions, droppedOrders };
+}

package/portfolio/wave9-admission.d.ts

@@ -0,0 +1,67 @@
+import type { Direction } from '../signals/types.js';
+import { type Wave9StrategyName } from './wave9-policy.js';
+export interface Wave9AdmissionPolicy {
+    riskPct: number;
+    maxPositions: number;
+    maxOpenRiskPct: number;
+    maxGrossExposureMultiple: number;
+    maxPositionUsd: number;
+    feeBps: number;
+    slippageBps: number;
+    capEnforcement: 'admission_only_no_forced_deleveraging';
+    riskMeasure: 'fixed_initial_stop_risk_usd';
+}
+export declare const WAVE9_ADMISSION_POLICY: Readonly<Wave9AdmissionPolicy>;
+export interface Wave9AdmissionPosition {
+    candidateId: string;
+    symbol: string;
+    strategy: Wave9StrategyName;
+    direction: Direction;
+    entryPrice: number;
+    quantity: number;
+    markPrice: number;
+    initialStop: number;
+    dollarRiskUsd: number;
+    accruedFundingUsd: number;
+}
+export interface Wave9AdmissionState {
+    cashEquityUsd: number;
+    positions: Wave9AdmissionPosition[];
+}
+export interface Wave9AdmissionCandidate {
+    id: string;
+    eventTime: string;
+    symbol: string;
+    strategy: Wave9StrategyName;
+    direction: Direction;
+    referencePrice: number;
+    stopPrice: number;
+}
+export type Wave9AdmissionReason = 'accepted' | 'invalidGeometry' | 'symbolAlreadyOpen' | 'maxPositions' | 'maxGrossExposure' | 'maxOpenRisk' | 'invalidSizing';
+export interface Wave9AdmissionLedgerRow extends Wave9AdmissionPosition {
+    estimatedExitCostUsd: number;
+}
+export interface Wave9AdmissionDecision extends Wave9AdmissionCandidate {
+    accepted: boolean;
+    reason: Wave9AdmissionReason;
+    entryPrice?: number;
+    quantity?: number;
+    notionalUsd?: number;
+    riskUsd?: number;
+    projectedCashEquityUsd?: number;
+    projectedLiquidationEquityUsd?: number;
+    projectedGrossExposureUsd?: number;
+    projectedOpenRiskUsd?: number;
+    projectedOpenPositions?: number;
+    projectedPositionLedger?: Wave9AdmissionLedgerRow[];
+}
+export interface Wave9AdmissionBatchResult {
+    decisions: Wave9AdmissionDecision[];
+    state: Wave9AdmissionState;
+}
+/**
+ * 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 declare function applyWave9AdmissionBatch(inputState: Wave9AdmissionState, rawCandidates: readonly Wave9AdmissionCandidate[], policy?: Readonly<Wave9AdmissionPolicy>): Wave9AdmissionBatchResult;

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;