@reefclaw/openclaw-plugin 0.1.1 → 0.1.2

package/signals/strategy-adapter.js

@@ -9,6 +9,7 @@ import { evaluateConditions } from './conditions/registry.js';
 import { resolveDirection } from './direction-rules.js';
 import { computeEntry } from './entry-rules.js';
 import { computeStop } from './stop-rules.js';
+import { computeATR } from '../shared/indicators.js';
 /**
  * Higher-timeframe tick gating state, keyed by
  * `${gateNamespace}\x1f${strategyName}:${symbol}`.
@@ -41,6 +42,73 @@ function pickTimeframeBars(ctx, tf) {
         return ctx.ohlcv4h ?? [];
     return ctx.ohlcv1h;
 }
+const TF_MS = {
+    '1h': 3_600_000,
+    '4h': 4 * 3_600_000,
+    '1d': 24 * 3_600_000,
+};
+/** Median spacing of the last few bars — robust bar-cadence probe. */
+function barSpacingMs(bars) {
+    const n = bars.length;
+    if (n < 2)
+        return 0;
+    const deltas = [];
+    for (let i = Math.max(1, n - 4); i < n; i++) {
+        deltas.push(bars[i].time.getTime() - bars[i - 1].time.getTime());
+    }
+    deltas.sort((a, b) => a - b);
+    return deltas[Math.floor(deltas.length / 2)];
+}
+/**
+ * Live parity for higher-timeframe strategies (the tfHours-aware-stops fix,
+ * 2026-07 — see docs/STRATEGY_RESEARCH_2026-07.md §6.4 / CLAUDE.md ★).
+ *
+ * Every implicit bar read in this engine — stop rules
+ * (`findSwingPoints(ctx.ohlcv1h.slice(-48))`), entry rules
+ * (`computeEMA(ctx.ohlcv1h…)`), conditions without a `tfHours` param
+ * (ema_proximity, stoch_rsi_extreme, adx_*, …) and `ctx.atr14` — targets the
+ * `ohlcv1h` slot. The backtest engine feeds MAIN-timeframe bars into that
+ * slot (and computes atr14 from them), so a 4h/1d strategy backtests against
+ * primary-timeframe geometry. LIVE contexts put real 1h bars there, so the
+ * same strategy would compute stops/EMAs/ATR from 1h data — a 1d ATR is ~8×
+ * the 1h ATR, so live stops came out ~8× too tight. This helper gives the
+ * evaluation the exact context shape the backtest validated: primary bars in
+ * the `ohlcv1h` slot, atr14 recomputed from them (same computeATR the
+ * backtest and live context builders use).
+ *
+ * Detection, not configuration: when the `ohlcv1h` slot already carries
+ * primary-cadence bars (median spacing ≥ 90% of the primary bar duration —
+ * i.e. a backtest context), the context is returned UNTOUCHED, so backtest
+ * behaviour is byte-identical by construction (including warm-up: the
+ * backtest engine already refuses to build a context below 50 main bars).
+ * A live 1h series can only look primary-spaced through a data gap, in
+ * which case we fall back to the untouched context (pre-fix behaviour)
+ * rather than guessing.
+ *
+ * Returns null for a LIVE context whose primary-timeframe history is below
+ * the backtest's 50-bar warm-up — the caller skips evaluation, mirroring
+ * the backtest's null-context warm-up window.
+ *
+ * Exported for tests.
+ */
+export function resolvePrimaryContext(ctx, tf, tfBars) {
+    if (tf === '1h')
+        return ctx;
+    const spacing = barSpacingMs(ctx.ohlcv1h);
+    if (spacing === 0 || spacing >= TF_MS[tf] * 0.9)
+        return ctx; // already primary (backtest) or undecidable
+    if (tfBars.length < 50)
+        return null; // live warm-up parity with the backtest engine
+    const highs = tfBars.map(b => b.high);
+    const lows = tfBars.map(b => b.low);
+    const closes = tfBars.map(b => b.close);
+    const atr14 = computeATR(highs, lows, closes, 14);
+    return {
+        ...ctx,
+        ohlcv1h: tfBars,
+        atr14: Number.isFinite(atr14) && atr14 > 0 ? atr14 : ctx.atr14,
+    };
+}
 /** Empty no-signal evaluation — used when gating skips a strategy. */
 const SKIPPED = { direction: null, conditions: [], trade: undefined };
 /**
@@ -80,40 +148,49 @@ export function adaptStrategy(config, gateNamespace) {
                 return SKIPPED;
             }
             lastEvaluatedBarTime.set(gateKey, latestBarTime);
+            // ─── Higher-timeframe live parity ──────────────────────────────
+            // Evaluate against a context whose implicit-1h slot carries
+            // primary-timeframe bars — see resolvePrimaryContext. Backtest
+            // contexts pass through untouched; only live contexts for 4h/1d
+            // strategies are adapted, and a live context below the backtest's
+            // 50-bar warm-up resolves to null → skip.
+            const ectx = resolvePrimaryContext(ctx, tf, tfBars);
+            if (ectx === null)
+                return SKIPPED;
             // ─── SkipIf gates ──────────────────────────────────────────────
             // Portfolio-wide / cross-symbol filters. If any are met the
             // strategy is skipped this tick. Evaluated before main conditions
             // so the bulk of the work is short-circuited.
             if (config.skipIf && config.skipIf.length > 0) {
-                const { conditions: skipResults } = evaluateConditions(config.skipIf, ctx, null);
+                const { conditions: skipResults } = evaluateConditions(config.skipIf, ectx, null);
                 if (skipResults.some(c => c.met))
                     return SKIPPED;
             }
             // Pass 1: evaluate conditions with direction = null
-            const { conditions: pass1, condCtx } = evaluateConditions(config.conditions, ctx, null);
+            const { conditions: pass1, condCtx } = evaluateConditions(config.conditions, ectx, null);
             // Determine direction
-            const direction = resolveDirection(config.directionRule, ctx, condCtx);
+            const direction = resolveDirection(config.directionRule, ectx, condCtx);
             // Pass 2: re-evaluate direction-sensitive conditions now that we know direction
             // (orderbook_imbalance and funding_contrarian behave differently per direction)
             const directionSensitive = new Set(['orderbook_imbalance', 'funding_contrarian', 'funding_extreme_skip', 'funding_position_ok', 'return_momentum']);
             const hasDirSensitive = config.conditions.some(c => directionSensitive.has(c.type));
             let finalConditions = pass1;
             if (direction && hasDirSensitive) {
-                const { conditions: pass2 } = evaluateConditions(config.conditions, ctx, direction);
+                const { conditions: pass2 } = evaluateConditions(config.conditions, ectx, direction);
                 // Merge: use pass2 results for direction-sensitive, pass1 for others
                 finalConditions = pass1.map((c, i) => directionSensitive.has(config.conditions[i].type) ? pass2[i] : c);
             }
             const allMet = finalConditions.every(c => c.met);
             let trade;
             if (allMet && direction) {
-                const entryZone = computeEntry(config.entryRule, ctx, direction, condCtx);
-                const stopLevel = computeStop(config.stopRule, ctx, direction, condCtx);
+                const entryZone = computeEntry(config.entryRule, ectx, direction, condCtx);
+                const stopLevel = computeStop(config.stopRule, ectx, direction, condCtx);
                 const risk = direction === 'LONG'
-                    ? ctx.currentPrice - stopLevel
-                    : stopLevel - ctx.currentPrice;
+                    ? ectx.currentPrice - stopLevel
+                    : stopLevel - ectx.currentPrice;
                 const targets = config.targetRMultiples.map(rm => direction === 'LONG'
-                    ? ctx.currentPrice + risk * rm
-                    : ctx.currentPrice - risk * rm);
+                    ? ectx.currentPrice + risk * rm
+                    : ectx.currentPrice - risk * rm);
                 trade = { entryZone, stopLevel, targets };
             }
             return { direction, conditions: finalConditions, trade };

package/tools/create-order.js

@@ -1,5 +1,6 @@
 // Tool: create_order — order execution with real price data + pre-trade risk gate
 // Readiness gate: BLOCKED unless adapter.readiness === 'READY'.
+import { randomUUID } from 'node:crypto';
 import { formatError } from '../logger.js';
 import { getQuoteBalance, getQuoteWalletBalance } from '../balance-utils.js';
 import { fetchCurrentPrice, fetchOrderBook, isError } from './helpers.js';
@@ -293,32 +294,37 @@ export async function createOrderTool(args, deps) {
         }
     }
     try {
-        const order = await deps.adapter.createOrder(args.symbol, side, type, args.amount, args.price, metadata);
+        // Stash the metadata BEFORE submission, keyed by a pre-generated
+        // clientOrderId (fixed 2026-07-07; supersedes the 2026-07-05 post-return
+        // stash). For market orders the user-data WS fill routinely arrives
+        // BEFORE the REST ack resolves — observed on prod (FIL 2026-07-06
+        // 20:28:17: WS capture consumed nothing and journaled metadata=none while
+        // the post-return stash landed milliseconds later). The WS
+        // ORDER_TRADE_UPDATE carries the clientOrderId (`o.c`), so
+        // onWsFillObserved falls back to it when the exchange orderId lookup
+        // misses; promote() below adds the exchange-orderId alias once the REST
+        // ack returns for the normal (WS-after-REST) ordering. If the submission
+        // throws, the unused stash entry simply expires (24h TTL, pruned).
+        let stashCid;
+        if (deps.autoCapture?.pendingEntries && metadata) {
+            stashCid = randomUUID();
+            deps.autoCapture.pendingEntries.put({
+                orderId: stashCid,
+                clientOrderId: stashCid,
+                symbol: args.symbol,
+                side: side,
+                metadata,
+            });
+        }
+        const order = await deps.adapter.createOrder(args.symbol, side, type, args.amount, args.price, metadata, stashCid ? { clientOrderId: stashCid } : undefined);
         // Auto-capture entry to the Position Decision Journal — fail-open, never
         // block the trading hot path on a webapp ingest blip.
         if (deps.autoCapture) {
-            // ALWAYS stash the metadata first (fixed 2026-07-05). Binance futures
-            // market orders routinely come back filled>0 but with NO average price
-            // in the immediate REST response — the synchronous capture below then
-            // bails ("missing fill price; skipping capture") and, before this fix,
-            // the metadata was dropped on the floor because the stash only ran in
-            // the not-filled branch. The WS-driven onWsFillObserved captured those
-            // entries seconds later with metadata=none → the live journal filled
-            // with '(no thesis recorded)' / setup_type='unknown' rows (majority of
-            // 2026-07 live entries) even though the agent supplied full v2.10.0
-            // metadata every time. When the synchronous capture DOES succeed, the
-            // WS dedup (openedFromExchangeTradeId === orderId) skips the duplicate
-            // and the unused stash entry simply expires (24h TTL, pruned).
-            if (metadata &&
+            if (stashCid &&
                 deps.autoCapture.pendingEntries &&
                 typeof order.id === 'string' &&
                 order.id.length > 0) {
-                deps.autoCapture.pendingEntries.put({
-                    orderId: order.id,
-                    symbol: args.symbol,
-                    side: side,
-                    metadata,
-                });
+                deps.autoCapture.pendingEntries.promote(stashCid, order.id);
             }
             const filledNow = typeof order.filled === 'number' && order.filled > 0;
             if (filledNow) {