@reefclaw/connect 0.1.11 → 0.1.12

package/assets/plugin/tools/helpers.d.ts

@@ -1,26 +0,0 @@
-import type { PublicMarketDataApi } from '../ccxt/public-market-data-api.js';
-import type { ExchangeSimulator } from '../simulator/exchange-simulator.js';
-import type { CcxtTicker } from '../types.js';
-/**
- * Fetch the latest ticker from the configured market-data source (Binance, or
- * intel in paper mode on a geo-blocked host) and update the simulator.
- * Returns the ticker on success, or an error object on failure.
- */
-export declare function fetchCurrentPrice(symbol: string, deps: {
-    binanceApi: PublicMarketDataApi;
-    simulator: ExchangeSimulator;
-}): Promise<CcxtTicker | {
-    error: string;
-}>;
-/**
- * Fetch the latest order book from Binance and cache in simulator.
- * Best-effort: never throws. Skips fetch if cached book is fresh enough.
- */
-export declare function fetchOrderBook(symbol: string, deps: {
-    binanceApi: PublicMarketDataApi;
-    simulator: ExchangeSimulator;
-}): Promise<void>;
-/** Type guard: check if the result is an error object */
-export declare function isError(result: unknown): result is {
-    error: string;
-};

package/assets/plugin/tools/helpers.js

@@ -1,39 +0,0 @@
-// Shared helpers for tool implementations.
-/**
- * Fetch the latest ticker from the configured market-data source (Binance, or
- * intel in paper mode on a geo-blocked host) and update the simulator.
- * Returns the ticker on success, or an error object on failure.
- */
-export async function fetchCurrentPrice(symbol, deps) {
-    const ticker = await deps.binanceApi.fetchTicker(symbol);
-    if (!ticker) {
-        return { error: `Failed to fetch current price for ${symbol}` };
-    }
-    deps.simulator.updateTicker(ticker);
-    return ticker;
-}
-/** Default TTL for cached orderbook: 5 seconds. */
-const ORDERBOOK_TTL_MS = 5_000;
-/**
- * Fetch the latest order book from Binance and cache in simulator.
- * Best-effort: never throws. Skips fetch if cached book is fresh enough.
- */
-export async function fetchOrderBook(symbol, deps) {
-    try {
-        // Skip if cached book is still fresh
-        const cached = deps.simulator.getLastOrderBook(symbol);
-        if (cached && Date.now() - cached.timestamp < ORDERBOOK_TTL_MS)
-            return;
-        const orderbook = await deps.binanceApi.fetchOrderBook(symbol, 20);
-        if (orderbook) {
-            deps.simulator.updateOrderBook(symbol, orderbook);
-        }
-    }
-    catch {
-        // Best-effort: fill engine falls back to random slippage
-    }
-}
-/** Type guard: check if the result is an error object */
-export function isError(result) {
-    return typeof result === 'object' && result !== null && 'error' in result;
-}

package/assets/plugin/tools/intel-api.d.ts

@@ -1,34 +0,0 @@
-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;
-    timeoutMs?: number;
-}
-/** Encode a value for safe use in a URL path segment */
-export declare const enc: typeof encodeURIComponent;
-export declare function fetchIntelApi(path: string, deps: IntelApiDeps, options?: FetchOptions): Promise<Record<string, unknown> | {
-    error: string;
-}>;

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

