@reefclaw/connect 0.1.30 → 0.1.32

package/assets/plugin/tools/intel-api.js

@@ -1,5 +1,6 @@
 // Shared helper for Intelligence API calls.
 // All intelligence tools use Bearer token auth against intel.reefclaw.com.
+import { keepAliveFetch } from '../http/keepalive-fetch.js';
 import { HL_INTEL_PREFIX, fromIntelSymbol, toIntelSymbol } from '../venues/symbols.js';
 // ─── Venue-aware intel-symbol mapping (plan §5.3: the agent keeps using
 //     canonical symbols like BTC/USDC; these helpers translate at the intel
@@ -67,6 +68,13 @@ export function intelSymbolOnVenue(deps, intelSymbol) {
     const isHl = intelSymbol.startsWith(HL_INTEL_PREFIX);
     return (deps.venue ?? 'binance') === 'hyperliquid' ? isHl : !isHl;
 }
+const getCache = new Map();
+const GET_CACHE_MAX_ENTRIES = 256;
+/** Test support: drop every cached GET response (the cache is module-level,
+ *  so suites that stub fetch with per-test responses must clear it). */
+export function clearIntelGetCache() {
+    getCache.clear();
+}
 /** Encode a value for safe use in a URL path segment */
 export const enc = encodeURIComponent;
 export async function fetchIntelApi(path, deps, options) {
@@ -78,6 +86,29 @@ export async function fetchIntelApi(path, deps, options) {
         return { error: 'No intelligence URL configured. Set intelligenceUrl in openclaw.json plugin config.' };
     }
     const url = `${intelligenceUrl}${path}`;
+    const ttl = options?.cacheTtlMs ?? 0;
+    if (ttl > 0 && (options?.method ?? 'GET') === 'GET') {
+        const key = `${connectionToken}:${url}`;
+        const hit = getCache.get(key);
+        if (hit && Date.now() - hit.at < ttl) {
+            // structuredClone: callers must never alias each other's response object.
+            return hit.value.then((v) => structuredClone(v));
+        }
+        const value = fetchIntelApiUncached(url, connectionToken, options);
+        getCache.set(key, { at: Date.now(), value });
+        // Failures don't stick for the TTL — next caller retries fresh.
+        void value.then((v) => { if (v && typeof v === 'object' && 'error' in v)
+            getCache.delete(key); }, () => getCache.delete(key));
+        if (getCache.size > GET_CACHE_MAX_ENTRIES) {
+            const oldest = getCache.keys().next().value;
+            if (oldest !== undefined)
+                getCache.delete(oldest);
+        }
+        return value.then((v) => structuredClone(v));
+    }
+    return fetchIntelApiUncached(url, connectionToken, options);
+}
+async function fetchIntelApiUncached(url, connectionToken, options) {
     const headers = { Authorization: `Bearer ${connectionToken}` };
     const fetchInit = {
         method: options?.method ?? 'GET',
@@ -89,7 +120,7 @@ export async function fetchIntelApi(path, deps, options) {
         fetchInit.body = JSON.stringify(options.body);
     }
     try {
-        const res = await fetch(url, fetchInit);
+        const res = await keepAliveFetch(url, fetchInit);
         if (res.status === 401) {
             return { error: 'Invalid or expired ReefClaw connection token.' };
         }

package/assets/plugin/tools/record-position-reviews.js

@@ -94,7 +94,6 @@ export async function recordPositionReviewsTool(args, deps) {
     // not load-bearing (each row carries its own reviewAt).
     let filed = 0;
     if (deps.decisionsClient && deps.userId) {
-        const promises = [];
         for (const r of reviews) {
             const stateEntry = deps.stateStore?.get(r.symbol);
             const positionId = stateEntry?.webappPositionId;
@@ -137,7 +136,8 @@ export async function recordPositionReviewsTool(args, deps) {
                 deps.stateStore.recordReview(r.symbol, r.verdict, undefined, r.thesis_status);
             }
         }
-        await Promise.allSettled(promises);
+        // POSTs above are fire-and-forget by design — durability is the client's
+        // in-flight set + drain(), not an await here.
     }
     else {
         logger.info(TAG, `record_position_reviews validated ${reviews.length} reviews; no decisionsClient configured (off-mode).`);

package/assets/plugin/tools/scan-pairs.js

@@ -129,8 +129,20 @@ function learningMatches(learning, setupType, regime) {
 }
 export async function scanPairsTool(args, deps, decisionsDeps) {
     const minScore = args.min_score ?? 4;
-    // 1. Fetch all symbol facts (cached, shared with get_setup_detail)
-    const factsRes = await getAllFactsCached(deps);
+    // Facts, strategies, and entry learnings are three independent reads (two
+    // intel, one webapp) — start them all now and await in the original order,
+    // so error precedence (facts → strategies → learnings-fail-quiet) and every
+    // early-return body stay byte-identical while the round-trips overlap.
+    const factsPromise = getAllFactsCached(deps);
+    const stratPromise = getStrategiesCached(deps);
+    const learningsPromise = decisionsDeps?.decisionsClient && decisionsDeps.userId
+        ? getEntryLearningsCached(decisionsDeps.decisionsClient, decisionsDeps.userId)
+        : Promise.resolve([]);
+    // An early return below must not leave a floating rejection behind.
+    stratPromise.catch(() => { });
+    learningsPromise.catch(() => { });
+    // 1. All symbol facts (cached, shared with get_setup_detail)
+    const factsRes = await factsPromise;
     if ('error' in factsRes)
         return factsRes;
     // Venue scope: only rank symbols this box can actually trade. Without this
@@ -154,8 +166,8 @@ export async function scanPairsTool(args, deps, decisionsDeps) {
                 : 'No symbol facts available. Intelligence service may still be computing initial data.',
         };
     }
-    // 2. Fetch user's active strategies (cached, shared with get_setup_detail)
-    const stratRes = await getStrategiesCached(deps);
+    // 2. User's active strategies (cached, shared with get_setup_detail)
+    const stratRes = await stratPromise;
     if ('error' in stratRes)
         return stratRes;
     const strategies = stratRes;
@@ -171,13 +183,10 @@ export async function scanPairsTool(args, deps, decisionsDeps) {
     }
     // 3. Evaluate all strategies against all facts
     const results = scanAllPairs(strategies, facts, minScore);
-    // 4. Fetch user's confirmed entry-time learnings (optional path — fail
-    //    quietly when the decisions client isn't wired, e.g. in dev or in
-    //    tests that exercise the pre-learning behaviour).
-    let entryLearnings = [];
-    if (decisionsDeps?.decisionsClient && decisionsDeps.userId) {
-        entryLearnings = await getEntryLearningsCached(decisionsDeps.decisionsClient, decisionsDeps.userId);
-    }
+    // 4. User's confirmed entry-time learnings (optional path — resolves []
+    //    when the decisions client isn't wired, e.g. in dev or in tests that
+    //    exercise the pre-learning behaviour).
+    const entryLearnings = await learningsPromise;
     const rankings = [];
     const vetoed = [];
     for (const r of results) {

package/assets/plugin/types.d.ts

@@ -63,6 +63,13 @@ export interface CcxtPosition {
     contractSize: number;
     entryPrice: number;
     markPrice: number;
+    /** Paper only: true when NO quote was available for this symbol, so
+     *  `markPrice` is a fabricated fallback (entryPrice) rather than a real mark.
+     *  Consumers that make protective decisions MUST NOT read `markPrice` as
+     *  truth when this is set — a fabricated "flat since entry" mark reads as a
+     *  healthy position and is how a breached stop stayed invisible for 35h.
+     *  Undefined on live (real marks come from the exchange). */
+    markPriceStale?: boolean;
     notional: number;
     unrealizedPnl: number;
     percentage: number;

package/assets/plugin/venues/hyperliquid/hl-live-adapter.d.ts

@@ -6,6 +6,7 @@ import { type HlCredentials } from './hl-private.js';
 import type { BracketId } from '../../live/bracket-types.js';
 import { BracketLedger } from '../../live/bracket-ledger.js';
 import { HlBracketCoordinator } from './hl-bracket-coordinator.js';
+import { type AutoCaptureContext } from '../../ingest/position-auto-capture.js';
 import type { TradeIngestWiring } from '../../live/live-adapter.js';
 export interface HlLiveAdapterOptions {
     credentials: HlCredentials;
@@ -23,6 +24,16 @@ export interface HlLiveAdapterOptions {
      *  via userFillsByTime. Same object boot passes the Binance adapter —
      *  `exchange` MUST be fillExchangeId('hyperliquid'). */
     tradeIngest?: TradeIngestWiring;
+    /** Position-decision journal wiring. When present, a close-direction user-
+     *  stream fill (dir "Close …" or a liquidation fill) is routed through
+     *  `onWsFillObserved` so an exchange-native bracket SL/TP fill journals an
+     *  EXACT close (reason `bracket_fill`) instead of leaking as status='open'
+     *  until the reconciler heals it as `reconciler_observed_flat` — the HL
+     *  analog of the wiring Binance's ws-ingest has carried since PR #205.
+     *  Entry/scale-in fills are deliberately NOT routed (the sync create_order
+     *  path captures them; the WS dedup key is unverified on HL — see
+     *  onUserFill). */
+    autoCapture?: AutoCaptureContext;
     /** Test seams. Production omits both. */
     bracketLedger?: BracketLedger;
     disableUserStream?: boolean;
@@ -54,6 +65,10 @@ export declare class HyperliquidLiveAdapter extends EventEmitter implements IExc
     /** exchangeTime of the newest fill ingested (WS or backfill) — the overlap
      *  low-water mark the reconnect gap backfill widens from. */
     private lastFillIngestMs;
+    /** oid → cloid backfill for fills that omit `cloid` (the journal close path
+     *  recognizes bracket legs by client id). Populated from `orderUpdates`,
+     *  which always carries both. Bounded, insertion-order eviction. */
+    private readonly oidToCloid;
     /** UTC-midnight Day-P&L anchor (KPI-must-equal-the-HL-app, §5.8). HL has no
      *  income endpoint, so the anchor is rebuilt from userFillsByTime + userFunding
      *  each balance fetch. Without this the skill self-computes a bogus anchor and
@@ -187,10 +202,20 @@ export declare class HyperliquidLiveAdapter extends EventEmitter implements IExc
      *  `startPosition` is the position BEFORE this fill — the WS-authoritative
      *  way to know the after-fill total without an extra REST read. */
     private onUserFill;
+    /** Close-direction fill → position-decision journal (close-bypass fix, HL
+     *  arm). Fire-and-forget: a journal POST blip must never touch the WS hot
+     *  path. Reduce-only is derived from `dir` (HL fills carry no reduceOnly
+     *  flag): "Close Long"/"Close Short", plus the liquidation marker. Flip
+     *  dirs ("Long > Short") are NOT closes of a tracked side we understand —
+     *  they stay with the reconciler backstop. */
+    private captureCloseFill;
     /** `orderUpdates` is authoritative for leg lifecycle (the ALGO_UPDATE
-     *  analog). A trigger = the exchange closed the position — surface the same
+     *  analog). A trigger = the exchange closed the position — surface the
      *  `drift_detected` close shape the Binance reconciler emits so the journal
-     *  close-bypass cleanup fires at once, not ≤5 min late. */
+     *  close-bypass cleanup fires fast — but AFTER a short grace, so the close
+     *  FILL (the exact-close journal path, `captureCloseFill`) wins the
+     *  undocumented orderUpdates/userFills frame ordering. The cleanup is
+     *  idempotent: state already dropped by the fill path ⇒ no-op. */
     private onUserOrderUpdate;
     /** T-5 REST truth-check — serialized so a slow pass can't stack. */
     private runTruthCheck;

package/assets/plugin/venues/hyperliquid/hl-live-adapter.js

@@ -38,7 +38,8 @@ import { generateBracketId } from '../../live/bracket-id.js';
 import { validateStopDirection, validateTargetDirection } from '../../live/bracket-params.js';
 import { HlBracketCoordinator, isRejectedOrder, isTerminalBracketState, } from './hl-bracket-coordinator.js';
 import { HyperliquidUserStream } from './hl-user-stream.js';
-import { hlFillToFillEvent } from './hl-fill-ingest.js';
+import { hlFillToFillEvent, hlCoinToCanonical } from './hl-fill-ingest.js';
+import { onWsFillObserved } from '../../ingest/position-auto-capture.js';
 import { formatError } from '../../logger.js';
 const TAG = 'hl-live-adapter';
 /** Venue-distinct ledger storage — a venue switch on the same box must never
@@ -55,6 +56,21 @@ const DEFAULT_MARKET_SLIPPAGE = 0.005;
 /** Sticky cooldown after a failed open-orders fetch (the Binance lesson: the
  *  SKILL.md audit→attach loop re-calls every ~3s and would pin the budget). */
 const OPEN_ORDERS_COOLDOWN_MS = 45_000;
+/** Grace before a bracket-trigger `drift_detected` emit. A trigger's close FILL
+ *  arrives on `userFills` and journals the exact close (real price, real PnL,
+ *  reason `bracket_fill`); the drift path's cleanup can only post a generic
+ *  `reconciler_observed_flat`. HL's WS frame ordering between `orderUpdates`
+ *  and `userFills` is undocumented, so without this grace the generic close
+ *  routinely won the race and 50% of HL live closes carried no close reason
+ *  (wisekid, 30d to 2026-08-17: 150/299). The cleanup is idempotent — when the
+ *  fill already journaled + dropped state, the delayed drift is a no-op; when
+ *  the fill never arrives (T-5 gap), the drift still heals, 10s late instead
+ *  of instant (previously ≤5 min via the periodic sweep). */
+const TRIGGER_DRIFT_GRACE_MS = 10_000;
+/** Bound on the oid→cloid map (fills MAY omit `cloid` — facts ledger §3.4 —
+ *  while `orderUpdates` always carries both, so the map backfills the fill's
+ *  client id for bracket recognition). Insertion-ordered eviction. */
+const OID_CLOID_MAP_MAX = 512;
 export class HyperliquidLiveAdapter extends EventEmitter {
     opts;
     api;
@@ -82,6 +98,10 @@ export class HyperliquidLiveAdapter extends EventEmitter {
     /** exchangeTime of the newest fill ingested (WS or backfill) — the overlap
      *  low-water mark the reconnect gap backfill widens from. */
     lastFillIngestMs = 0;
+    /** oid → cloid backfill for fills that omit `cloid` (the journal close path
+     *  recognizes bracket legs by client id). Populated from `orderUpdates`,
+     *  which always carries both. Bounded, insertion-order eviction. */
+    oidToCloid = new Map();
     /** UTC-midnight Day-P&L anchor (KPI-must-equal-the-HL-app, §5.8). HL has no
      *  income endpoint, so the anchor is rebuilt from userFillsByTime + userFunding
      *  each balance fetch. Without this the skill self-computes a bogus anchor and
@@ -821,6 +841,19 @@ export class HyperliquidLiveAdapter extends EventEmitter {
         // healed it, in a repeating flap. Exchange truth is the resync's job.
         if (meta?.isSnapshot)
             return;
+        // Journal close capture: a close-direction fill (bracket SL/TP trigger,
+        // liquidation, external reduce) bypasses close_position, and before this
+        // wiring the journal only learned about it from the reconciler — 50% of
+        // wisekid's 30d closes were `reconciler_observed_flat` heals with the
+        // close reason lost. Route it through the SAME generic path Binance's
+        // ws-ingest uses; `handleReduceOnlyExit` posts the exact close when the
+        // position goes flat and defers to close_position/backstop otherwise.
+        // ONLY close-direction fills are routed: entry/scale-in fills stay with
+        // the synchronous create_order capture, because the WS dedup key
+        // (`openedFromExchangeTradeId === exchangeOrderId`) is unverified against
+        // ccxt's HL order.id shape and a dedup miss would re-mint the 38-duplicate-
+        // pairs class (issue #199 twin bug).
+        this.captureCloseFill(fill);
         try {
             // Matches the primary entry cid OR any additional cid recorded for a
             // scale-in / second resting entry (F5) — matching on `entryCid` alone
@@ -848,27 +881,82 @@ export class HyperliquidLiveAdapter extends EventEmitter {
             logger.error(TAG, `onUserFill handler error: ${formatError(err)}`);
         }
     }
+    /** Close-direction fill → position-decision journal (close-bypass fix, HL
+     *  arm). Fire-and-forget: a journal POST blip must never touch the WS hot
+     *  path. Reduce-only is derived from `dir` (HL fills carry no reduceOnly
+     *  flag): "Close Long"/"Close Short", plus the liquidation marker. Flip
+     *  dirs ("Long > Short") are NOT closes of a tracked side we understand —
+     *  they stay with the reconciler backstop. */
+    captureCloseFill(fill) {
+        const capture = this.opts.autoCapture;
+        if (!capture)
+            return;
+        const dir = (fill.dir ?? '').toLowerCase();
+        const isClose = dir.startsWith('close') || fill.liquidation !== undefined;
+        if (!isClose)
+            return;
+        const price = Number(fill.px);
+        const size = Number(fill.sz);
+        if (!Number.isFinite(price) || price <= 0 || !Number.isFinite(size) || size <= 0)
+            return;
+        const realizedPnl = Number(fill.closedPnl);
+        const cloid = typeof fill.cloid === 'string' && fill.cloid.length > 0
+            ? fill.cloid
+            : this.oidToCloid.get(fill.oid);
+        onWsFillObserved(capture, {
+            symbol: hlCoinToCanonical(fill.coin),
+            side: fill.side === 'B' ? 'buy' : 'sell',
+            exchangeOrderId: String(fill.oid),
+            exchangeTradeId: String(fill.tid),
+            fillPrice: price,
+            fillSize: size,
+            reduceOnly: true,
+            realizedPnl: Number.isFinite(realizedPnl) ? realizedPnl : undefined,
+            clientOrderId: cloid,
+            exchangeTimeMs: Number.isFinite(fill.time) ? fill.time : undefined,
+        }).catch((err) => {
+            logger.warn(TAG, `journal close capture failed for ${fill.coin} oid=${fill.oid}: ${msg(err)}`);
+        });
+    }
     /** `orderUpdates` is authoritative for leg lifecycle (the ALGO_UPDATE
-     *  analog). A trigger = the exchange closed the position — surface the same
+     *  analog). A trigger = the exchange closed the position — surface the
      *  `drift_detected` close shape the Binance reconciler emits so the journal
-     *  close-bypass cleanup fires at once, not ≤5 min late. */
+     *  close-bypass cleanup fires fast — but AFTER a short grace, so the close
+     *  FILL (the exact-close journal path, `captureCloseFill`) wins the
+     *  undocumented orderUpdates/userFills frame ordering. The cleanup is
+     *  idempotent: state already dropped by the fill path ⇒ no-op. */
     onUserOrderUpdate(update) {
         try {
+            // oid→cloid backfill for fills that omit their client id (see
+            // captureCloseFill). orderUpdates always carries both.
+            const { oid, cloid } = update.order;
+            if (typeof oid === 'number' && typeof cloid === 'string' && cloid.length > 0) {
+                this.oidToCloid.set(oid, cloid);
+                if (this.oidToCloid.size > OID_CLOID_MAP_MAX) {
+                    const oldest = this.oidToCloid.keys().next().value;
+                    if (oldest !== undefined)
+                        this.oidToCloid.delete(oldest);
+                }
+            }
             const transition = this.getHlBracketCoordinator().handleOrderUpdate(update);
             if (transition === 'triggered_sl' || transition === 'triggered_tp' || transition === 'forced_close') {
                 const row = this.getHlBracketCoordinator().getLedger().getAll().find((r) => update.order.cloid && (r.slCid === update.order.cloid || r.tpCid === update.order.cloid));
                 const symbol = row?.symbol;
                 if (symbol) {
-                    this.emit('drift_detected', {
-                        timestamp: new Date().toISOString(),
-                        drifts: [
-                            {
-                                type: 'closed',
-                                symbol,
-                                localContracts: row?.qty ?? 0,
-                            },
-                        ],
-                    });
+                    const qty = row?.qty ?? 0;
+                    const timer = setTimeout(() => {
+                        this.emit('drift_detected', {
+                            timestamp: new Date().toISOString(),
+                            drifts: [
+                                {
+                                    type: 'closed',
+                                    symbol,
+                                    localContracts: qty,
+                                },
+                            ],
+                        });
+                    }, TRIGGER_DRIFT_GRACE_MS);
+                    timer.unref?.();
                 }
             }
         }

package/assets/shared/readiness.js

@@ -33,7 +33,11 @@ export const READINESS_CHECK_COPY = {
     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).',
+        // Venue-neutral on purpose: the same check runs on a Hyperliquid box,
+        // where naming Binance is a false alarm for an exchange the user does not
+        // use. Both venues reject/miscompute signed requests on a skewed clock
+        // (Binance -1021 recvWindow; Hyperliquid signs an epoch-ms nonce).
+        fixHint: 'The host clock drifts from your exchange’s server time. Enable NTP/chrony so signed orders are not rejected (Binance rejects with -1021; Hyperliquid nonces are epoch-ms and must not skew).',
     },
     plugin_loaded: {
         label: 'ReefClaw plugin loaded',

package/dist/cli.js

@@ -15,7 +15,7 @@ import { installBridge } from './bridge.js';
 import { installSkill } from './skill.js';
 import { enableConnectorSupervisor } from './supervisor-config.js';
 import { tuneGatewayMemory } from './gateway-tuning.js';
-import { checkGateway, checkBinanceRegion } from './validate.js';
+import { checkGateway, checkBinanceRegion, checkHyperliquidRegion } from './validate.js';
 import { readConfig, writeConfig, mergeReefClawConfig, gatewayAuthAlreadyRelaxed, openClawInstalled, openClawConfigPath, readGatewayPort, } from './openclaw.js';
 import { run, which } from './exec.js';
 import { step, ok, info, warn, fail, banner, bold, green, cyan, dim } from './ui.js';
@@ -136,13 +136,34 @@ function nextSteps() {
         `  3. The dashboard lights up ${green('green / Connected')} on its own within a few seconds.\n\n` +
         dim(`Dashboard: ${DASHBOARD}\n`));
 }
+/** `--venue hyperliquid` / `--venue=binance`. Absent = unknown: the user has
+ *  not chosen yet (venue is picked on the dashboard AFTER connecting), so we
+ *  run the Binance probe but phrase its failure as "Binance is blocked here",
+ *  never as "trading cannot work here". */
+function parseVenueArg(argv) {
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        const v = a.startsWith('--venue=') ? a.slice('--venue='.length) : a === '--venue' ? argv[i + 1] : undefined;
+        if (v === 'binance' || v === 'hyperliquid')
+            return v;
+    }
+    return null;
+}
 async function main() {
     banner(bold(cyan('ReefClaw connect')) + dim('  — link your OpenClaw agent to ReefClaw (paper trading)'));
     preflight();
-    // Prevention: a host in a Binance-restricted region (HTTP 451) can't trade —
-    // not even paper, which uses live Binance prices. Advisory (never fatal); the
-    // dashboard readiness surface re-checks it live after connect.
-    const binanceReachable = await checkBinanceRegion();
+    // Venue-aware reachability. ReefClaw trades Binance AND Hyperliquid; probing
+    // Binance for a Hyperliquid user produced a red "trading cannot work from
+    // here" on hosts where Hyperliquid works perfectly — the first thing such a
+    // user saw. `--venue hyperliquid` probes the venue they actually want.
+    const venue = parseVenueArg(process.argv.slice(2));
+    let binanceReachable = true;
+    if (venue === 'hyperliquid') {
+        await checkHyperliquidRegion();
+    }
+    else {
+        binanceReachable = await checkBinanceRegion();
+    }
     const pre = readConfig();
     const plugin = installPlugin();
     const merged = wireConfig(pre);
@@ -171,7 +192,7 @@ async function main() {
         warn('Connector supervision was not enabled — see the message above to finish it.');
     }
     if (!binanceReachable) {
-        warn('This host looks geo-blocked by Binance (HTTP 451) — trading will not work until you run the agent from a Binance-permitted region (most EU / several Asia VPS regions).');
+        warn('This host looks geo-blocked by BINANCE (HTTP 451). Binance trading will not work here — run the agent from a Binance-permitted region (most EU / several Asia VPS regions), or choose HYPERLIQUID on the dashboard, which is reachable from most regions including this one.');
     }
     nextSteps();
 }

package/dist/openclaw.js

@@ -74,7 +74,7 @@ export function mergeReefClawConfig(input, connect = {}) {
     // --- tool profile widening ---
     // `openclaw setup` defaults tools.profile to "coding" (2026.6+), whose fixed
     // core allowlist filters out ALL plugin tools — the agent would see none of
-    // the 62 trading tools. tools.alsoAllow explicitly widens the profile;
+    // the 66 trading tools. tools.alsoAllow explicitly widens the profile;
     // group:plugins covers every plugin-provided tool. Union, never replace.
     const existingAlsoAllow = Array.isArray(tools.alsoAllow) ? tools.alsoAllow.map(String) : [];
     if (!existingAlsoAllow.includes('group:plugins')) {

package/dist/validate.js

@@ -1,7 +1,7 @@
 // Light post-install checks. We can only verify the LOCAL gateway here — the
 // relay handshake only succeeds once the user pastes their connect message
 // (that's the onboarding "auto-detect" step on the dashboard).
-import { step, ok, warn, info, fail } from './ui.js';
+import { step, ok, warn, info } from './ui.js';
 /** Any HTTP response from the local gateway means OpenClaw is up and reachable.
  *  A connection refused means OpenClaw isn't running. */
 export async function checkGateway(port) {
@@ -27,11 +27,17 @@ export async function checkGateway(port) {
     }
 }
 /** Probe whether Binance USD-M Futures is reachable from THIS host. A `451` is
- *  Binance's geo-restriction signal — the host's region is blocked, and trading
- *  (even paper mode, which uses live Binance prices) cannot work from here. The
- *  probe is advisory: only a definitive `451` returns false; a network hiccup /
- *  timeout is NOT a geo-block, so we stay out of the way and let the dashboard
- *  readiness surface confirm a real, persistent problem later. Never fatal. */
+ *  Binance's geo-restriction signal — the host's region is blocked, so Binance
+ *  trading (and Binance-priced paper mode) cannot work from here. The probe is
+ *  advisory: only a definitive `451` returns false; a network hiccup / timeout
+ *  is NOT a geo-block, so we stay out of the way and let the dashboard
+ *  readiness surface confirm a real, persistent problem later. Never fatal.
+ *
+ *  ★ The copy deliberately names BINANCE, not "trading" — ReefClaw also trades
+ *  Hyperliquid, which is reachable from most regions INCLUDING Binance-blocked
+ *  ones (verified live). Telling a Hyperliquid user to relocate their server
+ *  because of Binance is a false alarm, and it used to be the first thing a
+ *  Hyperliquid-only user saw. Pass `--venue hyperliquid` to skip this entirely. */
 export async function checkBinanceRegion() {
     step('Checking Binance reachability from this host');
     const url = 'https://fapi.binance.com/fapi/v1/ping';
@@ -40,9 +46,11 @@ export async function checkBinanceRegion() {
     try {
         const res = await fetch(url, { signal: ctrl.signal });
         if (res.status === 451) {
-            fail('Binance returned HTTP 451 — this host is in a Binance-restricted region.');
-            info('Trading (and paper mode, which uses live Binance prices) cannot work from here.');
-            info('Run the agent from a Binance-permitted region — most EU / several Asia VPS regions work.');
+            warn('Binance returned HTTP 451 — this host is in a Binance-restricted region.');
+            info('BINANCE trading (and paper mode, which uses live Binance prices) cannot work from here.');
+            info('Either run the agent from a Binance-permitted region (most EU / several Asia VPS');
+            info('regions work), or trade HYPERLIQUID instead — it is reachable from most regions,');
+            info('including this one. You pick the exchange on the dashboard after connecting.');
             return false;
         }
         ok('Binance is reachable from this host');
@@ -58,3 +66,32 @@ export async function checkBinanceRegion() {
         clearTimeout(t);
     }
 }
+/** Probe Hyperliquid reachability — the venue-correct check for a user who
+ *  told us (`--venue hyperliquid`) that is what they intend to trade. */
+export async function checkHyperliquidRegion() {
+    step('Checking Hyperliquid reachability from this host');
+    const ctrl = new AbortController();
+    const t = setTimeout(() => ctrl.abort(), 5000);
+    try {
+        const res = await fetch('https://api.hyperliquid.xyz/info', {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ type: 'meta' }),
+            signal: ctrl.signal,
+        });
+        if (res.ok) {
+            ok('Hyperliquid is reachable from this host');
+            return true;
+        }
+        warn(`Hyperliquid responded HTTP ${res.status} from this host.`);
+        info('The dashboard re-checks this after you connect.');
+        return false;
+    }
+    catch {
+        info('Could not probe Hyperliquid reachability (network hiccup) — skipping; the dashboard verifies it after connect.');
+        return true;
+    }
+    finally {
+        clearTimeout(t);
+    }
+}

package/package.json

@@ -1,32 +1,33 @@
-{
-  "name": "@reefclaw/connect",
-  "version": "0.1.30",
-  "description": "One-command installer that connects your OpenClaw agent to ReefClaw (paper trading, no exchange keys).",
-  "type": "module",
-  "bin": {
-    "reefclaw-connect": "dist/cli.js"
-  },
-  "files": [
-    "dist",
-    "assets"
-  ],
-  "engines": {
-    "node": ">=20"
-  },
-  "scripts": {
-    "bundle-assets": "node scripts/bundle-assets.mjs",
-    "build": "tsc && node scripts/bundle-assets.mjs",
-    "test": "vitest",
-    "test:run": "vitest run"
-  },
-  "dependencies": {
-    "json5": "2.2.3"
-  },
-  "devDependencies": {
-    "@types/node": "^20",
-    "typescript": "^5",
-    "vitest": "^4.0.18"
-  },
-  "license": "MIT",
-  "homepage": "https://reefclaw.com"
-}
+{
+  "name": "@reefclaw/connect",
+  "version": "0.1.32",
+  "description": "One-command installer that connects your OpenClaw agent to ReefClaw (paper trading, no exchange keys).",
+  "type": "module",
+  "bin": {
+    "reefclaw-connect": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "assets"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "bundle-assets": "node scripts/bundle-assets.mjs",
+    "prepack": "npm run build",
+    "build": "tsc && node scripts/bundle-assets.mjs",
+    "test": "vitest",
+    "test:run": "vitest run"
+  },
+  "dependencies": {
+    "json5": "2.2.3"
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "typescript": "^5",
+    "vitest": "^4.0.18"
+  },
+  "license": "MIT",
+  "homepage": "https://reefclaw.com"
+}