@reefclaw/connect 0.1.10 → 0.1.12

package/assets/plugin/persistence/state-manager.js

@@ -1,222 +0,0 @@
-// State persistence manager for the paper trading simulator.
-// Saves/loads state to ~/.openclaw/plugins/reefclaw-paper-trading/state.json
-// Uses atomic writes (temp file + rename) to prevent corruption.
-import { readFile, writeFile, rename, mkdir, unlink } from 'node:fs/promises';
-import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join, dirname } from 'node:path';
-import { randomUUID } from 'node:crypto';
-import { logger } from '../logger.js';
-import { createDefaultState } from '../simulator/types.js';
-const TAG = 'state-manager';
-export class StateManager {
-    statePath;
-    saveTimer = null;
-    pendingState = null;
-    constructor(pluginId, baseDir) {
-        const base = baseDir ?? join(homedir(), '.openclaw', 'plugins', pluginId);
-        this.statePath = join(base, 'state.json');
-    }
-    getStatePath() {
-        return this.statePath;
-    }
-    /** Quarantine a state file that exists but won't parse, instead of letting
-     *  the caller silently overwrite it with a fresh default (which would wipe
-     *  the positions/orders/realized-PnL ledger). The corrupt bytes are renamed
-     *  to `<state>.corrupt-<ts>` so an operator can recover them. Returns true if
-     *  a corrupt file was quarantined. */
-    quarantineCorruptSync() {
-        if (!existsSync(this.statePath))
-            return false;
-        const dest = `${this.statePath}.corrupt-${Date.now()}`;
-        try {
-            renameSync(this.statePath, dest);
-            logger.error(TAG, `State file at ${this.statePath} is unreadable/corrupt — quarantined to ${dest}. NOT resetting silently; a fresh default will be used. Investigate before trading.`);
-        }
-        catch (err) {
-            logger.error(TAG, `State file at ${this.statePath} is corrupt AND could not be quarantined: ${err instanceof Error ? err.message : String(err)}`);
-        }
-        return true;
-    }
-    /** Load state from disk. Returns null when the file is MISSING (fresh start)
-     *  OR when it exists-but-is-unreadable (in which case the corrupt bytes are
-     *  quarantined first — never silently discarded). The two cases are
-     *  distinguished in the log; both yield null so the caller seeds a default,
-     *  but a corrupt file is preserved as `<state>.corrupt-<ts>`. */
-    async load() {
-        if (!existsSync(this.statePath)) {
-            logger.info(TAG, `No state file found at ${this.statePath}`);
-            return null;
-        }
-        try {
-            const raw = await readFile(this.statePath, 'utf-8');
-            const state = JSON.parse(raw);
-            logger.info(TAG, `Loaded state: ${state.positions.length} positions, ${state.openOrders.length} orders, ${state.tradeHistory.length} trades`);
-            return state;
-        }
-        catch {
-            // Exists but unreadable/corrupt — preserve, don't silently reset.
-            this.quarantineCorruptSync();
-            return null;
-        }
-    }
-    /** Save state atomically (write to a UNIQUE temp, rename to final). A unique
-     *  temp name (pid + uuid) is essential under the two-process model: both the
-     *  agent and gateway processes wire stateChanged→save, and a shared
-     *  `<state>.tmp` let their concurrent writes interleave into a torn file that
-     *  then parses as garbage on next boot. With a per-write temp, the worst case
-     *  degrades to a harmless last-writer-wins rename of two COMPLETE files. */
-    async save(state) {
-        const tmpPath = `${this.statePath}.${process.pid}.${randomUUID()}.tmp`;
-        try {
-            const dir = dirname(this.statePath);
-            if (!existsSync(dir)) {
-                await mkdir(dir, { recursive: true });
-            }
-            await writeFile(tmpPath, JSON.stringify(state, null, 2), 'utf-8');
-            await rename(tmpPath, this.statePath);
-            logger.debug(TAG, 'State saved');
-        }
-        catch (err) {
-            logger.error(TAG, `Failed to save state: ${err instanceof Error ? err.message : String(err)}`);
-            // Best-effort cleanup of the orphaned temp so they don't accumulate.
-            await unlink(tmpPath).catch(() => { });
-        }
-    }
-    /**
-     * Debounced save — coalesces rapid mutations into one write per second.
-     * Call this on every state change; it will save at most once per second.
-     */
-    debouncedSave(state) {
-        this.pendingState = state;
-        if (this.saveTimer)
-            return; // Already scheduled
-        this.saveTimer = setTimeout(() => {
-            this.saveTimer = null;
-            if (this.pendingState) {
-                const s = this.pendingState;
-                this.pendingState = null;
-                this.save(s).catch(() => { });
-            }
-        }, 1000);
-    }
-    /** Flush any pending debounced save immediately. */
-    async flush() {
-        if (this.saveTimer) {
-            clearTimeout(this.saveTimer);
-            this.saveTimer = null;
-        }
-        if (this.pendingState) {
-            const s = this.pendingState;
-            this.pendingState = null;
-            await this.save(s);
-        }
-    }
-    /** Load state or create default if not found. */
-    async loadOrDefault(startingBalance, quoteCurrency) {
-        const loaded = await this.load();
-        if (loaded)
-            return loaded;
-        const state = createDefaultState(startingBalance, quoteCurrency);
-        logger.info(TAG, `Initialized default state: ${startingBalance} ${quoteCurrency}`);
-        await this.save(state);
-        return state;
-    }
-    /** Synchronous load — for use in synchronous plugin register(). Same
-     *  missing-vs-corrupt distinction as load(): a corrupt file is quarantined
-     *  (preserved), never silently overwritten by the default the caller seeds. */
-    loadSync() {
-        if (!existsSync(this.statePath)) {
-            logger.info(TAG, `No state file found at ${this.statePath}`);
-            return null;
-        }
-        try {
-            const raw = readFileSync(this.statePath, 'utf-8');
-            const state = JSON.parse(raw);
-            logger.info(TAG, `Loaded state: ${state.positions.length} positions, ${state.openOrders.length} orders, ${state.tradeHistory.length} trades`);
-            return state;
-        }
-        catch {
-            this.quarantineCorruptSync();
-            return null;
-        }
-    }
-    /** Synchronous load-or-create-default — for use in synchronous plugin register(). */
-    loadOrDefaultSync(startingBalance, quoteCurrency) {
-        const loaded = this.loadSync();
-        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)) {
-                mkdirSync(dir, { recursive: true });
-            }
-            writeFileSync(this.statePath, JSON.stringify(state, null, 2), 'utf-8');
-        }
-        catch (err) {
-            logger.error(TAG, `Failed to save ${label} state: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-}
-/** 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/assets/plugin/pinned-plan.d.ts

@@ -1,9 +0,0 @@
-/** Has the agent's pinned invalidation price been reached at the current mark?
- *
- *  Long: invalidated when mark <= invalidationPrice.
- *  Short: invalidated when mark >= invalidationPrice.
- *
- *  Returns undefined when there is nothing to check — no pinned invalidation,
- *  or no usable mark — so a missing plan reads as "unknown", never a false
- *  "not hit". Pure. */
-export declare function computeInvalidationHit(side: 'long' | 'short', markPrice: number | undefined, invalidationPrice: number | undefined): boolean | undefined;

package/assets/plugin/pinned-plan.js

@@ -1,23 +0,0 @@
-// Pinned trade plan — derived indication helpers (Slice 1, Task 5).
-//
-// Pure functions surfaced to the agent at heartbeat (via fetch_positions →
-// CcxtPosition) so it can hold to its OWN plan instead of re-litigating the
-// entry every cycle. Indication only — nothing here enforces anything; the
-// only forced thing on the position is that a protective stop exists.
-/** Has the agent's pinned invalidation price been reached at the current mark?
- *
- *  Long: invalidated when mark <= invalidationPrice.
- *  Short: invalidated when mark >= invalidationPrice.
- *
- *  Returns undefined when there is nothing to check — no pinned invalidation,
- *  or no usable mark — so a missing plan reads as "unknown", never a false
- *  "not hit". Pure. */
-export function computeInvalidationHit(side, markPrice, invalidationPrice) {
-    if (invalidationPrice == null ||
-        !Number.isFinite(invalidationPrice) ||
-        markPrice == null ||
-        !Number.isFinite(markPrice)) {
-        return undefined;
-    }
-    return side === 'long' ? markPrice <= invalidationPrice : markPrice >= invalidationPrice;
-}

package/assets/plugin/portfolio/wave9-admission.d.ts

@@ -1,67 +0,0 @@
-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/assets/plugin/portfolio/wave9-admission.js

@@ -1,262 +0,0 @@
-// ⚠️ 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/assets/plugin/portfolio/wave9-policy.d.ts

@@ -1,36 +0,0 @@
-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;