@@ -1,119 +0,0 @@
-// 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) {
-    const { connectionToken, intelligenceUrl } = deps;
-    if (!connectionToken) {
-        return { error: 'No ReefClaw connection token configured. Intelligence features require a reefclaw.com account.' };
-    }
-    if (!intelligenceUrl) {
-        return { error: 'No intelligence URL configured. Set intelligenceUrl in openclaw.json plugin config.' };
-    }
-    const url = `${intelligenceUrl}${path}`;
-    const headers = { Authorization: `Bearer ${connectionToken}` };
-    const fetchInit = {
-        method: options?.method ?? 'GET',
-        headers,
-        signal: AbortSignal.timeout(options?.timeoutMs ?? 20_000),
-    };
-    if (options?.body !== undefined) {
-        headers['Content-Type'] = 'application/json';
-        fetchInit.body = JSON.stringify(options.body);
-    }
-    try {
-        const res = await fetch(url, fetchInit);
-        if (res.status === 401) {
-            return { error: 'Invalid or expired ReefClaw connection token.' };
-        }
-        if (res.status === 503) {
-            return { error: 'Intelligence service not ready. The regime classifier may still be loading.' };
-        }
-        if (!res.ok) {
-            // Try to extract the server's error message for actionable feedback
-            let detail = `Intelligence API returned ${res.status}`;
-            try {
-                const errBody = (await res.json());
-                if (errBody.error)
-                    detail = errBody.error;
-            }
-            catch { /* ignore parse failures */ }
-            return { error: detail };
-        }
-        return (await res.json());
-    }
-    catch (err) {
-        if (err instanceof Error && err.name === 'TimeoutError') {
-            const timeoutSec = Math.round((options?.timeoutMs ?? 20_000) / 1000);
-            return { error: `Intelligence API request timed out (${timeoutSec}s). Try again later.` };
-        }
-        return { error: `Intelligence API call failed: ${err instanceof Error ? err.message : String(err)}` };
-    }
-}

package/assets/plugin/tools/intel-cache.d.ts

@@ -1,25 +0,0 @@
-import type { IntelApiDeps } from './intel-api.js';
-import { type SymbolFact, type StrategyConfig, type StrategyRow } from '../strategy/evaluator.js';
-export declare function getAllFactsCached(deps: IntelApiDeps): Promise<SymbolFact[] | {
-    error: string;
-}>;
-/** Look up a single symbol's fact, preferring the shared all-facts snapshot.
- *  Falls back to the single-symbol endpoint when the all-facts snapshot is
- *  cold or the symbol is missing from it (e.g., a watchlist symbol not in
- *  the default 20-pair set). */
-export declare function getFactBySymbolCached(rawSymbol: string, deps: IntelApiDeps): Promise<SymbolFact | {
-    error: string;
-}>;
-/** Fetch active strategy rows, caching the full row shape. Both
- *  getStrategiesCached and this share the same rows cache so a warm cache
- *  from either entry point services the other without a second fetch. */
-export declare function getStrategyRowsCached(deps: IntelApiDeps): Promise<StrategyRow[] | {
-    error: string;
-}>;
-/** Backwards-compatible configs-only view, derived from the rows cache. */
-export declare function getStrategiesCached(deps: IntelApiDeps): Promise<StrategyConfig[] | {
-    error: string;
-}>;
-export declare const __testing__: {
-    resetCaches(): void;
-};

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

