@reefclaw/openclaw-plugin 0.1.5 → 0.1.7

package/tools/intel-api.d.ts

@@ -1,7 +1,27 @@
+import { type VenueId } from '../venues/symbols.js';
 export interface IntelApiDeps {
     connectionToken: string;
     intelligenceUrl: string;
+    /** Trading venue of this box (HYPERLIQUID_INTEGRATION_PLAN §5.3). Absent =
+     *  binance, so every pre-venue caller is byte-identical. */
+    venue?: VenueId;
 }
+/** Agent-facing symbol → the intel DB symbol for this deps' venue.
+ *  binance/absent: 'BTC/USDT' → 'BTCUSDT'; slashless input passes through
+ *  verbatim (today's working raw inputs stay byte-identical).
+ *  hyperliquid: 'BTC/USDC' → 'HL_BTC' (case preserved — 'kPEPE' is real,
+ *  'KPEPE' is not); 'HL_X' passes through; concatenated 'BTCUSDC' → 'HL_BTC'. */
+export declare function resolveIntelSymbol(deps: IntelApiDeps, symbol: string): string;
+/** Intel DB symbol → the symbol the agent should see and trade.
+ *  binance: verbatim ('BTCUSDT' stays 'BTCUSDT' — the historical shape the
+ *  agent already translates). hyperliquid: 'HL_BTC' → 'BTC/USDC'. */
+export declare function presentIntelSymbol(deps: IntelApiDeps, intelSymbol: string): string;
+/** Does this intel symbol belong to this deps' venue? Venue-scopes the scan
+ *  universe: an HL box must never rank Binance USDT candidates it cannot
+ *  trade (2026-07-13 wisekid: every setup died at the order-path price
+ *  fetch), and a Binance box must never rank HL_ rows once intel serves
+ *  them (INTEL_HL_FACTS). */
+export declare function intelSymbolOnVenue(deps: IntelApiDeps, intelSymbol: string): boolean;
 export interface FetchOptions {
     method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
     body?: unknown;

package/tools/intel-api.js

@@ -1,5 +1,72 @@
 // Shared helper for Intelligence API calls.
 // All intelligence tools use Bearer token auth against intel.reefclaw.com.
+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
+//     boundary). All three FAIL OPEN — unmappable input passes through
+//     verbatim so intel answers "no data for <echo>", which is honest and
+//     debuggable; never throw here. ─────────────────────────────────────────
+/** Strip a ccxt settle suffix ('BTC/USDC:USDC' → 'BTC/USDC'). */
+function stripSettle(s) {
+    return s.replace(/:[A-Za-z]+$/, '');
+}
+/** Agent-facing symbol → the intel DB symbol for this deps' venue.
+ *  binance/absent: 'BTC/USDT' → 'BTCUSDT'; slashless input passes through
+ *  verbatim (today's working raw inputs stay byte-identical).
+ *  hyperliquid: 'BTC/USDC' → 'HL_BTC' (case preserved — 'kPEPE' is real,
+ *  'KPEPE' is not); 'HL_X' passes through; concatenated 'BTCUSDC' → 'HL_BTC'. */
+export function resolveIntelSymbol(deps, symbol) {
+    const venue = deps.venue ?? 'binance';
+    const s = stripSettle(String(symbol ?? '').trim());
+    if (venue === 'hyperliquid') {
+        if (s.startsWith(HL_INTEL_PREFIX))
+            return s;
+        if (s.includes('/')) {
+            try {
+                return toIntelSymbol('hyperliquid', s);
+            }
+            catch {
+                return s;
+            }
+        }
+        if (s.length > 4 && s.endsWith('USDC'))
+            return `${HL_INTEL_PREFIX}${s.slice(0, -4)}`;
+        return s;
+    }
+    if (s.includes('/')) {
+        try {
+            return toIntelSymbol('binance', s);
+        }
+        catch {
+            return s;
+        }
+    }
+    return s;
+}
+/** Intel DB symbol → the symbol the agent should see and trade.
+ *  binance: verbatim ('BTCUSDT' stays 'BTCUSDT' — the historical shape the
+ *  agent already translates). hyperliquid: 'HL_BTC' → 'BTC/USDC'. */
+export function presentIntelSymbol(deps, intelSymbol) {
+    if ((deps.venue ?? 'binance') !== 'hyperliquid')
+        return intelSymbol;
+    if (!intelSymbol.startsWith(HL_INTEL_PREFIX))
+        return intelSymbol;
+    try {
+        return fromIntelSymbol(intelSymbol).canonical;
+    }
+    catch {
+        return intelSymbol;
+    }
+}
+/** Does this intel symbol belong to this deps' venue? Venue-scopes the scan
+ *  universe: an HL box must never rank Binance USDT candidates it cannot
+ *  trade (2026-07-13 wisekid: every setup died at the order-path price
+ *  fetch), and a Binance box must never rank HL_ rows once intel serves
+ *  them (INTEL_HL_FACTS). */
+export function intelSymbolOnVenue(deps, intelSymbol) {
+    const isHl = intelSymbol.startsWith(HL_INTEL_PREFIX);
+    return (deps.venue ?? 'binance') === 'hyperliquid' ? isHl : !isHl;
+}
 /** Encode a value for safe use in a URL path segment */
 export const enc = encodeURIComponent;
 export async function fetchIntelApi(path, deps, options) {

package/tools/intel-cache.d.ts

@@ -1,5 +1,5 @@
 import type { IntelApiDeps } from './intel-api.js';
-import type { SymbolFact, StrategyConfig, StrategyRow } from '../strategy/evaluator.js';
+import { type SymbolFact, type StrategyConfig, type StrategyRow } from '../strategy/evaluator.js';
 export declare function getAllFactsCached(deps: IntelApiDeps): Promise<SymbolFact[] | {
     error: string;
 }>;

package/tools/intel-cache.js

@@ -18,7 +18,8 @@
 //                                            per-symbol cache
 //   getStrategiesCached(deps)             — strategies cache
 //   __testing__.resetCaches()             — clears all caches between tests
-import { fetchIntelApi, enc } from './intel-api.js';
+import { fetchIntelApi, enc, resolveIntelSymbol } from './intel-api.js';
+import { isDeclarativeStrategyConfig, } from '../strategy/evaluator.js';
 // facts refresh every 5 min server-side; 30s client cache is safe
 const FACTS_TTL_MS = 30_000;
 // strategies are slow-changing user state
@@ -40,7 +41,14 @@ export async function getAllFactsCached(deps) {
     const now = Date.now();
     if (allFactsCache && now < allFactsCache.expiry)
         return allFactsCache.value;
-    const resp = await fetchIntelApi('/api/facts', deps, { timeoutMs: 30_000 });
+    // HL_ facts are opt-in server-side (?venue=hyperliquid) so venue-blind
+    // plugin builds can never receive them; binance sends the historical bare
+    // path — byte-identical. One process = one venue, so the module-global
+    // cache needs no venue key.
+    const factsPath = (deps.venue ?? 'binance') === 'hyperliquid'
+        ? '/api/facts?venue=hyperliquid'
+        : '/api/facts';
+    const resp = await fetchIntelApi(factsPath, deps, { timeoutMs: 30_000 });
     if (!resp || typeof resp !== 'object') {
         return { error: 'Intelligence /api/facts returned no response.' };
     }
@@ -83,8 +91,14 @@ export async function getFactBySymbolCached(rawSymbol, deps) {
     }
     // 3. Fall back to the single-symbol endpoint (symbol not in default scan
     //    set, or both caches cold). Populate the per-symbol cache so a repeat
-    //    call in the same heartbeat is free.
-    const resp = await fetchIntelApi(`/api/facts/${enc(symbol)}`, deps, { timeoutMs: 30_000 });
+    //    call in the same heartbeat is free. The FETCH form must preserve the
+    //    venue namespace and case ('HL_kPEPE' — the normalized cache key would
+    //    mangle it to 'HLKPEPE'); binance keeps fetching the normalized form
+    //    byte-identically.
+    const fetchSym = (deps.venue ?? 'binance') === 'hyperliquid'
+        ? resolveIntelSymbol(deps, rawSymbol)
+        : symbol;
+    const resp = await fetchIntelApi(`/api/facts/${enc(fetchSym)}`, deps, { timeoutMs: 30_000 });
     if (!resp || typeof resp !== 'object') {
         return { error: `Intelligence /api/facts/${symbol} returned no response.` };
     }
@@ -113,7 +127,8 @@ export async function getStrategyRowsCached(deps) {
     }
     if ('error' in resp)
         return { error: resp.error };
-    const rows = (resp.strategies ?? []);
+    const rows = (resp.strategies ?? [])
+        .filter((row) => row?.config && isDeclarativeStrategyConfig(row.config));
     stratRowCache = { value: rows, expiry: now + STRAT_TTL_MS };
     return rows;
 }

package/tools/list-strategies.d.ts

@@ -1,7 +1,17 @@
 import type { IntelApiDeps } from './intel-api.js';
 export interface ListStrategiesArgs {
-    active_only?: boolean;
+    active_only: boolean;
 }
+/**
+ * Canonicalize model-produced arguments before OpenClaw validates them.
+ *
+ * OpenClaw's production validator coerces a JSON null to boolean false. That
+ * would turn a malformed/omitted active-only request into an all-strategies
+ * request. Only a genuine boolean false therefore opts into inactive rows;
+ * every missing, null, string, array, or otherwise malformed input fails safe
+ * to the active strategies requested by the operator-status workflow.
+ */
+export declare function prepareListStrategiesArgs(raw: unknown): ListStrategiesArgs;
 export declare function listStrategiesTool(args: ListStrategiesArgs, deps: IntelApiDeps): Promise<Record<string, unknown> | {
     error: string;
 }>;

package/tools/list-strategies.js

@@ -1,5 +1,22 @@
 // Tool: list_strategies — list all strategies in the Strategy Box.
 import { fetchIntelApi } from './intel-api.js';
+/**
+ * Canonicalize model-produced arguments before OpenClaw validates them.
+ *
+ * OpenClaw's production validator coerces a JSON null to boolean false. That
+ * would turn a malformed/omitted active-only request into an all-strategies
+ * request. Only a genuine boolean false therefore opts into inactive rows;
+ * every missing, null, string, array, or otherwise malformed input fails safe
+ * to the active strategies requested by the operator-status workflow.
+ */
+export function prepareListStrategiesArgs(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return { active_only: true };
+    }
+    return {
+        active_only: raw.active_only === false ? false : true,
+    };
+}
 export async function listStrategiesTool(args, deps) {
     const query = args.active_only ? '?active=true' : '';
     return fetchIntelApi(`/api/strategies${query}`, deps);

package/tools/modify-stop.d.ts

@@ -1,4 +1,6 @@
 import type { IExchangeAdapter } from '../exchange-adapter.js';
+import type { TradingOperationLock } from '../lifecycle/trading-operation-lock.js';
+import type { Wave9LiveSymbolOwnershipCheck } from '../wave9/live-symbol-ownership.js';
 interface ModifyStopArgs {
     symbol: string;
     new_stop_price: number;
@@ -11,6 +13,8 @@ interface ModifyStopResult {
 }
 export declare function modifyStopTool(args: ModifyStopArgs, deps: {
     adapter: IExchangeAdapter;
+    operationLock?: TradingOperationLock;
+    checkWave9LiveSymbolOwnership?: Wave9LiveSymbolOwnershipCheck;
 }): Promise<ModifyStopResult | {
     error: string;
 }>;

package/tools/modify-stop.js

@@ -5,8 +5,10 @@
 // Paper mode: moves the position's metadata.stopPrice in place (the paper
 // stop-watcher reads it), so BE/trail works without a close+reopen round-trip.
 // Live mode without brackets enabled: error asking operator to enable.
+import { resolveBracketControl } from './bracket-control.js';
 import { validateStopDirection } from '../live/bracket-params.js';
 import { formatError } from '../logger.js';
+import { isWave9ManagedPosition } from '../wave9/paper-admission-guard.js';
 export async function modifyStopTool(args, deps) {
     if (!args.symbol)
         return { error: 'symbol is required.' };
@@ -16,33 +18,67 @@ export async function modifyStopTool(args, deps) {
     if (!deps.adapter.isLive) {
         return modifyStopPaper(deps.adapter, args);
     }
-    const mgr = deps.adapter.getBracketManager?.();
-    const ledger = deps.adapter.getBracketLedger?.();
-    if (!mgr || !ledger) {
-        return { error: 'Bracket orders are not enabled. Set brackets.mode in plugin-config.json to "observe" or "enforce".' };
-    }
-    const entry = ledger.getBySymbol(args.symbol);
-    if (!entry) {
-        return { error: `No active bracket for ${args.symbol}.` };
-    }
-    // Direction check — catch flipped sign before burning a cancel+resubmit cycle
-    const refPrice = entry.stopPrice && entry.targetPrice
-        ? (entry.stopPrice + entry.targetPrice) / 2
-        : await deps.adapter.getLastPrice(args.symbol);
-    if (refPrice != null && refPrice > 0) {
-        const msg = validateStopDirection(entry.entrySide, refPrice, args.new_stop_price);
-        if (msg)
-            return { error: msg };
-    }
-    try {
-        await mgr.modifyStop(args.symbol, args.new_stop_price);
+    if (deps.checkWave9LiveSymbolOwnership && !deps.operationLock) {
         return {
-            ok: true,
-            symbol: args.symbol,
-            old_stop_price: entry.stopPrice ?? null,
-            new_stop_price: args.new_stop_price,
+            error: 'Live modify_stop refused: the shared trading operation lock is required ' +
+                'while Wave 9 LIVE ownership checks are enabled.',
         };
     }
+    const modifyLive = async () => {
+        if (deps.checkWave9LiveSymbolOwnership) {
+            let ownership;
+            try {
+                ownership = await deps.checkWave9LiveSymbolOwnership(args.symbol);
+            }
+            catch (err) {
+                return {
+                    error: `modify_stop refused at mutation boundary: Wave 9 LIVE ownership check failed ` +
+                        `for ${args.symbol} (${formatError(err)}).`,
+                };
+            }
+            if (ownership.status === 'owned' || ownership.status === 'ambiguous') {
+                return {
+                    error: `modify_stop refused at mutation boundary: ${args.symbol} has ` +
+                        `${ownership.status} Wave 9 LIVE ownership (${ownership.reason}). ` +
+                        'Wave 9 uses its frozen initial 3x ATR emergency stop.',
+                };
+            }
+        }
+        const control = resolveBracketControl(deps.adapter);
+        if (!control) {
+            return { error: 'Bracket orders are not enabled. Set brackets.mode in plugin-config.json to "observe" or "enforce".' };
+        }
+        const entry = control.ledger.getBySymbol(args.symbol);
+        if (!entry) {
+            return { error: `No active bracket for ${args.symbol}.` };
+        }
+        // Direction check — catch flipped sign before burning a cancel+resubmit cycle
+        const refPrice = entry.stopPrice && entry.targetPrice
+            ? (entry.stopPrice + entry.targetPrice) / 2
+            : await deps.adapter.getLastPrice(args.symbol);
+        if (refPrice != null && refPrice > 0) {
+            const msg = validateStopDirection(entry.entrySide, refPrice, args.new_stop_price);
+            if (msg)
+                return { error: msg };
+        }
+        try {
+            await control.modifyStop(args.symbol, args.new_stop_price);
+            return {
+                ok: true,
+                symbol: args.symbol,
+                old_stop_price: entry.stopPrice ?? null,
+                new_stop_price: args.new_stop_price,
+            };
+        }
+        catch (err) {
+            return { error: formatError(err) };
+        }
+    };
+    try {
+        return deps.operationLock
+            ? await deps.operationLock.withAccountLock(`generic-modify-stop-final:${args.symbol}`, modifyLive)
+            : await modifyLive();
+    }
     catch (err) {
         return { error: formatError(err) };
     }
@@ -56,6 +92,9 @@ function modifyStopPaper(adapter, args) {
     if (!pos) {
         return { error: `No open position for ${args.symbol}.` };
     }
+    if (isWave9ManagedPosition(pos)) {
+        return { error: 'modify_stop refused: Wave 9 uses its frozen initial 3x ATR emergency stop.' };
+    }
     // Validate against the current mark (permits breakeven / trailing — the stop
     // just has to stay on the losing side of where price is now).
     const refPrice = pos.markPrice;

package/tools/modify-target.d.ts

@@ -1,4 +1,6 @@
 import type { IExchangeAdapter } from '../exchange-adapter.js';
+import type { TradingOperationLock } from '../lifecycle/trading-operation-lock.js';
+import type { Wave9LiveSymbolOwnershipCheck } from '../wave9/live-symbol-ownership.js';
 interface ModifyTargetArgs {
     symbol: string;
     new_target_price: number;
@@ -11,6 +13,8 @@ interface ModifyTargetResult {
 }
 export declare function modifyTargetTool(args: ModifyTargetArgs, deps: {
     adapter: IExchangeAdapter;
+    operationLock?: TradingOperationLock;
+    checkWave9LiveSymbolOwnership?: Wave9LiveSymbolOwnershipCheck;
 }): Promise<ModifyTargetResult | {
     error: string;
 }>;

package/tools/modify-target.js

@@ -1,7 +1,9 @@
 // Tool: modify_target — move the exchange-side take-profit on an open live
 // position. Mirror of modify_stop; see that file for rationale.
+import { resolveBracketControl } from './bracket-control.js';
 import { validateTargetDirection } from '../live/bracket-params.js';
 import { formatError } from '../logger.js';
+import { isWave9ManagedPosition } from '../wave9/paper-admission-guard.js';
 export async function modifyTargetTool(args, deps) {
     if (!args.symbol)
         return { error: 'symbol is required.' };
@@ -11,32 +13,66 @@ export async function modifyTargetTool(args, deps) {
     if (!deps.adapter.isLive) {
         return modifyTargetPaper(deps.adapter, args);
     }
-    const mgr = deps.adapter.getBracketManager?.();
-    const ledger = deps.adapter.getBracketLedger?.();
-    if (!mgr || !ledger) {
-        return { error: 'Bracket orders are not enabled. Set brackets.mode in plugin-config.json to "observe" or "enforce".' };
-    }
-    const entry = ledger.getBySymbol(args.symbol);
-    if (!entry) {
-        return { error: `No active bracket for ${args.symbol}.` };
-    }
-    const refPrice = entry.stopPrice && entry.targetPrice
-        ? (entry.stopPrice + entry.targetPrice) / 2
-        : await deps.adapter.getLastPrice(args.symbol);
-    if (refPrice != null && refPrice > 0) {
-        const msg = validateTargetDirection(entry.entrySide, refPrice, args.new_target_price);
-        if (msg)
-            return { error: msg };
-    }
-    try {
-        await mgr.modifyTarget(args.symbol, args.new_target_price);
+    if (deps.checkWave9LiveSymbolOwnership && !deps.operationLock) {
         return {
-            ok: true,
-            symbol: args.symbol,
-            old_target_price: entry.targetPrice ?? null,
-            new_target_price: args.new_target_price,
+            error: 'Live modify_target refused: the shared trading operation lock is required ' +
+                'while Wave 9 LIVE ownership checks are enabled.',
         };
     }
+    const modifyLive = async () => {
+        if (deps.checkWave9LiveSymbolOwnership) {
+            let ownership;
+            try {
+                ownership = await deps.checkWave9LiveSymbolOwnership(args.symbol);
+            }
+            catch (err) {
+                return {
+                    error: `modify_target refused at mutation boundary: Wave 9 LIVE ownership check failed ` +
+                        `for ${args.symbol} (${formatError(err)}).`,
+                };
+            }
+            if (ownership.status === 'owned' || ownership.status === 'ambiguous') {
+                return {
+                    error: `modify_target refused at mutation boundary: ${args.symbol} has ` +
+                        `${ownership.status} Wave 9 LIVE ownership (${ownership.reason}). ` +
+                        'Wave 9 is targetless and exits only on stop or completed-daily reversal.',
+                };
+            }
+        }
+        const control = resolveBracketControl(deps.adapter);
+        if (!control) {
+            return { error: 'Bracket orders are not enabled. Set brackets.mode in plugin-config.json to "observe" or "enforce".' };
+        }
+        const entry = control.ledger.getBySymbol(args.symbol);
+        if (!entry) {
+            return { error: `No active bracket for ${args.symbol}.` };
+        }
+        const refPrice = entry.stopPrice && entry.targetPrice
+            ? (entry.stopPrice + entry.targetPrice) / 2
+            : await deps.adapter.getLastPrice(args.symbol);
+        if (refPrice != null && refPrice > 0) {
+            const msg = validateTargetDirection(entry.entrySide, refPrice, args.new_target_price);
+            if (msg)
+                return { error: msg };
+        }
+        try {
+            await control.modifyTarget(args.symbol, args.new_target_price);
+            return {
+                ok: true,
+                symbol: args.symbol,
+                old_target_price: entry.targetPrice ?? null,
+                new_target_price: args.new_target_price,
+            };
+        }
+        catch (err) {
+            return { error: formatError(err) };
+        }
+    };
+    try {
+        return deps.operationLock
+            ? await deps.operationLock.withAccountLock(`generic-modify-target-final:${args.symbol}`, modifyLive)
+            : await modifyLive();
+    }
     catch (err) {
         return { error: formatError(err) };
     }
@@ -48,6 +84,9 @@ function modifyTargetPaper(adapter, args) {
     if (!pos) {
         return { error: `No open position for ${args.symbol}.` };
     }
+    if (isWave9ManagedPosition(pos)) {
+        return { error: 'modify_target refused: Wave 9 is targetless and exits only on stop or completed-daily reversal.' };
+    }
     const refPrice = pos.markPrice;
     const entrySide = pos.side === 'long' ? 'buy' : 'sell';
     if (Number.isFinite(refPrice) && refPrice > 0) {

package/tools/scan-pairs.d.ts

@@ -1,4 +1,5 @@
 import type { IntelApiDeps } from './intel-api.js';
+import type { ReentryTracker } from '../portfolio/reentry-tracker.js';
 import type { PositionDecisionsClient } from '../ingest/position-decisions-client.js';
 export interface ScanPairsArgs {
     /** Minimum confluence score (number of conditions met) to include in rankings. */
@@ -9,6 +10,9 @@ export interface ScanPairsArgs {
 export interface ScanPairsDecisionsDeps {
     decisionsClient?: PositionDecisionsClient;
     userId?: string;
+    /** Re-entry tracker (issue #204) — flags setups already traded within the
+     *  current signal bar. Indication only; nothing is filtered out. */
+    reentryTracker?: ReentryTracker;
 }
 export declare function scanPairsTool(args: ScanPairsArgs, deps: IntelApiDeps, decisionsDeps?: ScanPairsDecisionsDeps): Promise<Record<string, unknown> | {
     error: string;

package/tools/scan-pairs.js

@@ -15,6 +15,7 @@
 // apply override conditions if the directive allows. Saves the drill-in
 // round-trip on the ~6 macd_oversold_reversal-style candidates per
 // heartbeat the agent was rejecting post-scorecard pre-fix.
+import { intelSymbolOnVenue, presentIntelSymbol, resolveIntelSymbol } from './intel-api.js';
 import { scanAllPairs } from '../strategy/evaluator.js';
 import { getAllFactsCached, getStrategiesCached, __testing__ as cacheTesting } from './intel-cache.js';
 import { normalizeSetupFamily, resolveTriggerFamilies } from '../learning/setup-family.js';
@@ -132,11 +133,19 @@ export async function scanPairsTool(args, deps, decisionsDeps) {
     const factsRes = await getAllFactsCached(deps);
     if ('error' in factsRes)
         return factsRes;
-    let facts = factsRes;
-    // Optional symbols filter — narrows the scan to a watchlist.
+    // Venue scope: only rank symbols this box can actually trade. Without this
+    // an HL box ranks Binance USDT candidates that die at the order-path price
+    // fetch (2026-07-13 wisekid), and a Binance box would rank HL_ rows once
+    // intel serves them. No-op on binance today (facts carry no HL_ rows yet).
+    let facts = factsRes.filter(f => intelSymbolOnVenue(deps, f.symbol));
+    // Optional symbols filter — narrows the scan to a watchlist. Accepts both
+    // the raw intel form (legacy, case-insensitive) and the agent-facing
+    // canonical form ('BTC/USDC' → HL_BTC), which is what scan output shows on
+    // a non-binance venue.
     if (Array.isArray(args.symbols) && args.symbols.length > 0) {
         const wl = new Set(args.symbols.map(s => s.toUpperCase()));
-        facts = facts.filter(f => wl.has(f.symbol.toUpperCase()));
+        const wlResolved = new Set(args.symbols.map(s => resolveIntelSymbol(deps, s)));
+        facts = facts.filter(f => wl.has(f.symbol.toUpperCase()) || wlResolved.has(f.symbol));
     }
     if (facts.length === 0) {
         return {
@@ -155,9 +164,9 @@ export async function scanPairsTool(args, deps, decisionsDeps) {
             timestamp: new Date().toISOString(),
             pairs_scanned: facts.length,
             setups_found: 0,
-            note: 'No active strategies. Create or activate strategies using save_strategy or toggle_strategy.',
+            note: 'No active strategies — the agent scans every heartbeat but can NEVER enter a trade until one is active. If you have not already done so this session, tell the operator (chat) and offer next steps: list_strategies to see the available templates, toggle_strategy to activate one, or save_strategy to build a custom one.',
             rankings: [],
-            no_setup: facts.map(f => f.symbol),
+            no_setup: facts.map(f => presentIntelSymbol(deps, f.symbol)),
         };
     }
     // 3. Evaluate all strategies against all facts
@@ -173,13 +182,18 @@ export async function scanPairsTool(args, deps, decisionsDeps) {
     const vetoed = [];
     for (const r of results) {
         const matches = entryLearnings.filter(l => learningMatches(l, r.strategy, r.regime));
+        const agentSymbol = presentIntelSymbol(deps, r.symbol);
+        const reentryCaution = decisionsDeps?.reentryTracker?.cautionFor(agentSymbol, r.strategy);
         const out = {
-            symbol: r.symbol,
+            // Agent-facing form: on hyperliquid the agent must see the symbol it
+            // can hand straight to create_order ('BTC/USDC'), never 'HL_BTC'.
+            symbol: agentSymbol,
             score: r.score,
             regime: r.regime,
             strategy: r.strategy,
             conditions: `${r.conditionsMet}/${r.conditionsTotal} met: ${r.conditions.filter(c => c.met).map(c => c.name).join(', ')}`,
             summary: r.summary,
+            ...(reentryCaution ? { reentry_caution: reentryCaution } : {}),
         };
         if (matches.length === 0) {
             rankings.push(out);
@@ -198,8 +212,8 @@ export async function scanPairsTool(args, deps, decisionsDeps) {
     // 6. Build concise response
     const setupSymbols = new Set(results.map(r => r.symbol));
     const noSetup = facts
-        .map(f => f.symbol)
-        .filter(s => !setupSymbols.has(s));
+        .filter(f => !setupSymbols.has(f.symbol))
+        .map(f => presentIntelSymbol(deps, f.symbol));
     return {
         timestamp: new Date().toISOString(),
         pairs_scanned: facts.length,

package/tools/toggle-strategy.js

@@ -1,6 +1,13 @@
 // Tool: toggle_strategy — activate or deactivate a strategy.
 import { fetchIntelApi } from './intel-api.js';
+const WAVE9_OPERATOR_CONTROLLED_BUNDLE = 'wave9_28d_momentum_reversal';
 export async function toggleStrategyTool(args, deps) {
+    if (args.name === WAVE9_OPERATOR_CONTROLLED_BUNDLE) {
+        return {
+            error: 'Wave 9 activation is operator-controlled. Do not change this toggle; ' +
+                'the operator must use the Strategies dashboard.',
+        };
+    }
     return fetchIntelApi(`/api/strategies/${encodeURIComponent(args.name)}/toggle`, deps, {
         method: 'PUT',
         body: { active: args.active },

package/types.d.ts

@@ -69,6 +69,11 @@ export interface CcxtPosition {
     timestamp: number;
     datetime: string;
     setupType?: string;
+    missionId?: string;
+    candidateId?: string;
+    strategy?: 'tsmom_28d_long_flat_reversal_1d' | 'tsmom_28d_short_flat_reversal_1d';
+    accruedFundingUsd?: number;
+    fundingThroughTime?: string;
     thesis?: string;
     stopPrice?: number;
     targetPrice?: number;