@reefclaw/connect 0.1.5 → 0.1.6

package/assets/plugin/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/assets/plugin/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) {

package/assets/shared/readiness.d.ts

@@ -0,0 +1,50 @@
+export type ReadinessStatus = 'pass' | 'warn' | 'fail' | 'unknown';
+/** Which lifecycle phase a check belongs to. `connect` runs with NO Binance API
+ *  keys (covers paper trading too); `golive` needs keys (Phase 2). */
+export type ReadinessPhase = 'connect' | 'golive';
+export type ReadinessCheckId = 'binance_reachable' | 'clock_in_sync' | 'plugin_loaded' | 'tools_registered';
+export interface ReadinessCheck {
+    /** Stable machine id. Widened to string so the webapp can render checks from a
+     *  newer plugin it doesn't have the union for. */
+    id: ReadinessCheckId | string;
+    label: string;
+    status: ReadinessStatus;
+    phase: ReadinessPhase;
+    /** Short machine/human detail, e.g. "HTTP 451" or "drift 1200ms". */
+    detail?: string;
+    /** Plain-English fix, present only when the status is warn/fail. */
+    fixHint?: string;
+    /** epoch ms when this check ran. */
+    checkedAt: number;
+}
+export interface ReadinessReport {
+    /** Bumped only if the payload shape changes incompatibly. */
+    schemaVersion: 1;
+    generatedAt: number;
+    overall: ReadinessStatus;
+    checks: ReadinessCheck[];
+    /** Best-effort agent facts for display. */
+    agent?: {
+        pluginVersion?: string;
+        toolCount?: number;
+    };
+}
+interface CheckCopy {
+    label: string;
+    phase: ReadinessPhase;
+    fixHint: string;
+}
+/** The canonical connect-phase checks + their plain-English fixes. Single source
+ *  of copy; the plugin inlines these into each report so the webapp stays dumb. */
+export declare const READINESS_CHECK_COPY: Record<ReadinessCheckId, CheckCopy>;
+/** Build a self-describing check, pulling label/phase/fixHint from the copy map.
+ *  fixHint is attached only when there is something to fix (warn/fail). */
+export declare function makeReadinessCheck(id: ReadinessCheckId, status: ReadinessStatus, opts?: {
+    detail?: string;
+    checkedAt?: number;
+}): ReadinessCheck;
+/** Worst status across the checks: fail > warn > unknown > pass. An all-unknown
+ *  (or empty) set is 'unknown', so a report that couldn't run anything doesn't
+ *  masquerade as a clean pass. */
+export declare function deriveOverallReadiness(checks: ReadinessCheck[]): ReadinessStatus;
+export {};

package/assets/shared/readiness.js

@@ -0,0 +1,58 @@
+// Agent readiness — the check-result contract shared by the plugin (which runs
+// the checks ON the trader's host) and the webapp (which stores + renders them).
+//
+// The plugin emits SELF-DESCRIBING checks (label + fixHint inline) so the webapp
+// renders generically without duplicating the copy. Advisory only: readiness
+// explains failures, it never blocks trading or the safety floor.
+// See docs/AGENT_READINESS_GATE_PLAN.md.
+/** The canonical connect-phase checks + their plain-English fixes. Single source
+ *  of copy; the plugin inlines these into each report so the webapp stays dumb. */
+export const READINESS_CHECK_COPY = {
+    binance_reachable: {
+        label: 'Binance reachable',
+        phase: 'connect',
+        fixHint: 'Your agent host is geo-blocked by Binance (HTTP 451). Run OpenClaw from a Binance-permitted region — most EU / several Asia VPS regions work.',
+    },
+    clock_in_sync: {
+        label: 'Host clock in sync',
+        phase: 'connect',
+        fixHint: 'The host clock drifts from Binance server time. Enable NTP/chrony so signed orders are not rejected (-1021).',
+    },
+    plugin_loaded: {
+        label: 'ReefClaw plugin loaded',
+        phase: 'connect',
+        fixHint: 'The trading plugin did not load. Check the OpenClaw gateway logs for a plugin-load error.',
+    },
+    tools_registered: {
+        label: 'Trading tools registered',
+        phase: 'connect',
+        fixHint: 'No trading tools are registered. Ensure tools.alsoAllow includes "group:plugins", then restart the gateway.',
+    },
+};
+/** Build a self-describing check, pulling label/phase/fixHint from the copy map.
+ *  fixHint is attached only when there is something to fix (warn/fail). */
+export function makeReadinessCheck(id, status, opts = {}) {
+    const copy = READINESS_CHECK_COPY[id];
+    const needsFix = status === 'warn' || status === 'fail';
+    return {
+        id,
+        label: copy.label,
+        phase: copy.phase,
+        status,
+        ...(opts.detail !== undefined ? { detail: opts.detail } : {}),
+        ...(needsFix ? { fixHint: copy.fixHint } : {}),
+        checkedAt: opts.checkedAt ?? Date.now(),
+    };
+}
+/** Worst status across the checks: fail > warn > unknown > pass. An all-unknown
+ *  (or empty) set is 'unknown', so a report that couldn't run anything doesn't
+ *  masquerade as a clean pass. */
+export function deriveOverallReadiness(checks) {
+    if (checks.some((c) => c.status === 'fail'))
+        return 'fail';
+    if (checks.some((c) => c.status === 'warn'))
+        return 'warn';
+    if (checks.length === 0 || checks.every((c) => c.status === 'unknown'))
+        return 'unknown';
+    return 'pass';
+}

package/assets/shared/signals/strategy-adapter.d.ts

@@ -1,6 +1,39 @@
-import type { StrategyDefinition } from './types.js';
-import type { StrategyConfig } from './conditions/types.js';
+import type { StrategyDefinition, MarketContext, OhlcvBar } from './types.js';
+import type { StrategyConfig, PrimaryTimeframe } from './conditions/types.js';
 export declare function clearStrategyGatingState(): void;
+/**
+ * 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 declare function resolvePrimaryContext(ctx: MarketContext, tf: PrimaryTimeframe, tfBars: OhlcvBar[]): MarketContext | null;
 /**
  * Convert a declarative StrategyConfig into a StrategyDefinition
  * that the signal engine and backtest engine can evaluate.

package/assets/shared/signals/strategy-adapter.js

@@ -4,6 +4,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}`.
@@ -36,6 +37,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 };
 /**
@@ -75,40 +143,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/dist/daemon.js

@@ -0,0 +1,104 @@
+// Keep the bridge running across reboots. Linux/systemd-user is implemented
+// fully; macOS and Windows fall back to printing the manual run command (a
+// launchd/Task-Scheduler unit is a follow-up). The bridge reads its config from
+// ~/.openclaw/openclaw.json, so until the user pastes their connect message the
+// service will start, find no token, and restart — harmless; it connects within
+// seconds of the agent writing the config.
+import { writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir, userInfo } from 'node:os';
+import { BRIDGE_DIR } from './paths.js';
+import { run, which } from './exec.js';
+import { step, ok, info, warn } from './ui.js';
+const SERVICE_NAME = 'reefclaw-bridge';
+const NODE = process.execPath; // absolute path to the node running the installer
+/**
+ * Build the systemd user-unit text. Pure + exported so the path-quoting is
+ * unit-testable. Both `node` (process.execPath) and `bridgeDir` (under the
+ * user's home) can contain spaces. Quoting rules differ per directive:
+ *  - ExecStart= is parsed with shell-like word splitting, so an unquoted
+ *    `ExecStart=/home/a b/node …` reads the binary as `/home/a` — QUOTE both
+ *    the binary and the script path.
+ *  - WorkingDirectory= takes the raw value after `=` as a single path (no word
+ *    splitting) — spaces are safe UNQUOTED, and quotes are treated as literal
+ *    characters, failing the unit with "path is not absolute" (verified live
+ *    on systemd 255 / Ubuntu 24.04). Do NOT quote it.
+ */
+export function buildSystemdUnit(node, bridgeDir) {
+    const indexJs = join(bridgeDir, 'index.js');
+    return `[Unit]
+Description=ReefClaw connector - bridges OpenClaw to the ReefClaw dashboard
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+WorkingDirectory=${bridgeDir}
+ExecStart="${node}" "${indexJs}" --provider gateway --log-level info
+Restart=always
+RestartSec=5s
+
+[Install]
+WantedBy=default.target
+`;
+}
+function manualHint() {
+    warn('Could not set up an auto-start service on this OS yet.');
+    info('Keep the connector running with this command (leave it open / use your own service manager):');
+    info(`  "${NODE}" "${join(BRIDGE_DIR, 'index.js')}" --provider gateway`);
+}
+function installSystemd() {
+    if (!which('systemctl'))
+        return false;
+    const unitDir = join(homedir(), '.config', 'systemd', 'user');
+    mkdirSync(unitDir, { recursive: true });
+    const unit = buildSystemdUnit(NODE, BRIDGE_DIR);
+    writeFileSync(join(unitDir, `${SERVICE_NAME}.service`), unit, 'utf-8');
+    run('systemctl', ['--user', 'daemon-reload']);
+    const enabled = run('systemctl', ['--user', 'enable', '--now', `${SERVICE_NAME}.service`]);
+    if (!enabled.ok) {
+        warn('systemd --user enable/start did not succeed:');
+        if (enabled.stderr.trim())
+            info(enabled.stderr.trim().split('\n').slice(-2).join('\n'));
+        info(`Try:  systemctl --user enable --now ${SERVICE_NAME}.service`);
+        return false;
+    }
+    // `enable --now` can exit 0 while the unit failed to load (e.g. a bad unit
+    // file setting) — verify the unit actually came up before claiming ✓.
+    // 'active' = running; 'activating' = the expected pre-token restart loop
+    // (the bridge exits until the user pastes their connect message, and
+    // Restart=always re-launches it). Anything else (inactive/failed) means the
+    // unit never loaded.
+    const active = run('systemctl', ['--user', 'is-active', `${SERVICE_NAME}.service`]);
+    const state = active.stdout.trim();
+    if (state !== 'active' && state !== 'activating') {
+        warn(`the service did not come up (state: ${state || 'unknown'}).`);
+        info(`Inspect:  systemctl --user status ${SERVICE_NAME}.service`);
+        return false;
+    }
+    // Linger lets the user service run without an active login session (servers).
+    // Best-effort: needs privileges; non-fatal if it fails.
+    const linger = run('loginctl', ['enable-linger', userInfo().username]);
+    if (linger.ok) {
+        info('enabled linger (service survives logout / reboot)');
+    }
+    else {
+        info('note: run `sudo loginctl enable-linger $USER` so the connector survives logout.');
+    }
+    return true;
+}
+export function installDaemon() {
+    step('Starting the connector as a background service');
+    if (process.platform === 'linux') {
+        if (installSystemd()) {
+            ok(`connector running as a systemd user service (${SERVICE_NAME})`);
+            info(`logs:  journalctl --user -u ${SERVICE_NAME} -f`);
+            return true;
+        }
+        manualHint();
+        return false;
+    }
+    // macOS / Windows: manual for now (launchd / Task Scheduler unit is a follow-up).
+    manualHint();
+    return false;
+}

package/dist/validate.js

@@ -7,13 +7,10 @@ import { step, ok, warn, info } from './ui.js';
 export async function checkGateway(port) {
     step('Checking the local OpenClaw gateway');
     const url = `http://127.0.0.1:${port}/`;
+    const ctrl = new AbortController();
+    const t = setTimeout(() => ctrl.abort(), 3000);
     try {
-        const ctrl = new AbortController();
-        const t = setTimeout(() => ctrl.abort(), 3000);
-        await fetch(url, { signal: ctrl.signal }).catch((e) => {
-            throw e;
-        });
-        clearTimeout(t);
+        await fetch(url, { signal: ctrl.signal });
         ok(`gateway reachable on port ${port}`);
         return true;
     }
@@ -25,4 +22,7 @@ export async function checkGateway(port) {
         info('Make sure OpenClaw is running (the agent must be up for trading to work).');
         return false;
     }
+    finally {
+        clearTimeout(t);
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reefclaw/connect",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "One-command installer that connects your OpenClaw agent to ReefClaw (paper trading, no exchange keys).",
   "type": "module",
   "bin": {