@@ -1,148 +0,0 @@
-// Shared TTL cache for intelligence facts + strategies.
-//
-// Why this module exists: scan_pairs and get_setup_detail used to maintain
-// independent caches. scan_pairs cached the all-facts endpoint with a 30s
-// TTL; get_setup_detail had no cache and hit the single-symbol endpoint on
-// every call. When the fact-computer recomputed between the two calls,
-// scan_pairs and get_setup_detail saw different facts for the same symbol —
-// regime, chosen strategy, and entry/stop geometry could all diverge. The
-// 2026-05-15 session showed this repeatedly: scan ranks AVAX as TREND_DOWN
-// short, drill-down returns a LONG ladder, agent rejects setup as
-// "directionally inconsistent." Sharing the cache eliminates the divergence.
-//
-// API:
-//   getAllFactsCached(deps)               — populates the all-facts cache
-//   getFactBySymbolCached(symbol, deps)   — reads from all-facts cache when
-//                                            warm; otherwise falls back to
-//                                            single-symbol fetch + populates
-//                                            per-symbol cache
-//   getStrategiesCached(deps)             — strategies cache
-//   __testing__.resetCaches()             — clears all caches between tests
-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
-const STRAT_TTL_MS = 60_000;
-let allFactsCache = null;
-// Single rows cache backs BOTH the configs-only and rows views — keeping them
-// independent caused divergent fetches (scan_pairs warmed configs but
-// get_setup_detail's rows lookup missed and re-fetched, returning undefined
-// on test mocks). One cache, two derived views.
-let stratRowCache = null;
-// per-symbol cache for cases where the all-facts cache hasn't been populated
-// in this heartbeat (e.g., the agent called get_setup_detail directly without
-// running scan_pairs first).
-const symbolFactCache = new Map();
-function normalizeSymbol(raw) {
-    return raw.toUpperCase().replace(/[^A-Z0-9]/g, '');
-}
-export async function getAllFactsCached(deps) {
-    const now = Date.now();
-    if (allFactsCache && now < allFactsCache.expiry)
-        return allFactsCache.value;
-    // 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.' };
-    }
-    if ('error' in resp)
-        return { error: resp.error };
-    const value = (resp.facts ?? []);
-    allFactsCache = { value, expiry: now + FACTS_TTL_MS };
-    // Seed the per-symbol cache so a subsequent getFactBySymbolCached call
-    // for any symbol in this snapshot hits a cache without a round-trip.
-    const seedExpiry = now + FACTS_TTL_MS;
-    for (const f of value) {
-        if (!f.symbol)
-            continue;
-        symbolFactCache.set(normalizeSymbol(f.symbol), { value: f, expiry: seedExpiry });
-    }
-    return value;
-}
-/** Look up a single symbol's fact, preferring the shared all-facts snapshot.
- *  Falls back to the single-symbol endpoint when the all-facts snapshot is
- *  cold or the symbol is missing from it (e.g., a watchlist symbol not in
- *  the default 20-pair set). */
-export async function getFactBySymbolCached(rawSymbol, deps) {
-    const symbol = normalizeSymbol(rawSymbol);
-    const now = Date.now();
-    // 1. Try the per-symbol cache (seeded by getAllFactsCached or by a prior
-    //    single-symbol fetch).
-    const cached = symbolFactCache.get(symbol);
-    if (cached && now < cached.expiry)
-        return cached.value;
-    // 2. If the all-facts cache is warm and contains the symbol, use it. This
-    //    is the path that closes the scan_pairs / get_setup_detail divergence —
-    //    after a heartbeat scan, every drill-down hits the same snapshot the
-    //    scan saw.
-    if (allFactsCache && now < allFactsCache.expiry) {
-        const hit = allFactsCache.value.find(f => normalizeSymbol(f.symbol) === symbol);
-        if (hit) {
-            symbolFactCache.set(symbol, { value: hit, expiry: allFactsCache.expiry });
-            return hit;
-        }
-    }
-    // 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. 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.` };
-    }
-    if ('error' in resp)
-        return { error: resp.error };
-    const fact = resp;
-    if (!fact.symbol) {
-        return { error: `No facts available for ${symbol}` };
-    }
-    symbolFactCache.set(symbol, { value: fact, expiry: now + FACTS_TTL_MS });
-    return fact;
-}
-/** Fetch active strategy rows, caching the full row shape. Both
- *  getStrategiesCached and this share the same rows cache so a warm cache
- *  from either entry point services the other without a second fetch. */
-export async function getStrategyRowsCached(deps) {
-    const now = Date.now();
-    if (stratRowCache && now < stratRowCache.expiry)
-        return stratRowCache.value;
-    const resp = await fetchIntelApi('/api/strategies?active=true', deps, { timeoutMs: 20_000 });
-    // The mocked fetch may return undefined when no more responses are queued;
-    // guard explicitly rather than relying on `'error' in resp` (the `in`
-    // operator throws on undefined).
-    if (!resp || typeof resp !== 'object') {
-        return { error: 'Intelligence /api/strategies returned no response.' };
-    }
-    if ('error' in resp)
-        return { error: resp.error };
-    const rows = (resp.strategies ?? [])
-        .filter((row) => row?.config && isDeclarativeStrategyConfig(row.config));
-    stratRowCache = { value: rows, expiry: now + STRAT_TTL_MS };
-    return rows;
-}
-/** Backwards-compatible configs-only view, derived from the rows cache. */
-export async function getStrategiesCached(deps) {
-    const rows = await getStrategyRowsCached(deps);
-    if ('error' in rows)
-        return rows;
-    return rows.map(r => r.config);
-}
-export const __testing__ = {
-    resetCaches() {
-        allFactsCache = null;
-        stratRowCache = null;
-        symbolFactCache.clear();
-    },
-};

