perp-cli 0.6.4 → 0.7.1

package/dist/bot/engine.js

@@ -1,67 +1,167 @@
 import { getMarketSnapshot, evaluateAllConditions } from "./conditions.js";
 import { updateJobState } from "../jobs.js";
-import { checkArbLiquidity } from "../liquidity.js";
-import { computeMatchedSize, reconcileArbFills } from "../arb-sizing.js";
+import { getStrategy } from "./strategy-registry.js";
 import chalk from "chalk";
-export async function runBot(adapter, config, jobId, log = defaultLog, extraAdapters) {
+// Auto-register built-in strategies
+import "./strategies/grid-strategy.js";
+import "./strategies/dca-strategy.js";
+import "./strategies/funding-arb-strategy.js";
+import "./strategies/simple-mm.js";
+import "./strategies/engine-mm.js";
+import "./strategies/avellaneda-mm.js";
+import "./strategies/momentum-breakout.js";
+import "./strategies/mean-reversion.js";
+import "./strategies/aggressive-taker.js";
+import "./strategies/funding-arb-v2.js";
+import "./strategies/basis-arb.js";
+import "./strategies/regime-mm.js";
+import "./strategies/grid-mm.js";
+import "./strategies/liquidation-mm.js";
+import "./strategies/hedge-agent.js";
+import "./strategies/rfq-agent.js";
+import "./strategies/claude-agent.js";
+import "./strategies/apex-strategy.js";
+import "./strategies/funding-auto.js";
+// ── TUI state emitter ──
+class TuiEmitter {
+    stateListeners = [];
+    logListeners = [];
+    subscribe(onState, onLog) {
+        this.stateListeners.push(onState);
+        this.logListeners.push(onLog);
+        return () => {
+            this.stateListeners = this.stateListeners.filter((l) => l !== onState);
+            this.logListeners = this.logListeners.filter((l) => l !== onLog);
+        };
+    }
+    emitState(s) {
+        for (const l of this.stateListeners)
+            l(s);
+    }
+    emitLog(msg) {
+        const entry = { time: new Date().toLocaleTimeString(), message: msg };
+        for (const l of this.logListeners)
+            l(entry);
+    }
+}
+export async function runBot(adapter, config, jobId, log = defaultLog, extraAdapters, // for funding-arb (multi-exchange)
+mode = "headless") {
     const state = {
         phase: "monitoring",
         startTime: Date.now(),
         equity: 0,
         peakEquity: 0,
         dailyPnl: 0,
+        dailyStartEquity: 0,
+        dailyStartDate: new Date().toISOString().slice(0, 10),
         fills: 0,
         totalPnl: 0,
         rebalanceCount: 0,
         lastRebalance: 0,
         strategyActive: false,
-        gridOrders: new Map(),
-        gridUpper: 0,
-        gridLower: 0,
-        dcaOrdersPlaced: 0,
-        dcaLastOrder: 0,
-        arbRunning: false,
-        arbPositions: 0,
     };
+    // Resolve strategy from registry
+    const strategyFactory = getStrategy(config.strategy.type);
+    if (!strategyFactory)
+        throw new Error(`Unknown strategy: ${config.strategy.type}`);
+    const strategy = strategyFactory(config.strategy);
+    const strategyCtx = {
+        adapter,
+        symbol: config.symbol,
+        config: config.strategy,
+        state: new Map(),
+        tick: 0,
+        log,
+    };
+    // Pass extra adapters to strategy context for funding-arb
+    if (extraAdapters) {
+        strategyCtx.state.set("extraAdapters", extraAdapters);
+    }
+    const isDryRun = false; // TODO: wire up from config when dry-run mode is added
     let running = true;
+    // ── TUI / JSON mode setup ──
+    const tuiEmitter = new TuiEmitter();
+    let tuiUnmount;
+    let paused = false;
+    // Wrap log for TUI/JSON modes
+    const effectiveLog = mode === "json"
+        ? () => { } // JSON mode suppresses console log; NDJSON emitted per tick
+        : mode === "tui"
+            ? (msg) => tuiEmitter.emitLog(msg)
+            : log;
+    // Update strategy context to use effective log
+    strategyCtx.log = effectiveLog;
+    if (mode === "tui") {
+        try {
+            const { startDashboard } = await import("./tui/index.js");
+            const initialTuiState = buildTuiState(state, config, { price: 0, volatility24h: 0, fundingRate: 0, volume24h: 0 }, [], [], strategyCtx);
+            const result = startDashboard({
+                initialState: initialTuiState,
+                onQuit: () => { running = false; state.phase = "stopped"; },
+                onPause: () => { paused = !paused; },
+                subscribe: (onState, onLog) => tuiEmitter.subscribe(onState, onLog),
+            });
+            tuiUnmount = result.unmount;
+        }
+        catch {
+            // Fallback to headless if TUI fails (e.g., non-TTY)
+            // mode stays as-is but we just use the original log
+        }
+    }
     const shutdown = () => { running = false; state.phase = "stopped"; };
     process.on("SIGINT", shutdown);
     process.on("SIGTERM", shutdown);
-    // Header
-    log(chalk.cyan.bold(`\n  ╔═══════════════════════════════════════╗`));
-    log(chalk.cyan.bold(`  ║  ${config.name.padEnd(37)}║`));
-    log(chalk.cyan.bold(`  ╚═══════════════════════════════════════╝\n`));
-    log(`  Exchange:  ${chalk.white(config.exchange)}`);
-    log(`  Symbol:    ${chalk.white(config.symbol)}`);
-    log(`  Strategy:  ${chalk.white(config.strategy.type)}`);
-    log(`  Risk:      max drawdown $${config.risk.max_drawdown} | max daily loss $${config.risk.max_daily_loss}`);
-    log(`  Entry:     ${config.entry_conditions.map(c => c.type).join(" + ")}`);
-    log(`  Exit:      ${config.exit_conditions.map(c => c.type).join(" | ") || "manual"}`);
-    log("");
+    if (mode !== "tui") {
+        // Header (headless / json modes print header to console)
+        log(chalk.cyan.bold(`\n  ╔═══════════════════════════════════════╗`));
+        log(chalk.cyan.bold(`  ║  ${config.name.padEnd(37)}║`));
+        log(chalk.cyan.bold(`  ╚═══════════════════════════════════════╝\n`));
+        log(`  Exchange:  ${chalk.white(config.exchange)}`);
+        log(`  Symbol:    ${chalk.white(config.symbol)}`);
+        log(`  Strategy:  ${chalk.white(config.strategy.type)}`);
+        log(`  Risk:      max drawdown $${config.risk.max_drawdown} | max daily loss $${config.risk.max_daily_loss}`);
+        log(`  Entry:     ${config.entry_conditions.map(c => c.type).join(" + ")}`);
+        log(`  Exit:      ${config.exit_conditions.map(c => c.type).join(" | ") || "manual"}`);
+        log("");
+    }
     // Get initial equity
     try {
         const bal = await adapter.getBalance();
         state.equity = parseFloat(bal.equity);
         state.peakEquity = state.equity;
-        log(`  Starting equity: $${state.equity.toFixed(2)}`);
+        state.dailyStartEquity = state.equity;
+        effectiveLog(`  Starting equity: $${state.equity.toFixed(2)}`);
     }
     catch {
-        log(chalk.yellow(`  Could not fetch initial balance`));
+        effectiveLog(chalk.yellow(`  Could not fetch initial balance`));
+    }
+    if (mode !== "tui") {
+        log(chalk.gray(`\n  Monitoring conditions... (Ctrl+C to stop)\n`));
     }
-    log(chalk.gray(`\n  Monitoring conditions... (Ctrl+C to stop)\n`));
     try {
         while (running) {
+            // Honor pause toggle from TUI
+            if (paused) {
+                await sleep(500);
+                continue;
+            }
             const loopStart = Date.now();
             try {
-                // Get market data
-                const snapshot = await getMarketSnapshot(adapter, config.symbol);
+                // Get market data (enriched for strategy use)
+                const snapshot = await getEnrichedSnapshot(adapter, config.symbol);
                 // Update equity
                 try {
                     const bal = await adapter.getBalance();
                     state.equity = parseFloat(bal.equity);
                     if (state.equity > state.peakEquity)
                         state.peakEquity = state.equity;
-                    state.dailyPnl = state.equity - state.peakEquity; // simplified
+                    // Reset daily baseline at day boundary
+                    const today = new Date().toISOString().slice(0, 10);
+                    if (today !== state.dailyStartDate) {
+                        state.dailyStartEquity = state.equity;
+                        state.dailyStartDate = today;
+                    }
+                    state.dailyPnl = state.equity - state.dailyStartEquity;
                 }
                 catch { /* non-critical */ }
                 const context = {
@@ -74,24 +174,30 @@ export async function runBot(adapter, config, jobId, log = defaultLog, extraAdap
                 if (state.phase === "monitoring") {
                     const shouldEnter = evaluateAllConditions(config.entry_conditions, snapshot, context, "all");
                     if (shouldEnter) {
-                        log(chalk.green(`  ✓ Entry conditions met @ $${snapshot.price.toFixed(2)}`));
+                        effectiveLog(`  Entry conditions met @ $${snapshot.price.toFixed(2)}`);
                         state.phase = "entering";
                     }
                     else {
-                        logStatus(log, state, snapshot, "waiting");
+                        logStatus(effectiveLog, state, snapshot, "waiting");
                     }
                 }
                 // ── Phase: Entering (start strategy) ──
                 if (state.phase === "entering") {
                     try {
-                        await startStrategy(adapter, config, state, snapshot, log, extraAdapters);
+                        await strategy.init(strategyCtx, snapshot);
+                        // Execute any initial actions (e.g., grid placement on first tick)
+                        strategyCtx.tick = 0;
+                        const initActions = await strategy.onTick(strategyCtx, snapshot);
+                        await executeActions(adapter, config.symbol, initActions, effectiveLog, isDryRun);
+                        state.fills += countFills(initActions);
+                        strategyCtx.tick++;
                         state.phase = "running";
                         state.strategyActive = true;
-                        log(chalk.green(`  ▶ Strategy started`));
+                        effectiveLog(`  Strategy started`);
                     }
                     catch (err) {
                         const msg = err instanceof Error ? err.message : String(err);
-                        log(chalk.red(`  ✗ Strategy start failed: ${msg}`));
+                        effectiveLog(`  Strategy start failed: ${msg}`);
                         state.phase = "monitoring"; // retry
                     }
                 }
@@ -102,37 +208,54 @@ export async function runBot(adapter, config, jobId, log = defaultLog, extraAdap
                         && evaluateAllConditions(config.exit_conditions, snapshot, context, "any");
                     // Check risk limits
                     const drawdown = state.peakEquity - state.equity;
-                    const riskBreached = drawdown > config.risk.max_drawdown;
+                    const dailyLossBreached = state.dailyPnl < -config.risk.max_daily_loss;
+                    const riskBreached = drawdown > config.risk.max_drawdown || dailyLossBreached;
                     if (shouldExit || riskBreached) {
-                        const reason = riskBreached
-                            ? `drawdown $${drawdown.toFixed(2)} > limit $${config.risk.max_drawdown}`
-                            : "exit condition met";
-                        log(chalk.yellow(`  ⚠ Exiting: ${reason}`));
+                        const reason = dailyLossBreached
+                            ? `daily loss $${Math.abs(state.dailyPnl).toFixed(2)} > limit $${config.risk.max_daily_loss}`
+                            : drawdown > config.risk.max_drawdown
+                                ? `drawdown $${drawdown.toFixed(2)} > limit $${config.risk.max_drawdown}`
+                                : "exit condition met";
+                        effectiveLog(`  Exiting: ${reason}`);
                         state.phase = "exiting";
                     }
                     else {
                         // Manage running strategy
-                        await manageStrategy(adapter, config, state, snapshot, log, extraAdapters);
-                        logStatus(log, state, snapshot, "running");
+                        const actions = await strategy.onTick(strategyCtx, snapshot);
+                        await executeActions(adapter, config.symbol, actions, effectiveLog, isDryRun);
+                        state.fills += countFills(actions);
+                        strategyCtx.tick++;
+                        logStatus(effectiveLog, state, snapshot, "running");
                     }
                 }
                 // ── Phase: Exiting (close everything) ──
                 if (state.phase === "exiting") {
-                    await stopStrategy(adapter, config, state, log);
+                    const stopActions = await strategy.onStop(strategyCtx);
+                    await executeActions(adapter, config.symbol, stopActions, effectiveLog, isDryRun);
                     state.strategyActive = false;
                     if (config.risk.pause_after_loss_sec > 0 && state.dailyPnl < 0) {
-                        log(chalk.yellow(`  ⏸ Pausing ${config.risk.pause_after_loss_sec}s after loss`));
+                        effectiveLog(`  Pausing ${config.risk.pause_after_loss_sec}s after loss`);
                         state.phase = "paused";
                         await sleep(config.risk.pause_after_loss_sec * 1000);
                         state.phase = "monitoring";
-                        log(chalk.gray(`  Resuming monitoring...`));
+                        effectiveLog(`  Resuming monitoring...`);
                     }
                     else {
                         // If exit due to risk breach, stop completely
-                        log(chalk.red(`  ■ Bot stopped.`));
+                        effectiveLog(`  Bot stopped.`);
                         break;
                     }
                 }
+                // ── Emit state update for TUI / JSON ──
+                const positions = await fetchPositions(adapter, config.symbol);
+                const openOrders = await fetchOpenOrders(adapter, config.symbol);
+                const tuiState = buildTuiState(state, config, snapshot, positions, openOrders, strategyCtx);
+                if (mode === "tui") {
+                    tuiEmitter.emitState(tuiState);
+                }
+                else if (mode === "json") {
+                    console.log(JSON.stringify(tuiState));
+                }
                 // Update job state
                 if (jobId) {
                     updateJobState(jobId, {
@@ -150,7 +273,7 @@ export async function runBot(adapter, config, jobId, log = defaultLog, extraAdap
             }
             catch (err) {
                 const msg = err instanceof Error ? err.message : String(err);
-                log(chalk.red(`  ✗ Loop error: ${msg}`));
+                effectiveLog(`  Loop error: ${msg}`);
             }
             // Wait for next interval
             const elapsed = Date.now() - loopStart;
@@ -164,334 +287,83 @@ export async function runBot(adapter, config, jobId, log = defaultLog, extraAdap
         process.removeListener("SIGTERM", shutdown);
         // Cleanup: cancel any remaining orders
         if (state.strategyActive) {
-            log(chalk.gray(`  Cleaning up orders...`));
+            effectiveLog(`  Cleaning up orders...`);
             try {
                 await adapter.cancelAllOrders(config.symbol);
             }
             catch { /* best effort */ }
         }
+        // Unmount TUI if active
+        if (tuiUnmount) {
+            tuiUnmount();
+        }
     }
     const runtime = Math.floor((Date.now() - state.startTime) / 1000);
-    log(chalk.cyan.bold(`\n  Bot "${config.name}" finished`));
-    log(`  Runtime: ${formatDuration(runtime)} | Fills: ${state.fills} | PnL: $${state.totalPnl.toFixed(2)}`);
-    log(`  Equity: $${state.equity.toFixed(2)} (peak: $${state.peakEquity.toFixed(2)})\n`);
+    if (mode === "json") {
+        console.log(JSON.stringify({ event: "done", fills: state.fills, totalPnl: state.totalPnl, runtime, equity: state.equity, peakEquity: state.peakEquity }));
+    }
+    else if (mode !== "tui") {
+        log(chalk.cyan.bold(`\n  Bot "${config.name}" finished`));
+        log(`  Runtime: ${formatDuration(runtime)} | Fills: ${state.fills} | PnL: $${state.totalPnl.toFixed(2)}`);
+        log(`  Equity: $${state.equity.toFixed(2)} (peak: $${state.peakEquity.toFixed(2)})\n`);
+    }
     if (jobId) {
         updateJobState(jobId, { status: "done" });
     }
     return { fills: state.fills, totalPnl: state.totalPnl, runtime };
 }
-// ── Strategy lifecycle ──
-async function startStrategy(adapter, config, state, snapshot, log, extraAdapters) {
-    const strat = config.strategy;
-    if (strat.type === "grid") {
-        await startGrid(adapter, config.symbol, strat, state, snapshot, log);
-    }
-    else if (strat.type === "dca") {
-        state.dcaOrdersPlaced = 0;
-        state.dcaLastOrder = 0;
-        log(`  [DCA] Ready: ${strat.amount} ${config.symbol} every ${strat.interval_sec}s`);
-    }
-    else if (strat.type === "funding-arb") {
-        state.arbRunning = true;
-        state.arbPositions = 0;
-        log(`  [ARB] Funding arb ready | spread >= ${strat.min_spread}% | size $${strat.size_usd}`);
-        log(`  [ARB] Exchanges: ${strat.exchanges.join(", ")}`);
-    }
-}
-async function manageStrategy(adapter, config, state, snapshot, log, extraAdapters) {
-    const strat = config.strategy;
-    if (strat.type === "grid") {
-        await manageGrid(adapter, config.symbol, strat, state, snapshot, log);
-    }
-    else if (strat.type === "dca") {
-        await manageDCA(adapter, config.symbol, strat, state, snapshot, log);
-    }
-    else if (strat.type === "funding-arb") {
-        await manageFundingArb(adapter, config.symbol, strat, state, snapshot, log, extraAdapters);
-    }
-}
-async function stopStrategy(adapter, config, state, log) {
-    log(`  Cancelling all orders...`);
-    try {
-        await adapter.cancelAllOrders(config.symbol);
-    }
-    catch { /* best effort */ }
-    state.gridOrders.clear();
-}
-// ── Grid strategy ──
-async function startGrid(adapter, symbol, params, state, snapshot, log) {
-    // Determine price range
-    if (params.range_mode === "auto") {
-        const pct = params.range_pct ?? 3;
-        state.gridUpper = snapshot.price * (1 + pct / 100);
-        state.gridLower = snapshot.price * (1 - pct / 100);
-        log(`  [GRID] Auto range: $${state.gridLower.toFixed(2)} - $${state.gridUpper.toFixed(2)} (±${pct}%)`);
-    }
-    else {
-        if (!params.upper || !params.lower)
-            throw new Error("Fixed grid requires upper and lower");
-        state.gridUpper = params.upper;
-        state.gridLower = params.lower;
-    }
-    // Set leverage
-    if (params.leverage) {
-        try {
-            await adapter.setLeverage(symbol, params.leverage);
-            log(`  [GRID] Leverage: ${params.leverage}x`);
-        }
-        catch { /* non-critical */ }
-    }
-    // Place grid orders
-    await placeGridOrders(adapter, symbol, params, state, snapshot.price, log);
-}
-async function placeGridOrders(adapter, symbol, params, state, currentPrice, log) {
-    const step = (state.gridUpper - state.gridLower) / (params.grids - 1);
-    const sizePerGrid = params.size / params.grids;
-    let placed = 0;
-    // Cancel existing orders first
-    if (state.gridOrders.size > 0) {
-        try {
-            await adapter.cancelAllOrders(symbol);
-        }
-        catch { /* */ }
-        state.gridOrders.clear();
-    }
-    for (let i = 0; i < params.grids; i++) {
-        const price = state.gridLower + step * i;
-        // Determine side based on current price
-        let side;
-        if (params.side === "long")
-            side = "buy";
-        else if (params.side === "short")
-            side = "sell";
-        else
-            side = price < currentPrice ? "buy" : "sell";
-        try {
-            const result = await adapter.limitOrder(symbol, side, price.toFixed(2), String(sizePerGrid));
-            const orderId = String(result?.orderId ?? result?.oid ?? result?.id ?? "");
-            state.gridOrders.set(i, orderId);
-            placed++;
+// ── Action executor ──
+async function executeActions(adapter, symbol, actions, log, dryRun = false) {
+    for (const action of actions) {
+        if (dryRun) {
+            log(`  [DRY-RUN] ${action.type}: ${JSON.stringify(action)}`);
+            continue;
         }
-        catch {
-            // skip failed grid line
-        }
-    }
-    log(`  [GRID] Placed ${placed}/${params.grids} orders (step: $${step.toFixed(2)}, size: ${sizePerGrid.toFixed(6)})`);
-}
-async function manageGrid(adapter, symbol, params, state, snapshot, log) {
-    const step = (state.gridUpper - state.gridLower) / (params.grids - 1);
-    const sizePerGrid = params.size / params.grids;
-    // Check for fills
-    try {
-        const openOrders = await adapter.getOpenOrders();
-        const openIds = new Set(openOrders.filter(o => o.symbol.toUpperCase() === symbol.toUpperCase()).map(o => o.orderId));
-        let newFills = 0;
-        for (const [idx, orderId] of state.gridOrders.entries()) {
-            if (!openIds.has(orderId)) {
-                // Order filled — place opposite order
-                newFills++;
-                state.fills++;
-                state.totalPnl += step * sizePerGrid;
-                // Determine new side and price
-                const oldPrice = state.gridLower + step * idx;
-                const wasBuy = oldPrice < snapshot.price;
-                const newSide = wasBuy ? "sell" : "buy";
-                const newPrice = wasBuy ? oldPrice + step : oldPrice - step;
-                if (newPrice >= state.gridLower && newPrice <= state.gridUpper) {
-                    try {
-                        const result = await adapter.limitOrder(symbol, newSide, newPrice.toFixed(2), String(sizePerGrid));
-                        const newOrderId = String(result?.orderId ?? result?.oid ?? result?.id ?? "");
-                        state.gridOrders.set(idx, newOrderId);
-                    }
-                    catch { /* skip */ }
+        switch (action.type) {
+            case "place_order":
+                if (action.orderType === "market") {
+                    await adapter.marketOrder(symbol, action.side, action.size);
                 }
                 else {
-                    state.gridOrders.delete(idx);
+                    await adapter.limitOrder(symbol, action.side, action.price, action.size, {
+                        reduceOnly: action.reduceOnly,
+                        tif: action.tif,
+                    });
                 }
-            }
-        }
-        if (newFills > 0) {
-            log(chalk.green(`  [GRID] ${newFills} fill(s) | Total: ${state.fills} | Est. PnL: $${state.totalPnl.toFixed(2)}`));
-        }
-    }
-    catch { /* retry next loop */ }
-    // Auto-rebalance if price exits range
-    if (params.rebalance) {
-        const outOfRange = snapshot.price > state.gridUpper || snapshot.price < state.gridLower;
-        const cooldownOk = Date.now() - state.lastRebalance > params.rebalance_cooldown * 1000;
-        if (outOfRange && cooldownOk) {
-            const pct = params.range_pct ?? 3;
-            state.gridUpper = snapshot.price * (1 + pct / 100);
-            state.gridLower = snapshot.price * (1 - pct / 100);
-            state.rebalanceCount++;
-            state.lastRebalance = Date.now();
-            log(chalk.yellow(`  [GRID] Rebalance #${state.rebalanceCount}: price $${snapshot.price.toFixed(2)} outside range → new $${state.gridLower.toFixed(2)} - $${state.gridUpper.toFixed(2)}`));
-            await placeGridOrders(adapter, symbol, params, state, snapshot.price, log);
-        }
-    }
-}
-// ── DCA strategy ──
-async function manageDCA(adapter, symbol, params, state, snapshot, log) {
-    // Check if it's time for next order
-    const timeSinceLast = (Date.now() - state.dcaLastOrder) / 1000;
-    if (state.dcaLastOrder > 0 && timeSinceLast < params.interval_sec)
-        return;
-    // Check order limit
-    if (params.total_orders > 0 && state.dcaOrdersPlaced >= params.total_orders)
-        return;
-    // Check price limit
-    if (params.price_limit) {
-        // For DCA, we assume buying — skip if price above limit
-        if (snapshot.price > params.price_limit) {
-            return;
+                break;
+            case "cancel_order":
+                await adapter.cancelOrder(symbol, action.orderId);
+                break;
+            case "cancel_all":
+                await adapter.cancelAllOrders(symbol);
+                break;
+            case "edit_order":
+                await adapter.editOrder(symbol, action.orderId, action.price, action.size);
+                break;
+            case "set_leverage":
+                await adapter.setLeverage(symbol, action.leverage, action.marginMode);
+                break;
+            case "noop":
+                break;
         }
     }
-    // Place market order
-    try {
-        const side = "buy"; // DCA is typically buying
-        await adapter.marketOrder(symbol, side, String(params.amount));
-        state.dcaOrdersPlaced++;
-        state.dcaLastOrder = Date.now();
-        state.fills++;
-        const progress = params.total_orders > 0 ? ` (${state.dcaOrdersPlaced}/${params.total_orders})` : "";
-        log(chalk.green(`  [DCA] Order #${state.dcaOrdersPlaced}${progress}: buy ${params.amount} ${symbol} @ $${snapshot.price.toFixed(2)}`));
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        log(chalk.red(`  [DCA] Order failed: ${msg}`));
-    }
 }
-async function fetchRatesFromAdapter(adapter, exchangeName) {
-    try {
-        const markets = await adapter.getMarkets();
-        return markets.map(m => ({
-            symbol: m.symbol,
-            rate: parseFloat(m.fundingRate),
-            price: parseFloat(m.markPrice),
-        }));
-    }
-    catch {
-        return [];
-    }
-}
-async function manageFundingArb(adapter, symbol, params, state, _snapshot, log, extraAdapters) {
-    // Build adapter map from primary + extras
-    const adapters = new Map();
-    adapters.set(adapter.name.toLowerCase(), adapter);
-    if (extraAdapters) {
-        for (const [name, a] of extraAdapters)
-            adapters.set(name, a);
-    }
-    if (adapters.size < 2) {
-        log(chalk.yellow(`  [ARB] Need 2+ exchanges, have ${adapters.size}. Skipping.`));
-        return;
-    }
-    // Fetch rates from all exchanges
-    const ratesByExchange = new Map();
-    for (const [name, a] of adapters) {
-        const rates = await fetchRatesFromAdapter(a, name);
-        const map = new Map();
-        for (const r of rates)
-            map.set(r.symbol.toUpperCase(), { rate: r.rate, price: r.price });
-        ratesByExchange.set(name, map);
-    }
-    // Find opportunities: largest spread between any two exchanges
-    const exchangeNames = [...ratesByExchange.keys()];
-    const opportunities = [];
-    // Collect all symbols
-    const allSymbols = new Set();
-    for (const [, map] of ratesByExchange) {
-        for (const sym of map.keys())
-            allSymbols.add(sym);
-    }
-    for (const sym of allSymbols) {
-        let minRate = Infinity, maxRate = -Infinity;
-        let minExchange = "", maxExchange = "";
-        for (const exName of exchangeNames) {
-            const rate = ratesByExchange.get(exName)?.get(sym)?.rate;
-            if (rate === undefined)
-                continue;
-            if (rate < minRate) {
-                minRate = rate;
-                minExchange = exName;
-            }
-            if (rate > maxRate) {
-                maxRate = rate;
-                maxExchange = exName;
-            }
-        }
-        if (minExchange && maxExchange && minExchange !== maxExchange) {
-            const { computeAnnualSpread: cas } = await import("../funding.js");
-            const spread = cas(maxRate, maxExchange, minRate, minExchange);
-            if (spread >= params.min_spread) {
-                opportunities.push({
-                    symbol: sym,
-                    longExchange: minExchange, // long where rate is low (we receive funding)
-                    shortExchange: maxExchange, // short where rate is high (we pay less or receive)
-                    longRate: minRate,
-                    shortRate: maxRate,
-                    spread,
-                });
-            }
-        }
-    }
-    // Sort by spread descending
-    opportunities.sort((a, b) => b.spread - a.spread);
-    if (opportunities.length > 0) {
-        const top = opportunities.slice(0, 3);
-        for (const opp of top) {
-            log(`  [ARB] ${opp.symbol}: ${opp.spread.toFixed(1)}% spread (long ${opp.longExchange} ${(opp.longRate * 100).toFixed(4)}% / short ${opp.shortExchange} ${(opp.shortRate * 100).toFixed(4)}%)`);
-        }
-        // Auto-execute if under position limit
-        if (state.arbPositions < params.max_positions && opportunities.length > 0) {
-            const best = opportunities[0];
-            const longAdapter = adapters.get(best.longExchange);
-            const shortAdapter = adapters.get(best.shortExchange);
-            if (longAdapter && shortAdapter) {
-                // Calculate size from USD
-                const price = ratesByExchange.get(best.longExchange)?.get(best.symbol)?.price ?? 0;
-                if (price > 0) {
-                    // Liquidity check & size adjustment
-                    const liq = await checkArbLiquidity(longAdapter, shortAdapter, best.symbol, params.size_usd, 0.5, (msg) => log(chalk.yellow(`  ${msg}`)));
-                    if (!liq.viable)
-                        return;
-                    // Compute matched size for both legs
-                    const matched = computeMatchedSize(liq.adjustedSizeUsd, price, best.longExchange, best.shortExchange);
-                    if (!matched) {
-                        log(chalk.yellow(`  [ARB] Skip ${best.symbol}: can't compute matched size (min notional or precision issue)`));
-                        return;
-                    }
-                    try {
-                        log(chalk.cyan(`  [ARB] Opening: ${matched.size} ${best.symbol} on both legs ($${matched.notional.toFixed(0)}/leg, slippage ~${liq.longSlippage.toFixed(2)}%/${liq.shortSlippage.toFixed(2)}%)`));
-                        await Promise.all([
-                            longAdapter.marketOrder(best.symbol, "buy", matched.size),
-                            shortAdapter.marketOrder(best.symbol, "sell", matched.size),
-                        ]);
-                        // Verify fills match, correct if needed
-                        try {
-                            const recon = await reconcileArbFills(longAdapter, shortAdapter, best.symbol, (msg) => log(chalk.yellow(`  ${msg}`)));
-                            if (!recon.matched) {
-                                log(chalk.red(`  [ARB] WARNING: fills not matched after correction attempt`));
-                            }
-                        }
-                        catch { /* non-critical */ }
-                        state.arbPositions++;
-                        state.fills += 2;
-                        log(chalk.green(`  [ARB] Position opened! (${state.arbPositions}/${params.max_positions})`));
-                    }
-                    catch (err) {
-                        const msg = err instanceof Error ? err.message : String(err);
-                        log(chalk.red(`  [ARB] Execution failed: ${msg}`));
-                    }
-                }
-            }
-        }
-    }
-    else {
-        log(chalk.gray(`  [ARB] No opportunities >= ${params.min_spread}% spread`));
-    }
+// ── Enriched snapshot ──
+async function getEnrichedSnapshot(adapter, symbol) {
+    const base = await getMarketSnapshot(adapter, symbol);
+    const [orderbook, klines, markets] = await Promise.all([
+        adapter.getOrderbook(symbol).catch(() => ({ bids: [], asks: [] })),
+        adapter.getKlines(symbol, "1h", Date.now() - 24 * 60 * 60 * 1000, Date.now()).catch(() => []),
+        adapter.getMarkets().catch(() => []),
+    ]);
+    const market = markets.find(m => m.symbol.toUpperCase().includes(symbol.toUpperCase()));
+    return { ...base, klines, orderbook, openInterest: market?.openInterest ?? "0" };
 }
 // ── Utils ──
+/** Count fill-producing actions (market orders and limit orders) */
+function countFills(actions) {
+    return actions.filter(a => a.type === "place_order" && a.orderType === "market").length;
+}
 function logStatus(log, state, snapshot, phase) {
     const runtime = formatDuration(Math.floor((Date.now() - state.startTime) / 1000));
     const vol = snapshot.volatility24h.toFixed(1);
@@ -517,3 +389,76 @@ function formatDuration(sec) {
 function sleep(ms) {
     return new Promise(r => setTimeout(r, ms));
 }
+// ── TUI helpers ──
+async function fetchPositions(adapter, symbol) {
+    try {
+        const positions = await adapter.getPositions();
+        return positions
+            .filter(p => p.symbol.toUpperCase().includes(symbol.toUpperCase()) && parseFloat(p.size) !== 0)
+            .map(p => ({
+            symbol: p.symbol,
+            side: p.side,
+            size: p.size,
+            entryPrice: p.entryPrice,
+            markPrice: p.markPrice,
+            unrealizedPnl: p.unrealizedPnl,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+async function fetchOpenOrders(adapter, symbol) {
+    try {
+        const orders = await adapter.getOpenOrders();
+        return orders
+            .filter(o => o.symbol.toUpperCase().includes(symbol.toUpperCase()))
+            .map(o => ({
+            orderId: o.orderId,
+            side: o.side,
+            price: o.price,
+            size: o.size,
+            type: o.type,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+function buildTuiState(state, config, snapshot, positions, openOrders, strategyCtx) {
+    // Extract serializable strategy state from the Map
+    const strategyState = {};
+    for (const [k, v] of strategyCtx.state) {
+        // Skip non-serializable values (adapters, functions)
+        if (typeof v === "function" || (typeof v === "object" && v !== null && !(Array.isArray(v)) && v instanceof Map))
+            continue;
+        try {
+            JSON.stringify(v);
+            strategyState[k] = v;
+        }
+        catch {
+            // skip non-serializable
+        }
+    }
+    return {
+        phase: state.phase,
+        equity: state.equity,
+        peakEquity: state.peakEquity,
+        dailyPnl: state.dailyPnl,
+        fills: state.fills,
+        totalPnl: state.totalPnl,
+        runtime: Math.floor((Date.now() - state.startTime) / 1000),
+        strategy: config.strategy.type,
+        symbol: config.symbol,
+        exchange: config.exchange,
+        price: snapshot.price,
+        volume24h: snapshot.volume24h ?? 0,
+        openInterest: "0",
+        fundingRate: snapshot.fundingRate,
+        volatility24h: snapshot.volatility24h,
+        positions,
+        openOrders,
+        strategyState,
+        tick: strategyCtx.tick,
+    };
+}