@reefclaw/openclaw-plugin 0.1.5 → 0.1.7

package/tools/get-analytics.js

@@ -1,7 +1,7 @@
 // Tool: get_analytics — fetches edge analytics from the Intelligence API.
 // Returns per-strategy performance metrics (win rate, expectancy, Sharpe),
 // regime breakdown, equity curve, and degradation alerts.
-import { fetchIntelApi, enc } from './intel-api.js';
+import { fetchIntelApi, enc, resolveIntelSymbol } from './intel-api.js';
 export async function getAnalyticsTool(args, deps) {
-    return fetchIntelApi(`/api/analytics/${enc(args.symbol)}`, deps);
+    return fetchIntelApi(`/api/analytics/${enc(resolveIntelSymbol(deps, args.symbol))}`, deps);
 }

package/tools/get-basis.js

@@ -1,7 +1,7 @@
 // Tool: get_basis — fetches spot-futures basis (mark-spot premium) analysis.
 // Returns current premium/discount, historical basis, funding alignment, and dislocation detection.
-import { fetchIntelApi, enc } from './intel-api.js';
+import { fetchIntelApi, enc, resolveIntelSymbol } from './intel-api.js';
 export async function getBasisTool(args, deps) {
     const hours = args.hours ?? 24;
-    return fetchIntelApi(`/api/basis/${enc(args.symbol)}?hours=${hours}`, deps);
+    return fetchIntelApi(`/api/basis/${enc(resolveIntelSymbol(deps, args.symbol))}?hours=${hours}`, deps);
 }

package/tools/get-cascade-risk.js

@@ -1,8 +1,8 @@
 // Tool: get_cascade_risk — fetches liquidation cascade risk assessment.
 // Returns proximity to liquidation clusters, cascade impact estimates,
 // recent liquidation activity, and overall risk score.
-import { fetchIntelApi, enc } from './intel-api.js';
+import { fetchIntelApi, enc, resolveIntelSymbol } from './intel-api.js';
 export async function getCascadeRiskTool(args, deps) {
     const hours = args.hours ?? 24;
-    return fetchIntelApi(`/api/cascade-risk/${enc(args.symbol)}?hours=${hours}`, deps);
+    return fetchIntelApi(`/api/cascade-risk/${enc(resolveIntelSymbol(deps, args.symbol))}?hours=${hours}`, deps);
 }

package/tools/get-crypto-metrics.js

@@ -1,18 +1,28 @@
 // Tool: get_crypto_metrics — funding rate + open interest from Binance perpetual futures
 // Uses dedicated CCXT methods (fetchFundingRate + fetchOpenInterest) instead of fetchTicker,
 // because Binance's 24hr ticker endpoint does NOT include funding/OI data.