package/assets/plugin/tools/list-strategies.d.ts

@@ -1,17 +0,0 @@
-import type { IntelApiDeps } from './intel-api.js';
-export interface ListStrategiesArgs {
-    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/assets/plugin/tools/list-strategies.js

@@ -1,23 +0,0 @@
-// 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/assets/plugin/tools/modify-stop.d.ts

@@ -1,21 +0,0 @@
-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;
-}
-interface ModifyStopResult {
-    ok: true;
-    symbol: string;
-    old_stop_price: number | null;
-    new_stop_price: number;
-}
-export declare function modifyStopTool(args: ModifyStopArgs, deps: {
-    adapter: IExchangeAdapter;
-    operationLock?: TradingOperationLock;
-    checkWave9LiveSymbolOwnership?: Wave9LiveSymbolOwnershipCheck;
-}): Promise<ModifyStopResult | {
-    error: string;
-}>;
-export {};

package/assets/plugin/tools/modify-stop.js

@@ -1,120 +0,0 @@
-// Tool: modify_stop — move the exchange-side stop-loss on an open live
-// position. Implemented as cancel-then-resubmit inside BracketManager, with
-// automatic rollback if the new submit fails.
-//
-// 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.' };
-    if (!Number.isFinite(args.new_stop_price) || args.new_stop_price <= 0) {
-        return { error: 'new_stop_price must be a positive number.' };
-    }
-    if (!deps.adapter.isLive) {
-        return modifyStopPaper(deps.adapter, args);
-    }
-    if (deps.checkWave9LiveSymbolOwnership && !deps.operationLock) {
-        return {
-            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) };
-    }
-}
-/** Paper: move the stop on the open position's metadata in place. Validates the
- *  same direction geometry live does (stop on the losing side of the current
- *  mark), then writes metadata.stopPrice — no fee, no entry/R reset. */
-function modifyStopPaper(adapter, args) {
-    const sim = adapter.getSimulator();
-    const pos = sim.getPositions(args.symbol)[0];
-    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;
-    const entrySide = pos.side === 'long' ? 'buy' : 'sell';
-    if (Number.isFinite(refPrice) && refPrice > 0) {
-        const msg = validateStopDirection(entrySide, refPrice, args.new_stop_price);
-        if (msg)
-            return { error: msg };
-    }
-    const oldStop = pos.stopPrice ?? null;
-    try {
-        sim.updatePositionMetadata(args.symbol, { stopPrice: args.new_stop_price });
-    }
-    catch (err) {
-        return { error: formatError(err) };
-    }
-    return {
-        ok: true,
-        symbol: args.symbol,
-        old_stop_price: oldStop,
-        new_stop_price: args.new_stop_price,
-    };
-}

package/assets/plugin/tools/modify-target.d.ts

@@ -1,21 +0,0 @@
-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;
-}
-interface ModifyTargetResult {
-    ok: true;
-    symbol: string;
-    old_target_price: number | null;
-    new_target_price: number;
-}
-export declare function modifyTargetTool(args: ModifyTargetArgs, deps: {
-    adapter: IExchangeAdapter;
-    operationLock?: TradingOperationLock;
-    checkWave9LiveSymbolOwnership?: Wave9LiveSymbolOwnershipCheck;
-}): Promise<ModifyTargetResult | {
-    error: string;
-}>;
-export {};