@reefclaw/openclaw-plugin 0.1.10 → 0.1.12

package/bridge/gateway/event-parser.d.ts

@@ -155,6 +155,29 @@ export declare function extractBracketField(pos: {
     tpPrice?: number;
     state: string;
 } | undefined;
+/**
+ * Narrow the agent's PLANNED protective levels off a plugin-decorated position.
+ *
+ * `bracket` above is exchange truth and only exists where a venue-side ledger
+ * row does. In PAPER (either venue) there are no exchange legs — the levels
+ * live in the position's metadata and the stop-watcher enforces them — so
+ * without these fields the dashboard had NO target at all and drew the
+ * frozen-at-fill `originalStopPrice` as the stop even after a modify_stop.
+ * Both adapters already emit `stopPrice` / `targetPrice` on the CCXT position
+ * (ExchangeSimulator.getPositions, LiveAdapter.decoratePositionsWithMetadata);
+ * we only re-validate the shape here because CcxtPosition's index signature
+ * is `unknown`.
+ *
+ * ★ `plannedStopPrice` is the CURRENT stop (modify_stop moves it), NOT the
+ * frozen `originalStopPrice` R-denominator — never conflate the two. Display
+ * precedence is bracket (exchange truth) → planned → original.
+ */
+export declare function extractPlannedLevels(pos: {
+    [key: string]: unknown;
+}): {
+    plannedStopPrice?: number;
+    plannedTargetPrice?: number;
+};
 /** The payload shape received from GatewayWsClient 'agent' event */
 export interface AgentEventPayload {
     runId: string;

package/bridge/gateway/event-parser.js

@@ -304,6 +304,42 @@ export function extractBracketField(pos) {
         out.tpPrice = tpPrice;
     return out;
 }
+/**
+ * Narrow the agent's PLANNED protective levels off a plugin-decorated position.
+ *
+ * `bracket` above is exchange truth and only exists where a venue-side ledger
+ * row does. In PAPER (either venue) there are no exchange legs — the levels
+ * live in the position's metadata and the stop-watcher enforces them — so
+ * without these fields the dashboard had NO target at all and drew the
+ * frozen-at-fill `originalStopPrice` as the stop even after a modify_stop.
+ * Both adapters already emit `stopPrice` / `targetPrice` on the CCXT position
+ * (ExchangeSimulator.getPositions, LiveAdapter.decoratePositionsWithMetadata);
+ * we only re-validate the shape here because CcxtPosition's index signature
+ * is `unknown`.
+ *
+ * ★ `plannedStopPrice` is the CURRENT stop (modify_stop moves it), NOT the
+ * frozen `originalStopPrice` R-denominator — never conflate the two. Display
+ * precedence is bracket (exchange truth) → planned → original.
+ */
+export function extractPlannedLevels(pos) {
+    const num = (v) => typeof v === 'number' && Number.isFinite(v) && v > 0 ? v : undefined;
+    // A `fixed_target` realization rule carries the same number; use it only as a
+    // fallback for entries that pinned the rule without a top-level targetPrice.
+    const rule = pos.realizationRule;
+    const ruleTarget = rule && typeof rule === 'object'
+        ? rule.type === 'fixed_target'
+            ? num(rule.targetPrice)
+            : undefined
+        : undefined;
+    const stop = num(pos.stopPrice);
+    const target = num(pos.targetPrice) ?? ruleTarget;
+    const out = {};
+    if (stop !== undefined)
+        out.plannedStopPrice = stop;
+    if (target !== undefined)
+        out.plannedTargetPrice = target;
+    return out;
+}
 /**
  * Build the wallet/available/locked tuple from Binance Futures `info.assets[]`
  * when present. Returns null when the field is absent or unusable so the

package/bridge/gateway/tool-discovery.d.ts

@@ -1,9 +1,23 @@
-import { GatewayHttpClient } from './gateway-http-client.js';
+import { GatewayHttpClient, GatewayHttpError } from './gateway-http-client.js';
 /**
  * Logical tool names used by ReefClaw internally.
  * Each maps to one or more candidate actual tool names on the gateway.
  */
 export type LogicalTool = 'fetch_ticker' | 'fetch_balance' | 'fetch_ohlcv' | 'fetch_positions' | 'fetch_open_orders' | 'cancel_all_orders' | 'cancel_order' | 'close_position' | 'create_order' | 'get_market_structure' | 'get_crypto_metrics' | 'get_market_intel' | 'set_trading_mode' | 'set_exchange_credentials' | 'test_exchange_credentials' | 'clear_exchange_credentials' | 'get_bracket_config' | 'set_bracket_requirement';
+/**
+ * Build the test args used when probing each logical tool.
+ *
+ * Read tools (ticker, ohlcv, market structure, …) use the CONFIGURED symbol so
+ * the probe is venue-correct — the old hardcoded 'BTC/USDT' made every probe
+ * throw on a Hyperliquid-venue box ("not USDC-quoted"), which dropped the
+ * tools whose probes throw (fetch_open_orders, cancel_all_orders) and left the
+ * bridge retrying discovery every 30s forever (observed live on the HL rig,
+ * 2026-07-24).
+ *
+ * Destructive-capable tools (cancel_all_orders, close_position) probe with the
+ * PROBE_SENTINEL_SYMBOL so they can never execute against real state.
+ */
+export declare function buildProbeArgs(symbol?: string): Record<LogicalTool, Record<string, unknown>>;
 /** Map of logical tool names to their discovered actual tool names on the gateway */
 export type ToolMap = Partial<Record<LogicalTool, string>>;
 export interface DiscoveryResult {
@@ -16,10 +30,15 @@ export interface DiscoveryResult {
     /** Logical names of optional tools that are missing */
     missingOptional: LogicalTool[];
 }
+/** True when an envelope-level (HTTP 200, ok:false) error denotes an unknown
+ *  tool name rather than a tool that executed and failed. Exported for tests. */
+export declare function isUnknownToolEnvelopeError(err: GatewayHttpError): boolean;
 /**
  * Discover all available trading tools on the gateway.
  *
  * Probes required tools first, then optional tools in parallel.
  * Fails fast if no required tools are found.
  */
-export declare function discoverTools(http: GatewayHttpClient): Promise<DiscoveryResult>;
+export declare function discoverTools(http: GatewayHttpClient, opts?: {
+    symbol?: string;
+}): Promise<DiscoveryResult>;

package/bridge/gateway/tool-discovery.js

@@ -47,53 +47,109 @@ const CANDIDATES = {
     get_bracket_config: ['get_bracket_config'],
     set_bracket_requirement: ['set_bracket_requirement'],
 };
+/** Default probe symbol when the caller does not supply the configured one.
+ *  Kept for back-compat with pre-symbol callers; real deployments should pass
+ *  the configured symbol so probes are venue-correct (see buildProbeArgs). */
+const DEFAULT_PROBE_SYMBOL = 'BTC/USDT';
+/** Sentinel symbol for probes of DESTRUCTIVE-CAPABLE tools. It never resolves
+ *  to a market on any venue, so the probe can never touch a real order or
+ *  position: the tool executes, fails fast client-side, and the envelope-level
+ *  error still proves the tool exists (see probeCandidate).
+ *
+ *  ★ Why this exists (2026-07-24): cancel_all_orders was probed with a REAL
+ *  symbol — a valid, executable cancel-all sweep. On a live box with a resting
+ *  working order, every bridge restart (and every 30s discovery retry) would
+ *  silently cancel it. A probe must never be an order-book mutation. */
+const PROBE_SENTINEL_SYMBOL = '__probe__';
 /**
- * Test args used when probing each logical tool.
- * Read tools (ticker, balance, etc.) use real args that return data.
- * Write tools (create_order, cancel, close) use args that will be
- * rejected by exchange validation (amount:0, etc.) — we only need
- * to distinguish 400 (tool exists, bad args) from 404 (tool not found).
+ * Build the test args used when probing each logical tool.
+ *
+ * Read tools (ticker, ohlcv, market structure, …) use the CONFIGURED symbol so
+ * the probe is venue-correct — the old hardcoded 'BTC/USDT' made every probe
+ * throw on a Hyperliquid-venue box ("not USDC-quoted"), which dropped the
+ * tools whose probes throw (fetch_open_orders, cancel_all_orders) and left the
+ * bridge retrying discovery every 30s forever (observed live on the HL rig,
+ * 2026-07-24).
+ *
+ * Destructive-capable tools (cancel_all_orders, close_position) probe with the
+ * PROBE_SENTINEL_SYMBOL so they can never execute against real state.
  */
-const PROBE_ARGS = {
-    fetch_ticker: { symbol: 'BTC/USDT' },
-    fetch_balance: {},
-    fetch_ohlcv: { symbol: 'BTC/USDT', timeframe: '1h', limit: 1 },
-    fetch_positions: { symbol: 'BTC/USDT' },
-    fetch_open_orders: { symbol: 'BTC/USDT' },
-    // For write tools: probe with minimal args. We expect 400 (bad args) = tool exists.
-    cancel_all_orders: { symbol: 'BTC/USDT' },
-    cancel_order: { id: 'probe-0', symbol: 'BTC/USDT' },
-    close_position: { symbol: 'BTC/USDT' },
-    create_order: { symbol: 'BTC/USDT', type: 'limit', side: 'buy', amount: 0, price: 0 },
-    get_market_structure: { symbol: 'BTC/USDT' },
-    get_crypto_metrics: { symbol: 'BTC/USDT' },
-    get_market_intel: { category: 'sentiment' },
-    // Safe probe args — plugin tools early-return on invalid input without
-    // touching disk. `mode: '__probe__'` fails the VALID_MODES check; empty
-    // strings fail the length-8 validator in set_exchange_credentials. Both
-    // return HTTP 200 with ok:false, which the probe treats as "tool exists".
-    set_trading_mode: { mode: '__probe__' },
-    set_exchange_credentials: { apiKey: '', secret: '' },
-    // test_exchange_credentials: empty strings fail the length check and
-    // early-return without hitting Binance.
-    test_exchange_credentials: { apiKey: '', secret: '' },
-    // clear_exchange_credentials: tool requires confirm:true. Probing without
-    // it triggers the safety gate early-return — tool exists, nothing wiped.
-    clear_exchange_credentials: {},
-    // Bracket-config probes: no-arg read; set with an invalid flag triggers early-return.
-    get_bracket_config: {},
-    set_bracket_requirement: { flag: '__probe__', value: false },
-};
+export function buildProbeArgs(symbol = DEFAULT_PROBE_SYMBOL) {
+    return {
+        fetch_ticker: { symbol },
+        fetch_balance: {},
+        fetch_ohlcv: { symbol, timeframe: '1h', limit: 1 },
+        fetch_positions: { symbol },
+        fetch_open_orders: { symbol },
+        // ★ NEVER a real symbol: a cancel-all probe with a real symbol is a real
+        // cancel-all. The sentinel fails symbol resolution before any order is
+        // touched; the resulting envelope error still counts as "tool exists".
+        cancel_all_orders: { symbol: PROBE_SENTINEL_SYMBOL },
+        // cancel_order: nonexistent id — order-not-found error, nothing cancelled.
+        cancel_order: { id: 'probe-0', symbol },
+        // ★ Sentinel for the same reason: close_position with a real symbol and an
+        // open position could market-close it (the close-discipline validator is a
+        // live-mode reason gate, not a guarantee on every mode/venue/version).
+        close_position: { symbol: PROBE_SENTINEL_SYMBOL },
+        // amount 0 is rejected by order validation before reaching any exchange.
+        create_order: { symbol, type: 'limit', side: 'buy', amount: 0, price: 0 },
+        get_market_structure: { symbol },
+        get_crypto_metrics: { symbol },
+        get_market_intel: { category: 'sentiment' },
+        // Safe probe args — plugin tools early-return on invalid input without
+        // touching disk. `mode: '__probe__'` fails the VALID_MODES check; empty
+        // strings fail the length-8 validator in set_exchange_credentials. Both
+        // return HTTP 200 with ok:false, which the probe treats as "tool exists".
+        set_trading_mode: { mode: '__probe__' },
+        set_exchange_credentials: { apiKey: '', secret: '' },
+        // test_exchange_credentials: empty strings fail the length check and
+        // early-return without hitting Binance.
+        test_exchange_credentials: { apiKey: '', secret: '' },
+        // clear_exchange_credentials: tool requires confirm:true. Probing without
+        // it triggers the safety gate early-return — tool exists, nothing wiped.
+        clear_exchange_credentials: {},
+        // Bracket-config probes: no-arg read; set with an invalid flag triggers early-return.
+        get_bracket_config: {},
+        set_bracket_requirement: { flag: '__probe__', value: false },
+    };
+}
 // ---- Discovery logic ----
+/** Envelope-level error messages that mean "the gateway does not have this
+ *  tool" (as opposed to "the tool executed and failed"). Matched against the
+ *  error message + body of a 200-status GatewayHttpError.
+ *
+ *  The name-not-found pattern requires a QUOTED tool name ("tool 'x' not
+ *  found") — a bare `tool .* not found` would false-positive on legitimate
+ *  execution errors like cancel_order's "Tool invoke failed: Order probe-0
+ *  not found" (the probe's EXPECTED failure) and drop the tool. */
+const UNKNOWN_TOOL_RE = /unknown tool|tool ['"][^'"]*['"] (?:not found|does not exist)|no such tool|is not registered|tool_not_found|unavailable tool|not in allowlist/i;
+/** True when an envelope-level (HTTP 200, ok:false) error denotes an unknown
+ *  tool name rather than a tool that executed and failed. Exported for tests. */
+export function isUnknownToolEnvelopeError(err) {
+    const haystack = `${err.message} ${JSON.stringify(err.body ?? '')}`;
+    return UNKNOWN_TOOL_RE.test(haystack);
+}
 /**
  * Probe a single candidate tool name. Returns true if the tool exists.
  *
+ * ★ "Exists" means the invocation REACHED the tool — not that it succeeded.
+ * A tool that executed and threw (venue mismatch, transient rate limit, a
+ * refused destructive call) absolutely exists; dropping it from the toolMap
+ * was the 2026-07-24 HL-rig bug (fetch_open_orders/cancel_all_orders throw on
+ * a probe error → "missing" forever → 30s discovery-retry loop + emergency
+ * controls degraded).
+ *
  * Strategy:
- * - 200: tool exists and invocation succeeded
- * - 400: tool exists but args were bad (still counts as found)
+ * - 200 parsed OK: exists and works
+ * - 400: exists, bad args
+ * - 200 + envelope ok:false: the tool EXECUTED and failed → exists — unless
+ *   the envelope error says the tool name itself is unknown (gateways that
+ *   report unknown tools in-envelope instead of via 404)
+ * - >=500: the tool executed and threw server-side → exists
  * - 404: tool does not exist
  * - 401: auth error — rethrow (don't mask)
- * - Other: treat as not found
+ * - network error / timeout (status 0): unknown — treat as not found, the
+ *   discovery retry loop will re-probe
  */
 async function probeCandidate(http, candidateName, args) {
     try {
@@ -108,6 +164,15 @@ async function probeCandidate(http, candidateName, args) {
                 return false; // Tool not found
             if (err.status === 401)
                 throw err; // Auth error — fatal
+            if (err.status === 200) {
+                // Envelope-level failure: the HTTP layer accepted the call. Either the
+                // tool executed and failed (exists) or the gateway rejected an unknown
+                // tool name in-envelope (not found). Candidate order protects the
+                // ambiguous case: the real plugin name is probed before any alias.
+                return !isUnknownToolEnvelopeError(err);
+            }
+            if (err.status >= 500)
+                return true; // Tool executed and threw
         }
         return false;
     }
@@ -116,9 +181,9 @@ async function probeCandidate(http, candidateName, args) {
  * Discover the actual tool name for a logical tool by probing candidates in order.
  * Returns the first candidate that exists, or null if none found.
  */
-async function discoverTool(http, logical) {
+async function discoverTool(http, logical, probeArgs) {
     const candidates = CANDIDATES[logical];
-    const args = PROBE_ARGS[logical];
+    const args = probeArgs[logical];
     for (const candidate of candidates) {
         logger.debug(TAG, `Probing ${candidate} for ${logical}...`);
         const exists = await probeCandidate(http, candidate, args);
@@ -135,15 +200,16 @@ async function discoverTool(http, logical) {
  * Probes required tools first, then optional tools in parallel.
  * Fails fast if no required tools are found.
  */
-export async function discoverTools(http) {
+export async function discoverTools(http, opts) {
     logger.info(TAG, 'Starting tool auto-discovery...');
+    const probeArgs = buildProbeArgs(opts?.symbol);
     const toolMap = {};
     const found = [];
     const missingRequired = [];
     const missingOptional = [];
     // Discover required tools first (sequentially to fail fast on auth errors)
     for (const logical of REQUIRED_TOOLS) {
-        const actual = await discoverTool(http, logical);
+        const actual = await discoverTool(http, logical, probeArgs);
         if (actual) {
             toolMap[logical] = actual;
             found.push(logical);
@@ -167,7 +233,7 @@ export async function discoverTools(http) {
     }
     // Discover optional tools in parallel
     const optionalResults = await Promise.allSettled(OPTIONAL_TOOLS.map(async (logical) => {
-        const actual = await discoverTool(http, logical);
+        const actual = await discoverTool(http, logical, probeArgs);
         return { logical, actual };
     }));
     for (const result of optionalResults) {

package/bridge/providers/gateway.d.ts

@@ -14,6 +14,17 @@ export declare function shouldAnchorSessionNav(args: {
     today: string;
     mode: TradingMode;
 }): boolean;
+/** Decide whether to adopt the plugin-provided sessionStartNav from a balance
+ *  response. Pure so it can be unit-tested without the full provider.
+ *
+ *  ★ Deliberately MODE-INDEPENDENT: the plugin's anchor is authoritative in
+ *  every mode — live/shadow anchor to the exchange income/day-anchor, and
+ *  PAPER's simulator seeds + midnight-rolls its own anchor in state.json (the
+ *  same value its pre-trade risk gate reads). The pre-2026-07-24 non-PAPER
+ *  gate left paper with a SECOND, skill-computed anchor; on a customer box the
+ *  two diverged (13942 vs 10024) and the skill auto-flattened a FLAT account
+ *  at a phantom −27.81% drawdown while the plugin's own view was GREEN. */
+export declare function shouldSyncPluginSessionNav(pluginNav: unknown, currentNav: number): pluginNav is number;
 export declare class GatewayProvider implements OpenClawProvider {
     private readonly config;
     private http;

package/bridge/providers/gateway.js

@@ -9,7 +9,7 @@ import { isTradingMode } from '../types.js';
 import { GatewayHttpClient } from '../gateway/gateway-http-client.js';
 import { GatewayWsClient } from '../gateway/gateway-ws-client.js';
 import { discoverTools } from '../gateway/tool-discovery.js';
-import { EventParser, mapCcxtBalance, mapCcxtOrder, extractLiquidationFields, extractBracketField, } from '../gateway/event-parser.js';
+import { EventParser, mapCcxtBalance, mapCcxtOrder, extractLiquidationFields, extractBracketField, extractPlannedLevels, } from '../gateway/event-parser.js';
 import { Poller } from '../gateway/poller.js';
 import { ensureHeartbeatCron } from '../gateway/heartbeat-cron.js';
 import { computeEquity as _computeEquity, computePositionNotional as _computePositionNotional, computeRiskMetrics as _computeRiskMetrics, DEFAULT_RISK_LIMITS, } from './risk-calculator.js';
@@ -49,6 +49,21 @@ export function shouldAnchorSessionNav(args) {
         return true; // never anchored
     return args.mode === 'PAPER' && args.sessionDate !== args.today; // paper midnight rollover
 }
+/** Decide whether to adopt the plugin-provided sessionStartNav from a balance
+ *  response. Pure so it can be unit-tested without the full provider.
+ *
+ *  ★ Deliberately MODE-INDEPENDENT: the plugin's anchor is authoritative in
+ *  every mode — live/shadow anchor to the exchange income/day-anchor, and
+ *  PAPER's simulator seeds + midnight-rolls its own anchor in state.json (the
+ *  same value its pre-trade risk gate reads). The pre-2026-07-24 non-PAPER
+ *  gate left paper with a SECOND, skill-computed anchor; on a customer box the
+ *  two diverged (13942 vs 10024) and the skill auto-flattened a FLAT account
+ *  at a phantom −27.81% drawdown while the plugin's own view was GREEN. */
+export function shouldSyncPluginSessionNav(pluginNav, currentNav) {
+    return typeof pluginNav === 'number'
+        && pluginNav > 0
+        && Math.abs(currentNav - pluginNav) > 0.001;
+}
 function loadSessionStartNav() {
     for (const path of [getDayNavPath(), getLegacyDayNavPath()]) {
         try {
@@ -751,6 +766,8 @@ export class GatewayProvider {
                 giveBackRatio: typeof pos.giveBackRatio === 'number' ? pos.giveBackRatio : undefined,
                 originalStopPrice: typeof pos.originalStopPrice === 'number' ? pos.originalStopPrice : undefined,
                 ...(bracketField !== undefined ? { bracket: bracketField } : {}),
+                // Agent's planned stop/target — the ONLY SL/TP source in paper mode.
+                ...extractPlannedLevels(pos),
                 ...liqFields,
             });
         }
@@ -831,8 +848,11 @@ export class GatewayProvider {
         else {
             logger.warn(TAG, 'No device token from WS handshake — REST calls may fail (using raw gateway token)');
         }
-        // Step 4: Discover available tools (async — check for stop() after)
-        const discovery = await discoverTools(this.http);
+        // Step 4: Discover available tools (async — check for stop() after).
+        // Pass the configured symbol so probes are venue-correct — a hardcoded
+        // BTC/USDT probe throws on a Hyperliquid-venue plugin and silently drops
+        // the tools whose probes throw (2026-07-24 HL-rig bug).
+        const discovery = await discoverTools(this.http, { symbol: this.config.symbol });
         if (!this.started) {
             logger.info(TAG, 'Stopped during tool discovery — aborting initialization');
             this.http = null;
@@ -975,7 +995,7 @@ export class GatewayProvider {
             try {
                 // Capture http ref before await — stop() can nullify it
                 const http = this.http;
-                const discovery = await discoverTools(http);
+                const discovery = await discoverTools(http, { symbol: this.config.symbol });
                 // Guard: stop() may have been called during async discovery
                 if (!this.started || !this.http)
                     return;
@@ -1653,23 +1673,32 @@ export class GatewayProvider {
             if (typeof result.data.equity === 'number') {
                 this.equity = result.data.equity;
             }
-            // In non-PAPER modes, the plugin anchors sessionStartNav to Binance's
-            // /fapi/v1/income at UTC midnight on every balance fetch — that's the
-            // authoritative truth. Sync continuously, not just on first set: the
-            // pre-2026-05-14 guard `this.sessionStartNav < 0` meant once the skill
-            // had ANY value (from file load or computeEquity), the plugin's correct
-            // value was ignored forever. The skill's self-computed value drifts
-            // whenever trading has already happened before the skill first polls
-            // (operator screenshot 2026-05-14 found a $3.92 dashboard-vs-Binance
-            // gap from a $1095.95 self-computed seed vs the plugin's $1099.86
-            // midnight-anchored truth). Crossing UTC midnight is also handled
-            // automatically — plugin's anchor refreshes, skill syncs next poll.
-            if (this.tradingMode !== 'PAPER') {
+            // The plugin's sessionStartNav is the authoritative day anchor in EVERY
+            // mode, so sync continuously whenever it provides one:
+            //  - live/shadow: anchored to Binance's /fapi/v1/income at UTC midnight
+            //    (or the HL day-anchor reconstruction) — the 2026-05-14 lesson: the
+            //    skill's self-computed value drifts whenever trading happened before
+            //    the skill first polled ($1095.95 self-seed vs the plugin's $1099.86
+            //    income-anchored truth = a $3.92 dashboard-vs-Binance gap).
+            //  - PAPER: the simulator seeds + midnight-rolls its own anchor in
+            //    state.json and its pre-trade risk gate reads THAT value. The skill
+            //    previously kept a SECOND, self-computed paper anchor here — two
+            //    anchors for one number. On a customer box (2026-07-24) the skill's
+            //    boot-seeded 13942 diverged from the plugin's 10024 and the skill's
+            //    RED-zone math auto-flattened a FLAT account at a phantom −27.81%
+            //    while the plugin's own view was GREEN. One anchor, one truth.
+            // Crossing UTC midnight is handled automatically — the plugin's anchor
+            // refreshes, the skill syncs next poll. The skill's self-seed
+            // (trySetSessionStartNav) remains only as a fallback for plugins too old
+            // to emit sessionStartNav.
+            {
                 const pluginNav = result.data.sessionStartNav;
-                if (typeof pluginNav === 'number' && pluginNav > 0
-                    && Math.abs(this.sessionStartNav - pluginNav) > 0.001) {
+                if (shouldSyncPluginSessionNav(pluginNav, this.sessionStartNav)) {
                     const prev = this.sessionStartNav;
                     this.sessionStartNav = pluginNav;
+                    // Stamp the day so the PAPER self-seed path (shouldAnchorSessionNav
+                    // re-anchors on a stale sessionDate) doesn't flap against the sync.
+                    this.sessionDate = todayDateStr();
                     saveSessionStartNav(pluginNav);
                     logger.info(TAG, `Session start NAV synced from plugin: ${prev.toFixed(4)} -> ${pluginNav} (${this.tradingMode} mode)`);
                 }
@@ -2036,6 +2065,8 @@ export class GatewayProvider {
                 giveBackRatio: typeof p.giveBackRatio === 'number' ? p.giveBackRatio : undefined,
                 originalStopPrice: typeof p.originalStopPrice === 'number' ? p.originalStopPrice : undefined,
                 ...(bracketField !== undefined ? { bracket: bracketField } : {}),
+                // Agent's planned stop/target — the ONLY SL/TP source in paper mode.
+                ...extractPlannedLevels(p),
                 ...liqFields,
             };
         });

package/bridge/types.d.ts

@@ -186,6 +186,8 @@ export interface RiskUpdatePayload {
             tpPrice?: number;
             state: string;
         };
+        plannedStopPrice?: number;
+        plannedTargetPrice?: number;
     }>;
     balance?: {
         total: number;
@@ -239,6 +241,8 @@ export interface ReconciliationSnapshot {
             tpPrice?: number;
             state: string;
         };
+        plannedStopPrice?: number;
+        plannedTargetPrice?: number;
     }>;
     balance: {
         currency: string;

package/index.js

@@ -22,6 +22,7 @@ import { DEFAULT_CONFIG } from './types.js';
 import { PaperAdapter } from './paper-adapter.js';
 import { LiveAdapter, } from './live/live-adapter.js';
 import { createLiveAdapter, fillExchangeId, isLiveVenueSupported, parseVenue, venueQuoteCurrency, } from './venues/registry.js';
+import { resolvePluginSymbol } from './venues/symbols.js';
 import { HyperliquidPublicApi } from './venues/hyperliquid/hl-public.js';
 import { bracketsEnabled, loadBracketMode } from './config/brackets-config.js';
 import { loadUserDataStreamMode, loadUserDataStreamTunables, loadUserDataStreamDbWrite, getUserDataStreamIngestBaseUrl, resolveIngestToken, resolveReefclawUserId, } from './config/user-data-stream-config.js';
@@ -909,15 +910,22 @@ const paperTradingPlugin = {
         // rules, and an unreadable config falls back to the binance default
         // exactly like the main read does.
         let paperQuoteCurrency = DEFAULT_CONFIG.quoteCurrency;
+        let peekedVenue = 'binance';
         try {
-            paperQuoteCurrency = venueQuoteCurrency(parseVenue(readPluginConfig().exchange?.venue).venue);
+            peekedVenue = parseVenue(readPluginConfig().exchange?.venue).venue;
+            paperQuoteCurrency = venueQuoteCurrency(peekedVenue);
         }
         catch {
             /* unreadable plugin-config → binance default, matching the main read */
         }
         const pluginConfig = {
             startingBalance: DEFAULT_CONFIG.startingBalance,
-            symbol: DEFAULT_CONFIG.symbol,
+            // Symbol resolution (2026-07-24): honor the openclaw.json entry config
+            // (api.config.symbol — declared in configSchema but previously IGNORED),
+            // falling back to the VENUE's default (BTC/USDC on hyperliquid). The old
+            // venue-blind DEFAULT_CONFIG.symbol hardcode gave every in-plugin
+            // consumer on a hyperliquid box a symbol its own venue rejects.
+            symbol: resolvePluginSymbol(api.config?.symbol, peekedVenue),
             quoteCurrency: paperQuoteCurrency,
         };
         logger.info(TAG, `Config: ${pluginConfig.startingBalance} ${pluginConfig.quoteCurrency}, symbol: ${pluginConfig.symbol}`);

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "reefclaw-paper-trading",
   "name": "ReefClaw Trading",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "Supervised trading plugin for the ReefClaw dashboard: paper trading with real market data (no API keys required), and optional live trading on Binance or Hyperliquid behind explicit operator opt-in, exchange API credentials, and always-on protective stop brackets. Includes the dashboard connector bridge, heartbeat automation, and remote SKILL.md instruction updates from the ReefClaw webapp.",
   "author": "ReefClaw",
   "activation": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reefclaw/openclaw-plugin",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "ReefClaw supervised trading plugin for OpenClaw \u2014 paper trading with real market data, optional live trading on Binance or Hyperliquid (operator opt-in, API keys, always-on protective brackets), plus the ReefClaw dashboard connector with heartbeat automation and remote SKILL.md updates from the ReefClaw webapp. Install: /plugins install clawhub:@reefclaw/openclaw-plugin",
   "type": "module",
   "main": "index.js",

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

@@ -79,6 +79,14 @@ export declare class HyperliquidLiveAdapter extends EventEmitter implements IExc
      */
     closePosition(symbol: string, _closeReason?: CloseReason): Promise<CcxtOrder>;
     getBalance(): Promise<CcxtBalance>;
+    /** The live SL/TP trigger prices for `symbol`, or undefined when no
+     *  non-terminal ledger row exists. Mirrors LiveAdapter's Binance-side
+     *  `lookupBracket` so the dashboard's protective-level surfaces read the same
+     *  shape on both venues. Reads `_coordinator` directly rather than through
+     *  the lazy getter — merely displaying positions must not construct the
+     *  coordinator (which writes a ledger file); with no coordinator there are
+     *  no brackets to report anyway. */
+    private lookupBracket;
     /** Display contract (`?? []`) — the 20+ KPI/display callers. */
     getPositions(symbol?: string): Promise<CcxtPosition[]>;
     /** ★ Decision contract — null means UNKNOWN, and destructive paths must not act. */

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

@@ -120,6 +120,11 @@ export class HyperliquidLiveAdapter extends EventEmitter {
         // Prime the ADDRESS action budget (the starvation guard, §5.6).
         await this.api.refreshAddressBudget();
         // ---- Bracket wiring (issue #209) ----
+        // Build the coordinator here, not on first bracket action: getPositions
+        // reads its ledger to surface live SL/TP, and until the first truth-check
+        // fired (60s) a fresh boot would otherwise show every open position as
+        // unprotected on the dashboard. Construction is idempotent + cheap.
+        this.getHlBracketCoordinator();
         // Fast path: the user stream (fills drive attach for resting limits;
         // orderUpdates is the authoritative leg-lifecycle signal — the HL analog
         // of Binance's ALGO_UPDATE). Truth path: T-5 proved the WS replays
@@ -497,9 +502,29 @@ export class HyperliquidLiveAdapter extends EventEmitter {
         enriched.equity = round4(nav.equity);
         return enriched;
     }
+    /** The live SL/TP trigger prices for `symbol`, or undefined when no
+     *  non-terminal ledger row exists. Mirrors LiveAdapter's Binance-side
+     *  `lookupBracket` so the dashboard's protective-level surfaces read the same
+     *  shape on both venues. Reads `_coordinator` directly rather than through
+     *  the lazy getter — merely displaying positions must not construct the
+     *  coordinator (which writes a ledger file); with no coordinator there are
+     *  no brackets to report anyway. */
+    lookupBracket(symbol) {
+        const row = this._coordinator?.getLedger().getBySymbol(symbol);
+        if (!row)
+            return undefined;
+        if (row.state !== 'active' && row.state !== 'partial' && row.state !== 'attaching') {
+            return undefined;
+        }
+        return { slPrice: row.stopPrice, tpPrice: row.targetPrice, state: row.state };
+    }
     /** Display contract (`?? []`) — the 20+ KPI/display callers. */
     async getPositions(symbol) {
-        return (await this.api.fetchPositions(symbol)) ?? [];
+        const positions = (await this.api.fetchPositions(symbol)) ?? [];
+        // HL live keeps no per-symbol metadata map, so the bracket ledger is the
+        // ONLY protective-level source here — without this the dashboard drew
+        // neither a stop nor a target for an HL live position.
+        return positions.map((p) => ({ ...p, bracket: this.lookupBracket(p.symbol) }));
     }
     /** ★ Decision contract — null means UNKNOWN, and destructive paths must not act. */
     async getPositionsOrNull(symbol) {

package/venues/symbols.d.ts

@@ -20,6 +20,18 @@ export declare function fillExchangeId(venue: VenueId): string;
 export declare const VENUE_QUOTE_ASSET: Record<VenueId, string>;
 /** Prefix that namespaces Hyperliquid rows inside the intel symbol column. */
 export declare const HL_INTEL_PREFIX = "HL_";
+/** Default canonical trading symbol per venue — BTC quoted in the venue's
+ *  settle asset. A venue-blind 'BTC/USDT' default on a hyperliquid box is a
+ *  guaranteed venue-rejection everywhere it's consumed (same class as the
+ *  issue-#174 hardcoded-USDT wallet that read as $0 equity on the USDC venue). */
+export declare const VENUE_DEFAULT_SYMBOL: Record<VenueId, string>;
+/** Resolve the plugin's configured trading symbol: an explicit entry-config
+ *  value wins (openclaw.json plugins.entries.<id>.config.symbol, passed to
+ *  register() via api.config); otherwise the VENUE's default. Never a
+ *  venue-blind hardcode — before 2026-07-24 register() ignored the entry
+ *  config entirely and always used 'BTC/USDT', so every in-plugin consumer on
+ *  a hyperliquid-venue box carried a symbol its own venue rejects. */
+export declare function resolvePluginSymbol(entrySymbol: unknown, venue: VenueId): string;
 /** Canonical symbol → the venue's CCXT unified symbol.
  *  'BTC/USDT' (binance) → 'BTC/USDT:USDT'; 'BTC/USDC' (hyperliquid) →
  *  'BTC/USDC:USDC'. Accepts an already-suffixed input (idempotent). */

package/venues/symbols.js

@@ -39,6 +39,26 @@ export const VENUE_QUOTE_ASSET = {
 };
 /** Prefix that namespaces Hyperliquid rows inside the intel symbol column. */
 export const HL_INTEL_PREFIX = 'HL_';
+/** Default canonical trading symbol per venue — BTC quoted in the venue's
+ *  settle asset. A venue-blind 'BTC/USDT' default on a hyperliquid box is a
+ *  guaranteed venue-rejection everywhere it's consumed (same class as the
+ *  issue-#174 hardcoded-USDT wallet that read as $0 equity on the USDC venue). */
+export const VENUE_DEFAULT_SYMBOL = {
+    binance: 'BTC/USDT',
+    hyperliquid: 'BTC/USDC',
+};
+/** Resolve the plugin's configured trading symbol: an explicit entry-config
+ *  value wins (openclaw.json plugins.entries.<id>.config.symbol, passed to
+ *  register() via api.config); otherwise the VENUE's default. Never a
+ *  venue-blind hardcode — before 2026-07-24 register() ignored the entry
+ *  config entirely and always used 'BTC/USDT', so every in-plugin consumer on
+ *  a hyperliquid-venue box carried a symbol its own venue rejects. */
+export function resolvePluginSymbol(entrySymbol, venue) {
+    if (typeof entrySymbol === 'string' && entrySymbol.trim().length > 0) {
+        return stripSettleSuffix(entrySymbol.trim());
+    }
+    return VENUE_DEFAULT_SYMBOL[venue];
+}
 /** Strip a CCXT settle suffix ('BTC/USDT:USDT' → 'BTC/USDT'). Same regex as
  *  webapp/src/lib/symbols.ts normalizeSymbol — kept inline so this module has
  *  zero imports and survives the sync-copy deploy boundary. */