+import { fromIntelSymbol } from '../venues/symbols.js';
 export async function getCryptoMetricsTool(args, deps) {
     try {
+        // The agent routinely pastes intel-form ids into this tool ('ETHUSDT',
+        // 'HL_BTC' — ~100×/day live as of 2026-07-13). Handed to ccxt verbatim, a
+        // concatenated id resolves to the SPOT market and funding/OI fail
+        // ("supports linear and inverse contracts only"). Map both intel
+        // namespaces back to canonical BASE/QUOTE first; anything fromIntelSymbol
+        // can't map comes back verbatim (honest passthrough, no invented quote).
+        const canonical = args.symbol.includes('/') || args.symbol.includes(':')
+            ? args.symbol
+            : fromIntelSymbol(args.symbol.trim()).canonical;
         // Funding rate & OI only exist on perpetual futures. Convert a canonical
         // symbol to its linear-perp ccxt form by settling in the QUOTE currency
         // (BTC/USDT → BTC/USDT:USDT on Binance, BTC/USDC → BTC/USDC:USDC on
         // Hyperliquid). A hardcoded :USDT suffix produced the nonsense form
         // BTC/USDC:USDT on the HL venue (seen live, wisekid soak 2026-07-12) —
         // never silently translate quote assets across venues.
-        const quote = args.symbol.split('/')[1];
-        const perpSymbol = args.symbol.includes(':') || !quote
-            ? args.symbol
-            : `${args.symbol}:${quote}`;
+        const quote = canonical.split('/')[1];
+        const perpSymbol = canonical.includes(':') || !quote
+            ? canonical
+            : `${canonical}:${quote}`;
         // Fetch funding rate and open interest in parallel (separate API endpoints)
         const [fundingData, oiData, tickerData] = await Promise.all([
             deps.binanceApi.fetchFundingRate(perpSymbol),

package/tools/get-cvd.js

@@ -1,6 +1,6 @@
 // Tool: get_cvd — fetches CVD (Cumulative Volume Delta) analysis from the Intelligence API.
 // Returns buy/sell pressure, divergence detection, slope, z-score, and interpretation.
-import { fetchIntelApi, enc } from './intel-api.js';
+import { fetchIntelApi, enc, resolveIntelSymbol } from './intel-api.js';
 export async function getCvdTool(args, deps) {
-    return fetchIntelApi(`/api/cvd/${enc(args.symbol)}`, deps);
+    return fetchIntelApi(`/api/cvd/${enc(resolveIntelSymbol(deps, args.symbol))}`, deps);
 }

package/tools/get-divergences.js

@@ -1,6 +1,6 @@
 // Tool: get_divergences — multi-timeframe RSI/MACD divergence scanner.
 // Detects price-vs-indicator divergences across 15m, 1h, 4h, 1d timeframes.
-import { fetchIntelApi, enc } from './intel-api.js';
+import { fetchIntelApi, enc, resolveIntelSymbol } from './intel-api.js';
 export async function getDivergencesTool(args, deps) {
-    return fetchIntelApi(`/api/divergences/${enc(args.symbol)}`, deps);
+    return fetchIntelApi(`/api/divergences/${enc(resolveIntelSymbol(deps, args.symbol))}`, deps);
 }

package/tools/get-funding-context.js

@@ -10,7 +10,7 @@
 //
 // Returns `{ enabled: false, reason }` when the intel-side
 // FUNDING_OVERLAY flag is off or the symbol has < 100 30d samples.
-import { fetchIntelApi, enc } from './intel-api.js';
+import { fetchIntelApi, enc, resolveIntelSymbol } from './intel-api.js';
 export async function getFundingContextTool(args, deps) {
-    return fetchIntelApi(`/api/funding/${enc(args.symbol)}`, deps);
+    return fetchIntelApi(`/api/funding/${enc(resolveIntelSymbol(deps, args.symbol))}`, deps);
 }

package/tools/get-liquidation-levels.js

@@ -1,7 +1,7 @@
 // Tool: get_liquidation_levels — fetches liquidation levels from the Intelligence API.
 // Returns historical liquidation clusters and estimated liquidation levels around current price.
-import { fetchIntelApi, enc } from './intel-api.js';
+import { fetchIntelApi, enc, resolveIntelSymbol } from './intel-api.js';
 export async function getLiquidationLevelsTool(args, deps) {
     const hours = args.hours ?? 24;
-    return fetchIntelApi(`/api/liquidation-levels/${enc(args.symbol)}?hours=${hours}`, deps);
+    return fetchIntelApi(`/api/liquidation-levels/${enc(resolveIntelSymbol(deps, args.symbol))}?hours=${hours}`, deps);
 }

package/tools/get-liquidation-pulse.js

@@ -6,11 +6,11 @@
 // When the intel-side `microstructure.liquidationPulse` flag is off,
 // returns `{ enabled: false, reason }` — operator hasn't enabled the
 // feature yet.
-import { fetchIntelApi } from './intel-api.js';
+import { fetchIntelApi, resolveIntelSymbol } from './intel-api.js';
 export async function getLiquidationPulseTool(args, deps) {
     const params = new URLSearchParams();
     if (args.symbol)
-        params.set('symbol', args.symbol);
+        params.set('symbol', resolveIntelSymbol(deps, args.symbol));
     const windowSeconds = clamp(args.window_seconds ?? 60, 5, 300);
     params.set('window_seconds', String(windowSeconds));
     return fetchIntelApi(`/api/liquidation-pulse?${params.toString()}`, deps);

package/tools/get-pattern-scan.js

@@ -1,8 +1,8 @@
 // Tool: get_pattern_scan — automated chart pattern recognition from OHLCV data.
 // Calls Intelligence API for swing points, trendlines, and 10 pattern types.
-import { fetchIntelApi, enc } from './intel-api.js';
+import { fetchIntelApi, enc, resolveIntelSymbol } from './intel-api.js';
 export async function getPatternScanTool(args, deps) {
-    const intelSymbol = args.symbol.replace('/', '');
+    const intelSymbol = resolveIntelSymbol(deps, args.symbol);
     const timeframe = args.timeframe ?? '1h';
     return fetchIntelApi(`/api/patterns/${enc(intelSymbol)}?timeframe=${enc(timeframe)}&lookback=200`, deps);
 }

package/tools/get-regime.js

@@ -1,7 +1,7 @@
 // Tool: get_regime — fetches regime classification from the Intelligence API.
 // Returns current market regime (trend_up, trend_down, range_tight, etc.)
 // with confidence, probabilities, and contributing features.
-import { fetchIntelApi, enc } from './intel-api.js';
+import { fetchIntelApi, enc, resolveIntelSymbol } from './intel-api.js';
 export async function getRegimeTool(args, deps) {
-    return fetchIntelApi(`/api/regime/${enc(args.symbol)}`, deps);
+    return fetchIntelApi(`/api/regime/${enc(resolveIntelSymbol(deps, args.symbol))}`, deps);
 }

package/tools/get-resting-liquidity.js

@@ -5,7 +5,7 @@
 //
 // Returns `{ enabled: false, reason }` when the intel-side
 // `microstructure.bandedLiquidity` flag is off (= columns are NULL).
-import { fetchIntelApi, enc } from './intel-api.js';
+import { fetchIntelApi, enc, resolveIntelSymbol } from './intel-api.js';
 export async function getRestingLiquidityTool(args, deps) {
-    return fetchIntelApi(`/api/resting-liquidity/${enc(args.symbol)}`, deps);
+    return fetchIntelApi(`/api/resting-liquidity/${enc(resolveIntelSymbol(deps, args.symbol))}`, deps);
 }

package/tools/get-risk-scenario.js

@@ -2,7 +2,7 @@
 // Fetches positions + balance from simulator state, then calls Intelligence API for scenario analysis.
 // Returns: per-scenario P&L, heat, drawdown zone, stops triggered, limits breached.
 import { enc } from './intel-api.js';
-import { fetchIntelApi } from './intel-api.js';
+import { fetchIntelApi, resolveIntelSymbol } from './intel-api.js';
 export async function getRiskScenarioTool(args, deps) {
     const positions = deps.getPositions();
     const wallet = deps.getWallet();
@@ -34,7 +34,7 @@ export async function getRiskScenarioTool(args, deps) {
         })).filter(s => !isNaN(s.movePct));
     }
     // Normalize symbol for intelligence API (BTC/USDT → BTCUSDT)
-    const intelSymbol = args.symbol.replace('/', '');
+    const intelSymbol = resolveIntelSymbol(deps.intelApiDeps, args.symbol);
     const body = {
         positions: apiPositions,
         balance,

package/tools/get-session-review.js

@@ -1,8 +1,8 @@
 // Tool: get_session_review — automated end-of-session performance summary.
 // Calls Intelligence API for trade stats, setup/regime breakdown, lessons, and session-over-session comparison.
-import { fetchIntelApi, enc } from './intel-api.js';
+import { fetchIntelApi, enc, resolveIntelSymbol } from './intel-api.js';
 export async function getSessionReviewTool(args, deps) {
-    const intelSymbol = args.symbol.replace('/', '');
+    const intelSymbol = resolveIntelSymbol(deps, args.symbol);
     const hours = args.hours ?? 24;
     return fetchIntelApi(`/api/session-review/${enc(intelSymbol)}?hours=${hours}`, deps);
 }

package/tools/get-setup-detail.js

@@ -14,10 +14,18 @@
 // that direction so long and short setups produce ladders that match.
 // Cache is shared with scan_pairs (intel-cache.ts) so drill-down sees the
 // same fact snapshot the scan ranked the symbol from.
+import { resolveIntelSymbol } from './intel-api.js';
 import { evaluateStrategy, } from '../strategy/evaluator.js';
 import { getFactBySymbolCached, getStrategyRowsCached } from './intel-cache.js';
 export async function getSetupDetailTool(args, deps) {
-    const symbol = args.symbol.toUpperCase().replace(/[^A-Z0-9]/g, '');
+    // Venue-aware symbol resolution (plan §5.3). Binance keeps the historical
+    // sanitizer byte-identically; the hyperliquid arm maps agent-facing forms
+    // ('BTC/USDC', 'BTCUSDC') to the HL_ intel namespace and must NOT uppercase
+    // or strip '_' — HL coins are case-sensitive ('kPEPE' is real, 'KPEPE' is
+    // not) and the legacy sanitizer would mangle 'HL_BTC' into 'HLBTC'.
+    const symbol = (deps.venue ?? 'binance') === 'hyperliquid'
+        ? resolveIntelSymbol(deps, args.symbol)
+        : args.symbol.toUpperCase().replace(/[^A-Z0-9]/g, '');
     // 1. Fetch fact for this symbol — shared cache with scan_pairs, so a
     //    drill-down after a heartbeat scan hits the same snapshot the scan
     //    ranked the symbol from.
@@ -299,5 +307,16 @@ function computeStop(strategy, atr, entryPrice, direction) {
     }
 }
 function roundPrice(p) {
-    return Math.round(p * 100) / 100;
+    // 2 decimals for $1+ prices; below that, 6 significant digits — a flat
+    // 2-decimal round collapses entry/stop/targets onto the same value for the
+    // sub-cent class (1000PEPE/1000SHIB/…, ATR below the $0.01 granularity),
+    // tripping the zero-risk guard and refusing every setup on those symbols.
+    if (!Number.isFinite(p) || p === 0)
+        return p;
+    const abs = Math.abs(p);
+    if (abs >= 1)
+        return Math.round(p * 100) / 100;
+    const decimals = 5 - Math.floor(Math.log10(abs));
+    const f = Math.pow(10, decimals);
+    return Math.round(p * f) / f;
 }

package/tools/get-signals.js

@@ -7,9 +7,9 @@
 //             comparison (zero behaviour change).
 //   enforce — return the locally-evaluated snapshot, falling back to central
 //             when the local service has no fact for the symbol yet.
-import { fetchIntelApi, enc } from './intel-api.js';
+import { fetchIntelApi, enc, resolveIntelSymbol } from './intel-api.js';
 async function central(args, deps) {
-    const s = enc(args.symbol);
+    const s = enc(resolveIntelSymbol(deps, args.symbol));
     const [snapshot, history] = await Promise.all([
         fetchIntelApi(`/api/signals/${s}`, deps),
         fetchIntelApi(`/api/signals/${s}/history?hours=${args.hours ?? 24}`, deps),

package/tools/get-sizing.js

@@ -1,6 +1,6 @@
 // Tool: get_sizing — fetches Half-Kelly position sizing recommendation from Intelligence API.
 // Returns recommended size as % of account, Kelly fraction, win rate, avg W/L ratio, vol adjustment.
-import { fetchIntelApi, enc } from './intel-api.js';
+import { fetchIntelApi, enc, resolveIntelSymbol } from './intel-api.js';
 export async function getSizingTool(args, deps) {
-    return fetchIntelApi(`/api/sizing/${enc(args.symbol)}`, deps);
+    return fetchIntelApi(`/api/sizing/${enc(resolveIntelSymbol(deps, args.symbol))}`, deps);
 }

package/tools/get-trade-feedback.js

@@ -1,8 +1,8 @@
 // Tool: get_trade_feedback — fetches structured performance feedback from Intelligence API.
 // Returns per-setup-type win rates, regime breakdown, recent outcomes, and current streak.
 // Designed for the agent to review before entering trades.
-import { fetchIntelApi, enc } from './intel-api.js';
+import { fetchIntelApi, enc, resolveIntelSymbol } from './intel-api.js';
 export async function getTradeFeedbackTool(args, deps) {
     const hours = args.hours ?? 168;
-    return fetchIntelApi(`/api/analytics/${enc(args.symbol)}/feedback?hours=${hours}`, deps);
+    return fetchIntelApi(`/api/analytics/${enc(resolveIntelSymbol(deps, args.symbol))}/feedback?hours=${hours}`, deps);
 }

package/tools/get-trade-flow.js

@@ -1,7 +1,7 @@
 // Tool: get_trade_flow — fetches aggregated trade flow / institutional flow data.
 // Returns buy/sell volume, large trade (whale) activity, net delta, and whale pressure verdict.
-import { fetchIntelApi, enc } from './intel-api.js';
+import { fetchIntelApi, enc, resolveIntelSymbol } from './intel-api.js';
 export async function getTradeFlowTool(args, deps) {
     const minutes = args.minutes ?? 5;
-    return fetchIntelApi(`/api/trade-flow/${enc(args.symbol)}?minutes=${minutes}`, deps);
+    return fetchIntelApi(`/api/trade-flow/${enc(resolveIntelSymbol(deps, args.symbol))}?minutes=${minutes}`, deps);
 }

package/tools/get-volume-profile.js

@@ -1,7 +1,7 @@
 // Tool: get_volume_profile — fetches volume profile from the Intelligence API.
 // Returns price buckets with buy/sell volume, POC, value area, and current price.
-import { fetchIntelApi, enc } from './intel-api.js';
+import { fetchIntelApi, enc, resolveIntelSymbol } from './intel-api.js';
 export async function getVolumeProfileTool(args, deps) {
     const period = args.period ?? 24;
-    return fetchIntelApi(`/api/volume-profile/${enc(args.symbol)}?period=${period}`, deps);
+    return fetchIntelApi(`/api/volume-profile/${enc(resolveIntelSymbol(deps, args.symbol))}?period=${period}`, deps);
 }

package/tools/get-wave9-status.d.ts

@@ -0,0 +1,127 @@
+import { evaluateWave9Daily, type Wave9StrategyName } from '../portfolio/wave9-policy.js';
+import { type Wave9EvidenceProvider } from '../wave9/usdm-evidence-provider.js';
+import type { TradingOperationLock } from '../lifecycle/trading-operation-lock.js';
+import type { Wave9NativeStopObservation } from '../wave9/live-account-capture.js';
+import type { Wave9ExecutionMode } from '../wave9/paper-admission-guard.js';
+import type { IntelApiDeps } from './intel-api.js';
+export declare const WAVE9_BUNDLE_NAME = "wave9_28d_momentum_reversal";
+export declare const WAVE9_EXECUTION_KERNEL = "wave9_shared_v1";
+export declare const WAVE9_PAPER_ENTRY_WINDOW_MS: number;
+export interface Wave9BundleActivation {
+    available: boolean;
+    name: typeof WAVE9_BUNDLE_NAME;
+    executionModel: typeof WAVE9_EXECUTION_KERNEL;
+    active: boolean;
+    source?: 'tenant_override' | 'global_default';
+    error?: string;
+}
+export interface Wave9ActivationClient {
+    getActivation(): Promise<Wave9BundleActivation>;
+}
+export declare class IntelWave9ActivationClient implements Wave9ActivationClient {
+    private readonly deps;
+    constructor(deps: IntelApiDeps);
+    getActivation(): Promise<Wave9BundleActivation>;
+}
+export interface Wave9ObservedPosition {
+    symbol: string;
+    side: 'long' | 'short';
+    quantity: number;
+    entryPrice: number;
+    markPrice: number;
+    stopPrice?: number;
+    missionId?: string;
+    setupType?: string;
+    /** Present only after an exact Wave 9 admission has recorded it. */
+    candidateId?: string;
+    /** Optional future durable geometry for authoritative open-book projection. */
+    strategy?: Wave9StrategyName;
+    accruedFundingUsd?: number;
+    openedAt?: string;
+    /** Exchange-native stop identity and liveness bound by LIVE capture. */
+    nativeStop?: Wave9NativeStopObservation;
+    /** Stable held-position geometry, excluding mark/MFE/wallet volatility. */
+    positionFingerprint?: string;
+}
+export interface Wave9AccountSnapshot {
+    tradingMode: 'PAPER' | 'SHADOW' | 'MICRO_LIVE' | 'LIVE';
+    positionsAvailable: boolean;
+    openOrdersAvailable: boolean;
+    openOrderCount?: number;
+    /** Wallet cash after booked fees/realized PnL, not MTM account equity. */
+    cashEquityAvailable: boolean;
+    cashEquityUsd?: number;
+    positions?: Wave9ObservedPosition[];
+    /** Persisted closed Wave 9 identities; survives a gateway restart. */
+    executedCandidateIds?: string[];
+    source: string;
+    /** Exact process-local account geometry bound into short-lived guards. */
+    accountFingerprint?: string;
+    authoritative: boolean;
+    runtimeParity: false;
+    provenance: string;
+    adapterReadiness?: string;
+    nativeStopProtectionAvailable?: boolean;
+    reasons?: string[];
+}
+export interface Wave9EntryAuthorizationInput {
+    batchId: string;
+    candidateId: string;
+    missionId: string;
+    symbol: string;
+    side: 'BUY' | 'SELL';
+    quantity: string;
+    stopPrice: string;
+    sequence: number;
+    notBeforeMs: number;
+    deadlineMs: number;
+    accountFingerprint: string;
+    tradingMode: Wave9ExecutionMode;
+}
+export interface Wave9IssuedEntryAuthorization {
+    token: string;
+    batchId: string;
+    candidateId: string;
+    missionId: string;
+    sequence: number;
+    deadlineMs: number;
+    accountFingerprint: string;
+    tradingMode: Wave9ExecutionMode;
+}
+export interface Wave9ExitAuthorizationInput {
+    candidateId: string;
+    missionId: string;
+    symbol: string;
+    positionSide: 'long' | 'short';
+    reason: 'signal_reversal';
+    notBeforeMs: number;
+    deadlineMs: number;
+    positionFingerprint: string;
+    tradingMode: Wave9ExecutionMode;
+}
+export interface Wave9IssuedExitAuthorization {
+    token: string;
+    candidateId: string;
+    missionId: string;
+    deadlineMs: number;
+    positionFingerprint?: string;
+    tradingMode: Wave9ExecutionMode;
+}
+/** Structural seam implemented by the process-local paper admission guard. */
+export interface Wave9AdmissionAuthorizationIssuer {
+    issueBatch(decisions: readonly Wave9EntryAuthorizationInput[]): readonly Wave9IssuedEntryAuthorization[];
+    issueExitBatch(decisions: readonly Wave9ExitAuthorizationInput[]): readonly Wave9IssuedExitAuthorization[];
+}
+export interface GetWave9StatusDeps {
+    activationClient: Wave9ActivationClient;
+    getAccountSnapshot(): Promise<Wave9AccountSnapshot>;
+    operationLock: TradingOperationLock;
+    /** Wave 9 evidence and execution are pinned to Binance USD-M. */
+    executionVenue: string;
+    createEvidenceProvider?: () => Wave9EvidenceProvider;
+    authorizationIssuer?: Wave9AdmissionAuthorizationIssuer;
+    now?: () => Date;
+    evaluateDaily?: typeof evaluateWave9Daily;
+}
+export declare function wave9MissionId(candidateId: string): string;
+export declare function getWave9StatusTool(deps: GetWave9StatusDeps): Promise<Record<string, unknown>>;