perp-cli 0.4.12 → 0.5.2

package/dist/commands/arb-auto.js

@@ -1,5 +1,5 @@
 import chalk from "chalk";
-import { formatUsd, printJson, jsonOk } from "../utils.js";
+import { formatUsd, printJson, jsonOk, makeTable } from "../utils.js";
 import { computeExecutableSize } from "../liquidity.js";
 import { computeAnnualSpread, toHourlyRate } from "../funding.js";
 import { fetchPacificaPricesRaw, parsePacificaRaw, fetchHyperliquidMetaRaw, parseHyperliquidMetaRaw, fetchLighterOrderBookDetailsRaw, fetchLighterFundingRatesRaw, parseLighterRaw, } from "../shared-api.js";
@@ -9,6 +9,7 @@ import { smartOrder } from "../smart-order.js";
 import { aggressiveSettleBoost, estimateFundingUntilSettlement, computeBasisRisk, notifyIfEnabled, } from "../arb-utils.js";
 import { checkChainMargins, isCriticalMargin, shouldBlockEntries, computeAutoSize, } from "../cross-chain-margin.js";
 import { loadArbState, saveArbState, addPosition as persistAddPosition, removePosition as persistRemovePosition, createInitialState, } from "../arb-state.js";
+import { handleRates, handleBasisScan, handleDexScan, handleCompare, handleFundingHistory, handleFundingPositions, fetchAllPrices, printGapTable, printTrackSummary, formatGapPrice, } from "./arb.js";
 // ── Fee-Adjusted Net Spread Calculation ──
 import { getTakerFee } from "../constants.js";
 /**
@@ -151,6 +152,8 @@ async function fetchFundingSpreads() {
     }
     return snapshots.sort((a, b) => Math.abs(b.spread) - Math.abs(a.spread));
 }
+// Module-level holder for spot-close handler -- assigned inside registerArbAutoCommands.
+export let handleSpotClose;
 export function registerArbAutoCommands(program, getAdapterForExchange, isJson, getHLAdapterForDex) {
     const arb = program.commands.find(c => c.name() === "arb");
     if (!arb)
@@ -158,7 +161,7 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
     // ── arb auto ── (daemon mode)
     arb
         .command("auto")
-        .description("Auto-execute funding rate arbitrage (daemon)")
+        .description("Auto-execute funding rate arbitrage (daemon). Use --hip3 for HIP-3 cross-dex mode.")
         .option("--min-spread <pct>", "Min annual spread to enter (%)", "30")
         .option("--close-spread <pct>", "Close when spread drops below (%)", "5")
         .option("--size <usd>", "Position size per leg ($)", "100")
@@ -167,7 +170,7 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
         .option("--symbols <list>", "Comma-separated symbols to monitor (default: all)")
         .option("--interval <seconds>", "Check interval", "60")
         .option("--hold-days <days>", "Expected hold period for cost amortization", "7")
-        .option("--bridge-cost <usd>", "One-way bridge cost in USD", "0.5")
+        .option("--bridge-cost <usd>", "One-way bridge cost in USD", "0")
         .option("--no-reversal-exit", "Disable emergency exit on spread reversal")
         .option("--settle-aware", "Avoid entries near funding settlement (default: true)")
         .option("--no-settle-aware", "Disable settlement timing awareness")
@@ -179,7 +182,23 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
         .option("--cooldown <minutes>", "Minutes to wait before re-entering a closed symbol", "30")
         .option("--dry-run", "Simulate without executing trades")
         .option("--background", "Run in background (tmux)")
+        .option("--hip3", "Run HIP-3 cross-dex auto arb instead of perp-perp")
+        .option("--min-oi <usd>", "Min OI (USD) to enter (hip3 mode)", "50000")
+        .option("--min-grade <grade>", "Min viability grade: A, B, C, D (hip3 mode)", "C")
         .action(async (opts) => {
+        // Route to HIP-3 dex-auto logic if --hip3 flag is set
+        if (opts.hip3) {
+            return handleDexAuto({
+                minSpread: opts.minSpread,
+                closeSpread: opts.closeSpread,
+                size: opts.size,
+                maxPositions: opts.maxPositions,
+                minOi: opts.minOi,
+                minGrade: opts.minGrade,
+                interval: opts.interval,
+                dryRun: opts.dryRun,
+            });
+        }
         if (opts.background) {
             const { startJob } = await import("../jobs.js");
             const cliArgs = [
@@ -898,14 +917,242 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
     // ── arb scan ── (one-shot spread scan)
     arb
         .command("scan")
-        .description("Scan current funding rate spreads (perp-perp or spot-perp)")
-        .option("--mode <mode>", "Scan mode: perp-perp, spot-perp, all", "perp-perp")
+        .description("Scan funding spreads, rates, basis, gaps, HIP-3, or positions (--live for continuous monitoring)")
+        .option("--mode <mode>", "Scan mode: all, perp-perp, spot-perp", "all")
         .option("--min <pct>", "Min annual spread to show", "10")
         .option("--top <n>", "Return only top N results (for JSON output)")
         .option("--hold-days <days>", "Expected hold period for cost calc", "7")
-        .option("--bridge-cost <usd>", "One-way bridge cost in USD", "0.5")
+        .option("--bridge-cost <usd>", "One-way bridge cost in USD", "0")
         .option("--size <usd>", "Position size per leg ($) for cost calc", "100")
+        .option("--rates", "Show funding rates across all exchanges")
+        .option("--basis [symbol]", "Scan cross-exchange basis opportunities (optionally for a specific symbol)")
+        .option("--hip3", "Scan HIP-3 cross-dex funding spreads")
+        .option("--compare <symbol>", "Compare funding rates for a specific symbol")
+        .option("--history [symbol]", "Show funding rate history (optionally for a specific symbol)")
+        .option("--positions", "Show position funding impact")
+        .option("-s, --symbol <sym>", "Filter/track symbol")
+        .option("--symbols <list>", "Comma-separated list of symbols")
+        .option("--all", "Include all symbols (not just top)")
+        .option("--hours <n>", "Hours of history to show", "24")
+        .option("--exchange <ex>", "Filter by exchange")
+        .option("--max-gap <pct>", "Max price gap % (hip3 mode)")
+        .option("--include-native", "Include native HL perps (hip3 mode)", true)
+        .option("--no-include-native", "Exclude native HL perps (hip3 mode)")
+        .option("--gaps", "Show cross-exchange price gaps")
+        .option("--live", "Continuous live monitoring (auto-refresh)")
+        .option("--track", "Track a symbol's price gap over time (requires -s)")
+        .option("--alert <pct>", "Alert when price gap exceeds threshold % (requires -s)")
+        .option("--interval <seconds>", "Refresh interval for --live mode", "60")
+        .option("--duration <minutes>", "Track duration in minutes (with --track)", "10")
+        .option("--beep", "Beep on large gaps (with --gaps)")
+        .option("--check-liquidity", "Check orderbook depth in live mode (slower)")
         .action(async (opts) => {
+        // ── Price gap modes ──
+        if (opts.gaps || opts.track || opts.alert) {
+            const sym = opts.symbol?.toUpperCase();
+            const minGap = parseFloat(opts.min);
+            const intervalMs = parseInt(opts.interval) * 1000;
+            // Alert mode
+            if (opts.alert) {
+                if (!sym) {
+                    console.log(chalk.red("  --alert requires --symbol or -s"));
+                    return;
+                }
+                const threshold = parseFloat(opts.alert);
+                if (!isJson())
+                    console.log(chalk.cyan(`\n  Waiting for ${sym} gap > ${threshold}%...\n`));
+                const check = async () => {
+                    const snapshots = await fetchAllPrices();
+                    const s = snapshots.find((x) => x.symbol === sym);
+                    if (!s)
+                        return false;
+                    const now = new Date().toLocaleTimeString();
+                    if (!isJson())
+                        console.log(chalk.gray(`  ${now} ${sym} gap: ${s.maxGapPct.toFixed(4)}%`));
+                    if (s.maxGapPct >= threshold) {
+                        if (isJson()) {
+                            printJson(jsonOk(s));
+                        }
+                        else {
+                            console.log(chalk.green.bold(`\n  TRIGGERED! ${sym} gap: ${s.maxGapPct.toFixed(4)}% (> ${threshold}%)`));
+                            const lines = [];
+                            if (s.pacPrice !== null)
+                                lines.push(`  Pacifica:    $${formatGapPrice(s.pacPrice)}`);
+                            if (s.hlPrice !== null)
+                                lines.push(`  Hyperliquid: $${formatGapPrice(s.hlPrice)}`);
+                            if (s.ltPrice !== null)
+                                lines.push(`  Lighter:     $${formatGapPrice(s.ltPrice)}`);
+                            lines.push(`  Gap:         $${s.maxGap.toFixed(4)} (${s.cheapest}→${s.expensive})`);
+                            console.log(lines.join("\n") + "\n");
+                        }
+                        return true;
+                    }
+                    return false;
+                };
+                if (await check())
+                    return;
+                await new Promise((resolve) => {
+                    const timer = setInterval(async () => { if (await check()) {
+                        clearInterval(timer);
+                        resolve();
+                    } }, intervalMs);
+                });
+                return;
+            }
+            // Track mode
+            if (opts.track) {
+                if (!sym) {
+                    console.log(chalk.red("  --track requires --symbol or -s"));
+                    return;
+                }
+                const durationMs = parseInt(opts.duration) * 60 * 1000;
+                const endTime = Date.now() + durationMs;
+                const samples = [];
+                if (!isJson()) {
+                    console.log(chalk.cyan.bold(`\n  Tracking ${sym} price gap\n`));
+                    console.log(`  Duration:  ${opts.duration} min`);
+                    console.log(`  Interval:  ${opts.interval}s`);
+                    console.log(chalk.gray("  Collecting samples...\n"));
+                }
+                const sample = async () => {
+                    const snapshots = await fetchAllPrices();
+                    const s = snapshots.find((x) => x.symbol === sym);
+                    if (!s) {
+                        console.log(chalk.gray(`  ${new Date().toLocaleTimeString()} — ${sym} not found on both exchanges`));
+                        return;
+                    }
+                    samples.push({ time: new Date().toLocaleTimeString(), gap: s.maxGap, gapPct: s.maxGapPct, direction: `${s.cheapest}→${s.expensive}` });
+                    const gapColor = s.maxGapPct >= 0.1 ? chalk.yellow : chalk.gray;
+                    const parts = [`PAC: ${s.pacPrice !== null ? "$" + formatGapPrice(s.pacPrice) : "-"}`];
+                    parts.push(`HL: ${s.hlPrice !== null ? "$" + formatGapPrice(s.hlPrice) : "-"}`);
+                    parts.push(`LT: ${s.ltPrice !== null ? "$" + formatGapPrice(s.ltPrice) : "-"}`);
+                    console.log(`  ${chalk.white(s.symbol.padEnd(6))} ${parts.join("  ")}  ${gapColor(`${s.maxGapPct.toFixed(4)}%`)}  ${s.cheapest}→${s.expensive}`);
+                };
+                await sample();
+                const timer = setInterval(async () => { if (Date.now() >= endTime) {
+                    clearInterval(timer);
+                    printTrackSummary(sym, samples);
+                    return;
+                } await sample(); }, intervalMs);
+                await new Promise((resolve) => { setTimeout(resolve, durationMs + 1000); });
+                return;
+            }
+            // Gaps snapshot (default for --gaps without --live)
+            if (!isJson())
+                console.log(chalk.cyan("\n  Fetching prices from Pacifica, Hyperliquid & Lighter...\n"));
+            let snapshots = await fetchAllPrices();
+            if (sym)
+                snapshots = snapshots.filter((s) => s.symbol.includes(sym));
+            if (opts.top)
+                snapshots = snapshots.slice(0, parseInt(opts.top));
+            if (isJson())
+                return printJson(jsonOk(snapshots.filter((s) => s.maxGapPct >= minGap)));
+            printGapTable(snapshots, minGap);
+            return;
+        }
+        // ── Live monitoring mode ──
+        if (opts.live) {
+            // If --hip3, route to dex monitor
+            if (opts.hip3) {
+                return handleDexMonitor({ ...opts, top: opts.top ?? "15" });
+            }
+            // Perp-perp live funding spread monitor
+            const minSpread = parseFloat(opts.min);
+            const intervalSec = parseInt(opts.interval);
+            const topN = parseInt(opts.top ?? "15");
+            const checkLiq = opts.checkLiquidity ?? false;
+            const holdDays = parseFloat(opts.holdDays);
+            const bridgeCostUsd = parseFloat(opts.bridgeCost);
+            const sizeUsd = parseFloat(opts.size);
+            let cycle = 0;
+            if (!isJson()) {
+                console.log(chalk.cyan.bold("\n  Funding Arb Monitor"));
+                console.log(chalk.gray(`  Min spread: ${minSpread}% | Refresh: ${intervalSec}s | Top: ${topN}`));
+                console.log(chalk.gray(`  Net spread: ${holdDays}d hold, $${bridgeCostUsd} bridge, $${sizeUsd} size`));
+                if (checkLiq)
+                    console.log(chalk.gray(`  Liquidity check: ON`));
+                console.log(chalk.gray(`  Press Ctrl+C to stop\n`));
+            }
+            const exAbbr = (e) => e === "pacifica" ? "PAC" : e === "hyperliquid" ? "HL" : "LT";
+            while (true) {
+                cycle++;
+                const ts = new Date().toLocaleTimeString();
+                try {
+                    const spreads = await fetchFundingSpreads();
+                    const filtered = spreads.filter(s => Math.abs(s.spread) >= minSpread).slice(0, topN);
+                    if (cycle > 1) {
+                        const linesToClear = filtered.length + 4;
+                        process.stdout.write(`\x1b[${linesToClear}A\x1b[J`);
+                    }
+                    console.log(chalk.gray(`  ${ts} — Cycle ${cycle} | ${filtered.length} opportunities >= ${minSpread}%\n`));
+                    if (filtered.length === 0) {
+                        console.log(chalk.gray(`  No opportunities found.\n`));
+                    }
+                    else {
+                        const liqData = new Map();
+                        if (checkLiq && filtered.length > 0) {
+                            const topCheck = filtered.slice(0, 5);
+                            await Promise.allSettled(topCheck.map(async (s) => {
+                                try {
+                                    const [hlOB, ltOB] = await Promise.all([fetchHLOrderbook(s.symbol), fetchLighterOrderbook(s.symbol)]);
+                                    const hlDepth = hlOB.reduce((sum, l) => sum + l[0] * l[1], 0);
+                                    const ltDepth = ltOB.reduce((sum, l) => sum + l[0] * l[1], 0);
+                                    const hlBest = hlOB[0]?.[0] ?? 0;
+                                    const ltBest = ltOB[0]?.[0] ?? 0;
+                                    const gap = hlBest && ltBest ? (Math.abs(hlBest - ltBest) / Math.min(hlBest, ltBest) * 100).toFixed(3) : "?";
+                                    liqData.set(s.symbol, { hlDepth: Math.round(hlDepth), ltDepth: Math.round(ltDepth), gap });
+                                }
+                                catch { /* skip */ }
+                            }));
+                        }
+                        for (const s of filtered) {
+                            const direction = `${exAbbr(s.shortExch)}>${exAbbr(s.longExch)}`;
+                            const grossSpread = Math.abs(s.spread);
+                            const rtCost = computeRoundTripCostPct(s.longExch, s.shortExch);
+                            const netSpread = computeNetSpread(grossSpread, holdDays, rtCost, bridgeCostUsd, sizeUsd);
+                            const grossColor = grossSpread >= 50 ? chalk.green.bold : grossSpread >= 30 ? chalk.green : chalk.yellow;
+                            const netColor = netSpread >= 20 ? chalk.green : netSpread >= 0 ? chalk.yellow : chalk.red;
+                            const rates = [];
+                            if (s.pacRate)
+                                rates.push(`PAC:${(s.pacRate * 100).toFixed(4)}%`);
+                            if (s.hlRate)
+                                rates.push(`HL:${(s.hlRate * 100).toFixed(4)}%`);
+                            if (s.ltRate)
+                                rates.push(`LT:${(s.ltRate * 100).toFixed(4)}%`);
+                            let liqInfo = "";
+                            const ld = liqData.get(s.symbol);
+                            if (ld)
+                                liqInfo = chalk.gray(` | depth: HL $${ld.hlDepth.toLocaleString()} LT $${ld.ltDepth.toLocaleString()} gap:${ld.gap}%`);
+                            console.log(`  ${chalk.white.bold(s.symbol.padEnd(8))} ` +
+                                `${grossColor(`${grossSpread.toFixed(1)}%`.padEnd(8))} ` +
+                                `${netColor(`net:${netSpread.toFixed(1)}%`.padEnd(12))} ` +
+                                `${direction.padEnd(7)} ` +
+                                rates.join(" ") + liqInfo);
+                        }
+                        console.log(chalk.gray(`  * Net spreads are predicted estimates (${holdDays}d hold, $${bridgeCostUsd} bridge)`));
+                        console.log();
+                    }
+                }
+                catch (err) {
+                    console.log(chalk.red(`  ${ts} Error: ${err instanceof Error ? err.message : err}\n`));
+                }
+                await new Promise(r => setTimeout(r, intervalSec * 1000));
+            }
+        }
+        // Route to specialized handlers
+        if (opts.compare)
+            return handleCompare(isJson, opts.compare);
+        if (opts.rates)
+            return handleRates(isJson, { symbol: opts.symbol, symbols: opts.symbols, all: opts.all, minSpread: opts.min });
+        if (opts.basis)
+            return handleBasisScan(isJson, { minBasis: opts.min, symbol: typeof opts.basis === "string" ? opts.basis : opts.symbol });
+        if (opts.hip3)
+            return handleDexScan(isJson, { minSpread: opts.min, maxGap: opts.maxGap || "5", includeNative: opts.includeNative !== false, top: opts.top || "20" });
+        if (opts.history)
+            return handleFundingHistory(isJson, { symbol: (typeof opts.history === "string" ? opts.history : opts.symbol) || "ETH", hours: opts.hours || "24", exchange: opts.exchange });
+        if (opts.positions)
+            return handleFundingPositions(isJson, getAdapterForExchange, { exchanges: opts.exchange });
+        // Default: existing scan logic continues below
         const minSpread = parseFloat(opts.min);
         const holdDays = parseFloat(opts.holdDays);
         const bridgeCostUsd = parseFloat(opts.bridgeCost);
@@ -943,27 +1190,29 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
                     console.log(chalk.gray(`  No spot+perp opportunities above ${minSpread}%\n`));
                 }
                 else {
-                    console.log(chalk.gray(`  ${"SYMBOL".padEnd(8)} ${"GROSS".padEnd(8)} ${"NET".padEnd(8)} ${"FEES".padEnd(7)} ${"BE".padEnd(5)} ${"PERP".padEnd(5)} ${"SPOT".padEnd(8)} DIRECTION`));
-                    for (const s of spotSpreads.slice(0, parseInt(opts.top ?? "30"))) {
+                    const exAbbr = (e) => e === "pacifica" ? "PAC" : e === "hyperliquid" ? "HL" : "LT";
+                    const rows = spotSpreads.slice(0, parseInt(opts.top ?? "30")).map(s => {
                         const spotEx = s.spotExchanges[0] || "lighter";
                         const rtCost = computeRoundTripCostPct(spotEx, s.perpExchange);
                         const effectiveBridgeCost = s.spotExchanges.includes(s.perpExchange) ? 0 : bridgeCostUsd;
                         const netSpread = computeNetSpread(s.annualSpreadPct, holdDays, rtCost, effectiveBridgeCost, sizeUsd);
                         const breakEvenDays = rtCost > 0 ? Math.ceil(rtCost / (s.annualSpreadPct / 365)) : 0;
-                        const grossColor = s.annualSpreadPct >= 30 ? chalk.green : chalk.yellow;
+                        const grossColor = s.annualSpreadPct >= 50 ? chalk.green.bold : s.annualSpreadPct >= 30 ? chalk.green : chalk.yellow;
                         const netColor = netSpread >= 20 ? chalk.green : netSpread >= 0 ? chalk.yellow : chalk.red;
                         const dir = s.direction === "long-spot-short-perp" ? "Spot+Short" : "Sell+Long";
-                        const exAbbr = (e) => e === "pacifica" ? "PAC" : e === "hyperliquid" ? "HL" : "LT";
-                        console.log(`  ${chalk.white.bold(s.symbol.padEnd(8))} ` +
-                            `${grossColor(`${s.annualSpreadPct.toFixed(1)}%`.padEnd(8))} ` +
-                            `${netColor(`${netSpread.toFixed(1)}%`.padEnd(8))} ` +
-                            `${chalk.gray(`${rtCost.toFixed(2)}%`.padEnd(7))} ` +
-                            `${chalk.gray(`${breakEvenDays}d`.padEnd(5))} ` +
-                            `${exAbbr(s.perpExchange).padEnd(5)} ` +
-                            `${s.spotExchanges.map(exAbbr).join(",").padEnd(8)} ` +
-                            dir);
-                    }
-                    console.log(chalk.gray(`\n  ${spotSpreads.length} spot+perp opportunities (spot funding = 0%)`));
+                        return [
+                            chalk.white.bold(s.symbol),
+                            grossColor(`${s.annualSpreadPct.toFixed(1)}%`),
+                            netColor(`${netSpread.toFixed(1)}%`),
+                            chalk.gray(`${rtCost.toFixed(2)}%`),
+                            chalk.gray(`${breakEvenDays}d`),
+                            exAbbr(s.perpExchange),
+                            s.spotExchanges.map(exAbbr).join(","),
+                            dir,
+                        ];
+                    });
+                    console.log(makeTable(["Symbol", "Gross", "Net", "Fees", "BE", "Perp", "Spot", "Direction"], rows));
+                    console.log(chalk.gray(`  ${spotSpreads.length} spot+perp opportunities (spot funding = 0%)`));
                     console.log(chalk.gray(`  Net spread assumes ${holdDays}d hold, $${bridgeCostUsd} bridge, $${sizeUsd} size. BE = break-even days`));
                 }
             }
@@ -1012,17 +1261,14 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
             console.log(chalk.gray(`  No perp-perp spreads above ${minSpread}%\n`));
             return;
         }
-        // Header
-        console.log(chalk.gray(`  ${"SYMBOL".padEnd(8)} ${"GROSS".padEnd(8)} ${"NET".padEnd(8)} ${"FEES".padEnd(7)} ${"GAP".padEnd(8)} ${"DIR".padEnd(7)} RATES`));
-        for (const s of filtered) {
-            const exAbbr = (e) => e === "pacifica" ? "PAC" : e === "hyperliquid" ? "HL" : "LT";
+        const exAbbr = (e) => e === "pacifica" ? "PAC" : e === "hyperliquid" ? "HL" : "LT";
+        const rows = filtered.map(s => {
             const direction = `${exAbbr(s.shortExch)}>${exAbbr(s.longExch)}`;
             const grossSpread = Math.abs(s.spread);
             const rtCost = computeRoundTripCostPct(s.longExch, s.shortExch);
             const netSpread = computeNetSpread(grossSpread, holdDays, rtCost, bridgeCostUsd, sizeUsd);
-            const grossColor = grossSpread >= 30 ? chalk.green : chalk.yellow;
+            const grossColor = grossSpread >= 50 ? chalk.green.bold : grossSpread >= 30 ? chalk.green : chalk.yellow;
             const netColor = netSpread >= 20 ? chalk.green : netSpread >= 0 ? chalk.yellow : chalk.red;
-            // Price gap between long/short exchanges
             const longPrice = s.longExch === "pacifica" ? s.pacMarkPrice : s.longExch === "hyperliquid" ? s.hlMarkPrice : s.ltMarkPrice;
             const shortPrice = s.shortExch === "pacifica" ? s.pacMarkPrice : s.shortExch === "hyperliquid" ? s.hlMarkPrice : s.ltMarkPrice;
             const mid = (longPrice + shortPrice) / 2;
@@ -1035,15 +1281,18 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
                 rates.push(`HL:${(s.hlRate * 100).toFixed(4)}%`);
             if (s.ltRate)
                 rates.push(`LT:${(s.ltRate * 100).toFixed(4)}%`);
-            console.log(`  ${chalk.white.bold(s.symbol.padEnd(8))} ` +
-                `${grossColor(`${grossSpread.toFixed(1)}%`.padEnd(8))} ` +
-                `${netColor(`${netSpread.toFixed(1)}%`.padEnd(8))} ` +
-                `${chalk.gray(`${rtCost.toFixed(2)}%`.padEnd(7))} ` +
-                `${gapColor(`${priceGapPct.toFixed(3)}%`.padEnd(8))} ` +
-                `${direction.padEnd(7)} ` +
-                rates.join(" "));
-        }
-        console.log(chalk.gray(`\n  ${filtered.length} opportunities above ${minSpread}% gross annual spread`));
+            return [
+                chalk.white.bold(s.symbol),
+                grossColor(`${grossSpread.toFixed(1)}%`),
+                netColor(`${netSpread.toFixed(1)}%`),
+                chalk.gray(`${rtCost.toFixed(2)}%`),
+                gapColor(`${priceGapPct.toFixed(3)}%`),
+                direction,
+                rates.join(" "),
+            ];
+        });
+        console.log(makeTable(["Symbol", "Gross", "Net", "Fees", "Gap", "Dir", "Rates"], rows));
+        console.log(chalk.gray(`  ${filtered.length} opportunities above ${minSpread}% gross annual spread`));
         console.log(chalk.gray(`  Net spread assumes ${holdDays}d hold, $${bridgeCostUsd} bridge cost, $${sizeUsd} size`));
         console.log(chalk.gray(`  * Spreads are estimates based on current rates — actual may vary`));
         console.log(chalk.gray(`  Use 'perp arb auto --min-spread ${minSpread}' to auto-trade\n`));
@@ -1051,19 +1300,27 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
     // ── arb exec ── (validate orderbook + simultaneous dual-leg entry)
     arb
         .command("exec")
-        .description("Execute arb: validate orderbook depth on both exchanges, then enter both legs simultaneously")
+        .description("Execute arb: validate orderbook depth, then enter both legs simultaneously. Use spot:<exch> for spot+perp mode.")
         .argument("<symbol>", "Symbol (e.g. BTC, ETH, ICP)")
-        .argument("<longExch>", "Exchange to go LONG on (hl, pac, lighter)")
+        .argument("<longExch>", "Exchange to go LONG on (hl, pac, lighter, or spot:hl / spot:lt for spot+perp)")
         .argument("<shortExch>", "Exchange to go SHORT on (hl, pac, lighter)")
         .argument("<sizeUsd>", "Position size per leg in USD")
         .option("--max-slippage <pct>", "Max slippage % per leg", "0.5")
         .option("--leverage <n>", "Set leverage before entry (both exchanges)")
         .option("--isolated", "Use isolated margin mode")
         .option("--smart", "Smart execution: IOC limit at best bid/ask + 1 tick (reduces slippage)")
+        .option("--dry-run", "Simulate without executing trades")
+        .option("--reconcile", "Auto-adjust leg sizes to match after execution (trim larger side)")
         .action(async (symbol, longExch, shortExch, sizeUsdStr, opts) => {
+        // Detect spot: prefix -> route to spot-exec logic
+        if (longExch.startsWith("spot:")) {
+            const spotExch = longExch.slice(5); // extract "hl" from "spot:hl"
+            return handleSpotExec(symbol, spotExch, shortExch, sizeUsdStr, opts);
+        }
         const sym = symbol.toUpperCase();
         const sizeUsd = parseFloat(sizeUsdStr);
         const maxSlippage = parseFloat(opts.maxSlippage);
+        const dryRun = !!opts.dryRun || process.argv.includes("--dry-run");
         // Resolve exchange aliases
         const aliasMap = { hl: "hyperliquid", pac: "pacifica", lt: "lighter" };
         longExch = aliasMap[longExch.toLowerCase()] || longExch.toLowerCase();
@@ -1150,11 +1407,25 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
         const avgPrice = (longCheck.avgFillPrice + shortCheck.avgFillPrice) / 2;
         const matchedUsd = matchedBase * avgPrice;
         if (!isJson()) {
-            console.log(chalk.cyan(`\n  Arb Exec: ${sym}${opts.smart ? " (smart order)" : ""}`));
+            console.log(chalk.cyan(`\n  Arb Exec: ${sym}${opts.smart ? " (smart order)" : ""}${dryRun ? " [DRY RUN]" : ""}`));
             console.log(chalk.gray(`    LONG  ${longExch}: buy  ${matchedSize} (~$${(matchedBase * longCheck.avgFillPrice).toFixed(2)}, slippage ${longCheck.slippagePct.toFixed(3)}%)`));
             console.log(chalk.gray(`    SHORT ${shortExch}: sell ${matchedSize} (~$${(matchedBase * shortCheck.avgFillPrice).toFixed(2)}, slippage ${shortCheck.slippagePct.toFixed(3)}%)`));
-            console.log(chalk.gray(`    Executing both legs simultaneously...\n`));
         }
+        // 4b. Dry-run: return simulated result without executing
+        if (dryRun) {
+            const result = {
+                status: "filled", symbol: sym, dryRun: true,
+                size: matchedSize, notionalUsd: Math.round(matchedUsd * 100) / 100,
+                long: { exchange: longExch, side: "buy", size: matchedSize, slippagePct: longCheck.slippagePct },
+                short: { exchange: shortExch, side: "sell", size: matchedSize, slippagePct: shortCheck.slippagePct },
+            };
+            if (isJson())
+                return printJson(jsonOk(result));
+            console.log(chalk.yellow(`\n    [DRY RUN] Would execute: long ${matchedSize} on ${longExch} + short ${matchedSize} on ${shortExch} (~$${matchedUsd.toFixed(2)})\n`));
+            return;
+        }
+        if (!isJson())
+            console.log(chalk.gray(`    Executing both legs simultaneously...\n`));
         // 5. Execute both legs simultaneously
         const execLong = opts.smart
             ? smartOrder(longAdapter, sym, "buy", matchedSize).then(r => r.result)
@@ -1197,22 +1468,79 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
                 console.log(chalk.yellow(`  Rolled back ${openSide} leg. Check exchange min order sizes.\n`));
                 return;
             }
+            // 7. Verify fill sizes match expected
+            const expectedSize = parseFloat(matchedSize);
+            const longFilled = Number(longPos.size);
+            const shortFilled = Number(shortPos.size);
+            const fillWarnings = [];
+            if (longFilled < expectedSize * 0.5)
+                fillWarnings.push(`Long fill ${longPos.size} < expected ${matchedSize} — partial fill?`);
+            if (shortFilled < expectedSize * 0.5)
+                fillWarnings.push(`Short fill ${shortPos.size} < expected ${matchedSize} — partial fill?`);
+            // Size mismatch between legs
+            const sizeDiffPct = Math.abs(longFilled - shortFilled) / Math.max(longFilled, shortFilled) * 100;
+            if (sizeDiffPct > 5)
+                fillWarnings.push(`Leg size mismatch: long ${longPos.size} vs short ${shortPos.size} (${sizeDiffPct.toFixed(1)}% diff)`);
+            // 8. Reconcile — trim larger leg to match smaller
+            let reconciled = false;
+            let reconciledSize = "";
+            if (opts.reconcile && sizeDiffPct > 1 && longFilled > 0 && shortFilled > 0) {
+                const targetSize = Math.min(longFilled, shortFilled);
+                const trimSide = longFilled > shortFilled ? "long" : "short";
+                const trimAdapter = trimSide === "long" ? longAdapter : shortAdapter;
+                const trimAction = trimSide === "long" ? "sell" : "buy"; // reduce long = sell, reduce short = buy
+                const excess = Math.abs(longFilled - shortFilled);
+                const trimDecimals = matchedSize.includes(".") ? matchedSize.split(".")[1].length : 0;
+                const excessStr = excess.toFixed(trimDecimals);
+                if (!isJson())
+                    console.log(chalk.cyan(`    Reconciling: ${trimSide} has ${excess.toFixed(trimDecimals)} excess → trimming...`));
+                try {
+                    if (opts.smart) {
+                        await smartOrder(trimAdapter, sym, trimAction, excessStr, { reduceOnly: true });
+                    }
+                    else {
+                        await trimAdapter.marketOrder(sym, trimAction, excessStr);
+                    }
+                    reconciled = true;
+                    reconciledSize = targetSize.toFixed(trimDecimals);
+                    fillWarnings.length = 0; // clear mismatch warnings
+                    if (!isJson())
+                        console.log(chalk.green(`    Reconciled: both legs now ~${reconciledSize} units`));
+                }
+                catch (reconErr) {
+                    const msg = reconErr instanceof Error ? reconErr.message : String(reconErr);
+                    fillWarnings.push(`Reconcile failed (${trimSide} trim): ${msg}`);
+                    if (!isJson())
+                        console.log(chalk.yellow(`    Reconcile failed: ${msg}`));
+                }
+            }
+            const fillStatus = fillWarnings.length > 0 ? "filled_unverified" : "filled";
+            const finalSize = reconciled ? reconciledSize : matchedSize;
             logExecution({
                 type: "arb_entry", exchange: `${longExch}+${shortExch}`,
-                symbol: sym, side: "entry", size: matchedSize,
-                status: "success", dryRun: false,
-                meta: { longExch, shortExch, matchedUsd, longSlippage: longCheck.slippagePct, shortSlippage: shortCheck.slippagePct },
+                symbol: sym, side: "entry", size: finalSize,
+                status: fillWarnings.length > 0 ? "unverified" : "success", dryRun: false,
+                meta: { longExch, shortExch, matchedUsd, longSlippage: longCheck.slippagePct, shortSlippage: shortCheck.slippagePct, reconciled, ...(fillWarnings.length > 0 && { warnings: fillWarnings }) },
             });
             const result = {
-                status: "filled", symbol: sym, size: matchedSize, notionalUsd: Math.round(matchedUsd * 100) / 100,
-                long: { exchange: longExch, side: "buy", size: longPos.size, slippagePct: longCheck.slippagePct },
-                short: { exchange: shortExch, side: "sell", size: shortPos.size, slippagePct: shortCheck.slippagePct },
+                status: fillStatus, symbol: sym, size: finalSize, notionalUsd: Math.round(matchedUsd * 100) / 100,
+                long: { exchange: longExch, side: "buy", size: reconciled ? reconciledSize : longPos.size, slippagePct: longCheck.slippagePct },
+                short: { exchange: shortExch, side: "sell", size: reconciled ? reconciledSize : shortPos.size, slippagePct: shortCheck.slippagePct },
+                ...(reconciled && { reconciled: true }),
+                ...(fillWarnings.length > 0 && { warnings: fillWarnings }),
             };
             if (isJson())
                 return printJson(jsonOk(result));
-            console.log(chalk.green(`  FILLED: ${sym} ${matchedSize} units (~$${matchedUsd.toFixed(2)})`));
-            console.log(chalk.green(`    LONG  ${longExch} ✓ (${longPos.size})`));
-            console.log(chalk.green(`    SHORT ${shortExch} ✓ (${shortPos.size})\n`));
+            if (fillWarnings.length > 0) {
+                console.log(chalk.yellow(`  FILLED (unverified): ${sym} ${finalSize} units (~$${matchedUsd.toFixed(2)})`));
+                for (const w of fillWarnings)
+                    console.log(chalk.yellow(`    ⚠ ${w}`));
+            }
+            else {
+                console.log(chalk.green(`  FILLED${reconciled ? " (reconciled)" : ""}: ${sym} ${finalSize} units (~$${matchedUsd.toFixed(2)})`));
+            }
+            console.log(chalk.green(`    LONG  ${longExch} ✓ (${reconciled ? reconciledSize : longPos.size})`));
+            console.log(chalk.green(`    SHORT ${shortExch} ✓ (${reconciled ? reconciledSize : shortPos.size})\n`));
         }
         else if (longOk !== shortOk) {
             // One leg failed — rollback
@@ -1272,19 +1600,8 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
             console.log(chalk.red(`    SHORT: ${result.shortError}\n`));
         }
     });
-    // ── arb spot-exec ── (spot+perp arb execution)
-    arb
-        .command("spot-exec")
-        .description("Execute spot+perp arb: buy spot + short perp simultaneously")
-        .argument("<symbol>", "Symbol (e.g. ETH, BTC)")
-        .argument("<spotExch>", "Spot exchange: hl (Hyperliquid) or lt (Lighter)")
-        .argument("<perpExch>", "Perp exchange: hl, lt, pac")
-        .argument("<sizeUsd>", "Position size per leg in USD")
-        .option("--max-slippage <pct>", "Max slippage % per leg", "0.5")
-        .option("--leverage <n>", "Set leverage on perp side before entry")
-        .option("--isolated", "Use isolated margin mode on perp side")
-        .option("--dry-run", "Simulate without executing trades")
-        .action(async (symbol, spotExch, perpExch, sizeUsdStr, opts) => {
+    // ── spot-exec logic (called from exec when longExch starts with "spot:") ──
+    async function handleSpotExec(symbol, spotExch, perpExch, sizeUsdStr, opts) {
         const sym = symbol.toUpperCase();
         const sizeUsd = parseFloat(sizeUsdStr);
         const maxSlippage = parseFloat(opts.maxSlippage);
@@ -1692,25 +2009,19 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
             console.log(chalk.red(`    SPOT:  ${result.spotError}`));
             console.log(chalk.red(`    PERP:  ${result.perpError}\n`));
         }
-    });
-    // ── arb spot-close ── (close spot+perp arb position)
-    arb
-        .command("spot-close")
-        .description("Close a spot+perp arb position: sell spot + buy back perp")
-        .argument("<symbol>", "Symbol (e.g. ETH)")
-        .option("--spot-exch <exchange>", "Spot exchange (hl or lt)")
-        .option("--perp-exch <exchange>", "Perp exchange (hl, lt, pac)")
-        .action(async (symbol, opts) => {
-        const sym = symbol.toUpperCase();
+    }
+    // ── Expose spot-close handler for consolidated "arb close" in arb/index.ts ──
+    handleSpotClose = async (sym_arg, opts_arg, getAdapter, isJsonFn) => {
+        const sym = sym_arg.toUpperCase();
         // Try to find the position from state
         const state = loadArbState();
         const pos = state?.positions.find(p => p.symbol.toUpperCase() === sym && p.mode === "spot-perp");
         const aliasMap = { hl: "hyperliquid", pac: "pacifica", lt: "lighter" };
-        const spotExch = aliasMap[opts.spotExch?.toLowerCase() ?? ""] || opts.spotExch?.toLowerCase() || pos?.spotExchange || pos?.longExchange;
-        const perpExch = aliasMap[opts.perpExch?.toLowerCase() ?? ""] || opts.perpExch?.toLowerCase() || pos?.shortExchange;
+        const spotExch = aliasMap[opts_arg.spotExch?.toLowerCase() ?? ""] || opts_arg.spotExch?.toLowerCase() || pos?.spotExchange || pos?.longExchange;
+        const perpExch = aliasMap[opts_arg.perpExch?.toLowerCase() ?? ""] || opts_arg.perpExch?.toLowerCase() || pos?.shortExchange;
         if (!spotExch || !perpExch) {
             const msg = "Cannot determine exchanges. Specify --spot-exch and --perp-exch, or ensure the position is tracked in state.";
-            if (isJson())
+            if (isJsonFn())
                 return printJson(jsonOk({ error: msg }));
             console.log(chalk.red(`  ${msg}`));
             return;
@@ -1720,31 +2031,31 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
         const { LighterSpotAdapter } = await import("../exchanges/lighter-spot.js");
         let spotAdapter;
         if (spotExch === "hyperliquid") {
-            const hlAdapter = await getAdapterForExchange("hyperliquid");
+            const hlAdapter = await getAdapter("hyperliquid");
             const hlSpot = new HyperliquidSpotAdapter(hlAdapter);
             await hlSpot.init();
             spotAdapter = hlSpot;
         }
         else {
-            const ltAdapter = await getAdapterForExchange("lighter");
+            const ltAdapter = await getAdapter("lighter");
             const ltSpot = new LighterSpotAdapter(ltAdapter);
             await ltSpot.init();
             spotAdapter = ltSpot;
         }
-        const perpAdapter = await getAdapterForExchange(perpExch);
+        const perpAdapter = await getAdapter(perpExch);
         const spotSymbol = `${sym}/USDC`;
         // Find how much to close
         const perpPositions = await perpAdapter.getPositions();
         const perpPos = perpPositions.find(p => p.symbol.replace("-PERP", "").toUpperCase() === sym && p.side === "short");
         if (!perpPos) {
             const msg = `No short perp position found for ${sym} on ${perpExch}`;
-            if (isJson())
+            if (isJsonFn())
                 return printJson(jsonOk({ error: msg }));
             console.log(chalk.red(`  ${msg}`));
             return;
         }
         const closeSize = perpPos.size;
-        if (!isJson()) {
+        if (!isJsonFn()) {
             console.log(chalk.cyan(`\n  Closing Spot+Perp Arb: ${sym}`));
             console.log(chalk.gray(`    SPOT  ${spotExch}: sell ${closeSize}`));
             console.log(chalk.gray(`    PERP  ${perpExch}: buy  ${closeSize} (close short)`));
@@ -1819,7 +2130,7 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
                     const leftover = Number(usdcBal?.available ?? 0);
                     if (leftover > 0.01) {
                         await ltSpot.transferUsdcToPerp(leftover);
-                        if (!isJson())
+                        if (!isJsonFn())
                             console.log(chalk.gray(`  Returned ~$${leftover.toFixed(2)} USDC spot→perp on Lighter`));
                     }
                 }
@@ -1842,7 +2153,7 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
                 mode: "spot-perp", symbol: sym, size: closeSize,
                 ...(closeWarnings.length > 0 && { warnings: closeWarnings }),
             };
-            if (isJson())
+            if (isJsonFn())
                 return printJson(jsonOk(closeResult));
             if (closeVerified) {
                 console.log(chalk.green(`  CLOSED (verified): ${sym} ${closeSize} units`));
@@ -1860,19 +2171,16 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
             if (!perpOk)
                 errors.push(`Perp buy failed: ${perpResult.reason}`);
             const result = { status: "partial_close", symbol: sym, spotOk, perpOk, errors };
-            if (isJson())
+            if (isJsonFn())
                 return printJson(jsonOk(result));
             console.log(chalk.red(`  Close partially failed:`));
             for (const e of errors)
                 console.log(chalk.red(`    ${e}`));
             console.log(chalk.yellow(`  Manual intervention may be needed.\n`));
         }
-    });
-    // ── arb pnl ── (check arb position PnL)
-    arb
-        .command("pnl")
-        .description("Check PnL of current arb positions across exchanges")
-        .action(async () => {
+    };
+    // ── arb pnl logic (extracted as inner function, no command registration) ──
+    async function _handleArbPnl() {
         if (!isJson())
             console.log(chalk.cyan("\n  Checking arb positions...\n"));
         const exchangeNames = ["hyperliquid", "lighter", "pacifica"];
@@ -2022,125 +2330,9 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
         console.log(`    Net (if closed now): ${netColor(`$${netPnl.toFixed(4)}`)}`);
         console.log(chalk.gray(`    (Fees assume ${(TAKER_FEE * 100).toFixed(3)}% taker. Actual may vary.)`));
         console.log(chalk.gray(`    * Net includes actual settled funding where available.\n`));
-    });
-    // ── arb monitor ── (live monitoring with liquidity)
-    arb
-        .command("monitor")
-        .description("Live-monitor funding spreads with liquidity data")
-        .option("--min <pct>", "Min annual spread to show", "20")
-        .option("--interval <sec>", "Refresh interval in seconds", "60")
-        .option("--top <n>", "Show top N opportunities", "15")
-        .option("--check-liquidity", "Check orderbook depth (slower)")
-        .option("--hold-days <days>", "Expected hold period for net spread calc", "7")
-        .option("--bridge-cost <usd>", "One-way bridge cost in USD", "0.5")
-        .option("--size <usd>", "Position size per leg ($) for cost calc", "100")
-        .action(async (opts) => {
-        const minSpread = parseFloat(opts.min);
-        const intervalSec = parseInt(opts.interval);
-        const topN = parseInt(opts.top);
-        const checkLiq = opts.checkLiquidity ?? false;
-        const holdDays = parseFloat(opts.holdDays);
-        const bridgeCostUsd = parseFloat(opts.bridgeCost);
-        const sizeUsd = parseFloat(opts.size);
-        let cycle = 0;
-        if (!isJson()) {
-            console.log(chalk.cyan.bold("\n  Funding Arb Monitor"));
-            console.log(chalk.gray(`  Min spread: ${minSpread}% | Refresh: ${intervalSec}s | Top: ${topN}`));
-            console.log(chalk.gray(`  Net spread: ${holdDays}d hold, $${bridgeCostUsd} bridge, $${sizeUsd} size`));
-            if (checkLiq)
-                console.log(chalk.gray(`  Liquidity check: ON`));
-            console.log(chalk.gray(`  Press Ctrl+C to stop\n`));
-        }
-        const exAbbr = (e) => e === "pacifica" ? "PAC" : e === "hyperliquid" ? "HL" : "LT";
-        while (true) {
-            cycle++;
-            const ts = new Date().toLocaleTimeString();
-            try {
-                const spreads = await fetchFundingSpreads();
-                const filtered = spreads
-                    .filter(s => Math.abs(s.spread) >= minSpread)
-                    .slice(0, topN);
-                // Clear previous output (move cursor up)
-                if (cycle > 1) {
-                    const linesToClear = filtered.length + 4;
-                    process.stdout.write(`\x1b[${linesToClear}A\x1b[J`);
-                }
-                console.log(chalk.gray(`  ${ts} — Cycle ${cycle} | ${filtered.length} opportunities >= ${minSpread}%\n`));
-                if (filtered.length === 0) {
-                    console.log(chalk.gray(`  No opportunities found.\n`));
-                }
-                else {
-                    // Optionally check liquidity for top entries
-                    const liqData = new Map();
-                    if (checkLiq && filtered.length > 0) {
-                        const topCheck = filtered.slice(0, 5); // check liquidity for top 5 only
-                        await Promise.allSettled(topCheck.map(async (s) => {
-                            try {
-                                const [hlOB, ltOB] = await Promise.all([
-                                    fetchHLOrderbook(s.symbol),
-                                    fetchLighterOrderbook(s.symbol),
-                                ]);
-                                const hlDepth = hlOB.reduce((sum, l) => sum + l[0] * l[1], 0);
-                                const ltDepth = ltOB.reduce((sum, l) => sum + l[0] * l[1], 0);
-                                // Price gap between best ask (buy side) and best bid (sell side)
-                                const hlBest = hlOB[0]?.[0] ?? 0;
-                                const ltBest = ltOB[0]?.[0] ?? 0;
-                                const gap = hlBest && ltBest
-                                    ? (Math.abs(hlBest - ltBest) / Math.min(hlBest, ltBest) * 100).toFixed(3)
-                                    : "?";
-                                liqData.set(s.symbol, { hlDepth: Math.round(hlDepth), ltDepth: Math.round(ltDepth), gap });
-                            }
-                            catch { /* skip */ }
-                        }));
-                    }
-                    for (const s of filtered) {
-                        const direction = `${exAbbr(s.shortExch)}>${exAbbr(s.longExch)}`;
-                        const grossSpread = Math.abs(s.spread);
-                        const rtCost = computeRoundTripCostPct(s.longExch, s.shortExch);
-                        const netSpread = computeNetSpread(grossSpread, holdDays, rtCost, bridgeCostUsd, sizeUsd);
-                        const grossColor = grossSpread >= 50 ? chalk.green.bold
-                            : grossSpread >= 30 ? chalk.green
-                                : chalk.yellow;
-                        const netColor = netSpread >= 20 ? chalk.green : netSpread >= 0 ? chalk.yellow : chalk.red;
-                        const rates = [];
-                        if (s.pacRate)
-                            rates.push(`PAC:${(s.pacRate * 100).toFixed(4)}%`);
-                        if (s.hlRate)
-                            rates.push(`HL:${(s.hlRate * 100).toFixed(4)}%`);
-                        if (s.ltRate)
-                            rates.push(`LT:${(s.ltRate * 100).toFixed(4)}%`);
-                        let liqInfo = "";
-                        const ld = liqData.get(s.symbol);
-                        if (ld) {
-                            liqInfo = chalk.gray(` | depth: HL $${ld.hlDepth.toLocaleString()} LT $${ld.ltDepth.toLocaleString()} gap:${ld.gap}%`);
-                        }
-                        console.log(`  ${chalk.white.bold(s.symbol.padEnd(8))} ` +
-                            `${grossColor(`${grossSpread.toFixed(1)}%`.padEnd(8))} ` +
-                            `${netColor(`net:${netSpread.toFixed(1)}%`.padEnd(12))} ` +
-                            `${direction.padEnd(7)} ` +
-                            rates.join(" ") +
-                            liqInfo);
-                    }
-                    console.log(chalk.gray(`  * Net spreads are predicted estimates (${holdDays}d hold, $${bridgeCostUsd} bridge)`));
-                    console.log();
-                }
-            }
-            catch (err) {
-                console.log(chalk.red(`  ${ts} Error: ${err instanceof Error ? err.message : err}\n`));
-            }
-            await new Promise(r => setTimeout(r, intervalSec * 1000));
-        }
-    });
-    // ── arb dex-monitor ── (live HIP-3 cross-dex monitoring)
-    arb
-        .command("dex-monitor")
-        .description("Live-monitor HIP-3 cross-dex funding arb opportunities")
-        .option("--min <pct>", "Min annual spread to show", "10")
-        .option("--interval <sec>", "Refresh interval in seconds", "60")
-        .option("--top <n>", "Show top N opportunities", "20")
-        .option("--include-native", "Include native HL perps", true)
-        .option("--no-include-native", "Exclude native HL perps")
-        .action(async (opts) => {
+    }
+    // ── dex-monitor logic (accessed via 'arb scan --live --hip3') ──
+    async function handleDexMonitor(opts) {
         const minSpread = parseFloat(opts.min);
         const intervalSec = parseInt(opts.interval);
         const topN = parseInt(opts.top);
@@ -2199,191 +2391,194 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
             }
             await new Promise(r => setTimeout(r, intervalSec * 1000));
         }
-    });
-    // ── arb dex-auto ── (HIP-3 cross-dex auto arb)
-    if (getHLAdapterForDex) {
-        arb
-            .command("dex-auto")
-            .description("Auto-execute HIP-3 cross-dex funding arb (long low-funding, short high-funding)")
-            .option("--min-spread <pct>", "Min annual spread to enter (%)", "30")
-            .option("--close-spread <pct>", "Close when spread drops below (%)", "5")
-            .option("--size <usd>", "Position size per leg ($)", "100")
-            .option("--max-positions <n>", "Max simultaneous arb positions", "5")
-            .option("--min-oi <usd>", "Min OI (USD) to enter", "50000")
-            .option("--min-grade <grade>", "Min viability grade: A, B, C, D", "C")
-            .option("--interval <seconds>", "Check interval", "120")
-            .option("--dry-run", "Simulate without executing trades")
-            .action(async (opts) => {
-            const minSpread = parseFloat(opts.minSpread);
-            const closeSpread = parseFloat(opts.closeSpread);
-            const sizeUsd = parseFloat(opts.size);
-            const maxPositions = parseInt(opts.maxPositions);
-            const minOi = parseFloat(opts.minOi);
-            const gradeOrder = { A: 0, B: 1, C: 2, D: 3 };
-            const minGradeIdx = gradeOrder[opts.minGrade.toUpperCase()] ?? 2;
-            const intervalMs = parseInt(opts.interval) * 1000;
-            // Check both subcommand option and global/argv (Commander may route --dry-run to parent)
-            const dryRun = !!opts.dryRun || process.argv.includes("--dry-run");
-            const openPositions = [];
-            if (!isJson()) {
-                console.log(chalk.cyan.bold("\n  HIP-3 Cross-Dex Arb Bot\n"));
-                console.log(`  Mode:          ${dryRun ? chalk.yellow("DRY RUN") : chalk.green("LIVE")}`);
-                console.log(`  Enter spread:  >= ${minSpread}% annual`);
-                console.log(`  Close spread:  <= ${closeSpread}% annual`);
-                console.log(`  Size per leg:  $${sizeUsd}`);
-                console.log(`  Max positions: ${maxPositions}`);
-                console.log(`  Min OI:        $${formatUsd(minOi)}`);
-                console.log(`  Min grade:     ${opts.minGrade.toUpperCase()}`);
-                console.log(`  Interval:      ${opts.interval}s`);
-                console.log(chalk.gray("\n  Monitoring... (Ctrl+C to stop)\n"));
-            }
-            const cycle = async () => {
-                try {
-                    const pairs = await scanDexArb({
-                        minAnnualSpread: 0, // get all, filter ourselves
-                        includeNative: true,
-                    });
-                    const now = new Date().toLocaleTimeString();
-                    // Check close conditions
-                    for (let i = openPositions.length - 1; i >= 0; i--) {
-                        const pos = openPositions[i];
-                        // Find current pair for this position
-                        const current = pairs.find(p => p.underlying === pos.underlying &&
-                            ((p.long.dex === pos.longDex && p.short.dex === pos.shortDex) ||
-                                (p.long.dex === pos.shortDex && p.short.dex === pos.longDex)));
-                        const currentSpread = current?.annualSpread ?? 0;
-                        if (currentSpread <= closeSpread || !current) {
-                            const reason = !current ? "pair disappeared" : `spread ${currentSpread.toFixed(1)}% <= ${closeSpread}%`;
-                            if (!isJson())
-                                console.log(chalk.yellow(`  ${now} CLOSE ${pos.underlying} — ${reason}`));
-                            if (!dryRun) {
-                                try {
-                                    const longAdapter = await getHLAdapterForDex(pos.longDex);
-                                    const shortAdapter = await getHLAdapterForDex(pos.shortDex);
-                                    await Promise.all([
-                                        longAdapter.marketOrder(pos.longSymbol, "sell", pos.size),
-                                        shortAdapter.marketOrder(pos.shortSymbol, "buy", pos.size),
-                                    ]);
-                                    logExecution({
-                                        type: "arb_close", exchange: `${pos.longDex}+${pos.shortDex}`,
-                                        symbol: pos.underlying, side: "close", size: String(pos.size),
-                                        status: "success", dryRun: false,
-                                        meta: { longDex: pos.longDex, shortDex: pos.shortDex, reason, longSymbol: pos.longSymbol, shortSymbol: pos.shortSymbol },
-                                    });
-                                    if (!isJson())
-                                        console.log(chalk.green(`  ${now} CLOSED ${pos.underlying} — both legs`));
-                                }
-                                catch (err) {
-                                    logExecution({
-                                        type: "arb_close", exchange: `${pos.longDex}+${pos.shortDex}`,
-                                        symbol: pos.underlying, side: "close", size: String(pos.size),
-                                        status: "failed", dryRun: false,
-                                        error: err instanceof Error ? err.message : String(err),
-                                        meta: { longDex: pos.longDex, shortDex: pos.shortDex },
-                                    });
-                                    if (!isJson())
-                                        console.error(chalk.red(`  ${now} CLOSE FAILED ${pos.underlying}: ${err instanceof Error ? err.message : err}`));
-                                }
+    }
+    // ── dex-auto logic (accessed via 'arb auto --hip3') ── (HIP-3 cross-dex auto arb)
+    async function handleDexAuto(opts) {
+        if (!getHLAdapterForDex) {
+            console.log(chalk.red("  HIP-3 dex adapter not available."));
+            return;
+        }
+        const minSpread = parseFloat(opts.minSpread);
+        const closeSpread = parseFloat(opts.closeSpread);
+        const sizeUsd = parseFloat(opts.size);
+        const maxPositions = parseInt(opts.maxPositions);
+        const minOi = parseFloat(opts.minOi);
+        const gradeOrder = { A: 0, B: 1, C: 2, D: 3 };
+        const minGradeIdx = gradeOrder[opts.minGrade.toUpperCase()] ?? 2;
+        const intervalMs = parseInt(opts.interval) * 1000;
+        // Check both subcommand option and global/argv (Commander may route --dry-run to parent)
+        const dryRun = !!opts.dryRun || process.argv.includes("--dry-run");
+        const openPositions = [];
+        if (!isJson()) {
+            console.log(chalk.cyan.bold("\n  HIP-3 Cross-Dex Arb Bot\n"));
+            console.log(`  Mode:          ${dryRun ? chalk.yellow("DRY RUN") : chalk.green("LIVE")}`);
+            console.log(`  Enter spread:  >= ${minSpread}% annual`);
+            console.log(`  Close spread:  <= ${closeSpread}% annual`);
+            console.log(`  Size per leg:  $${sizeUsd}`);
+            console.log(`  Max positions: ${maxPositions}`);
+            console.log(`  Min OI:        $${formatUsd(minOi)}`);
+            console.log(`  Min grade:     ${opts.minGrade.toUpperCase()}`);
+            console.log(`  Interval:      ${opts.interval}s`);
+            console.log(chalk.gray("\n  Monitoring... (Ctrl+C to stop)\n"));
+        }
+        const cycle = async () => {
+            try {
+                const pairs = await scanDexArb({
+                    minAnnualSpread: 0, // get all, filter ourselves
+                    includeNative: true,
+                });
+                const now = new Date().toLocaleTimeString();
+                // Check close conditions
+                for (let i = openPositions.length - 1; i >= 0; i--) {
+                    const pos = openPositions[i];
+                    // Find current pair for this position
+                    const current = pairs.find(p => p.underlying === pos.underlying &&
+                        ((p.long.dex === pos.longDex && p.short.dex === pos.shortDex) ||
+                            (p.long.dex === pos.shortDex && p.short.dex === pos.longDex)));
+                    const currentSpread = current?.annualSpread ?? 0;
+                    if (currentSpread <= closeSpread || !current) {
+                        const reason = !current ? "pair disappeared" : `spread ${currentSpread.toFixed(1)}% <= ${closeSpread}%`;
+                        if (!isJson())
+                            console.log(chalk.yellow(`  ${now} CLOSE ${pos.underlying} — ${reason}`));
+                        if (!dryRun) {
+                            try {
+                                const longAdapter = await getHLAdapterForDex(pos.longDex);
+                                const shortAdapter = await getHLAdapterForDex(pos.shortDex);
+                                await Promise.all([
+                                    longAdapter.marketOrder(pos.longSymbol, "sell", pos.size),
+                                    shortAdapter.marketOrder(pos.shortSymbol, "buy", pos.size),
+                                ]);
+                                logExecution({
+                                    type: "arb_close", exchange: `${pos.longDex}+${pos.shortDex}`,
+                                    symbol: pos.underlying, side: "close", size: String(pos.size),
+                                    status: "success", dryRun: false,
+                                    meta: { longDex: pos.longDex, shortDex: pos.shortDex, reason, longSymbol: pos.longSymbol, shortSymbol: pos.shortSymbol },
+                                });
+                                if (!isJson())
+                                    console.log(chalk.green(`  ${now} CLOSED ${pos.underlying} — both legs`));
+                            }
+                            catch (err) {
+                                logExecution({
+                                    type: "arb_close", exchange: `${pos.longDex}+${pos.shortDex}`,
+                                    symbol: pos.underlying, side: "close", size: String(pos.size),
+                                    status: "failed", dryRun: false,
+                                    error: err instanceof Error ? err.message : String(err),
+                                    meta: { longDex: pos.longDex, shortDex: pos.shortDex },
+                                });
+                                if (!isJson())
+                                    console.error(chalk.red(`  ${now} CLOSE FAILED ${pos.underlying}: ${err instanceof Error ? err.message : err}`));
                             }
-                            openPositions.splice(i, 1);
                         }
+                        openPositions.splice(i, 1);
                     }
-                    // Check entry conditions
-                    if (openPositions.length < maxPositions) {
-                        for (const pair of pairs) {
-                            if (openPositions.some(p => p.underlying === pair.underlying))
-                                continue;
-                            if (openPositions.length >= maxPositions)
-                                break;
-                            if (pair.annualSpread < minSpread)
-                                continue;
-                            if (pair.minOiUsd < minOi)
-                                continue;
-                            if (gradeOrder[pair.viability] > minGradeIdx)
-                                continue;
-                            // Calculate size in asset units
-                            const avgPrice = (pair.long.markPrice + pair.short.markPrice) / 2;
-                            if (avgPrice <= 0)
-                                continue;
-                            const szDecimals = Math.min(pair.long.szDecimals, pair.short.szDecimals);
-                            const rawSize = sizeUsd / avgPrice;
-                            const size = rawSize.toFixed(szDecimals);
-                            if (!isJson()) {
-                                console.log(chalk.green(`  ${now} ENTER ${pair.underlying} — spread ${pair.annualSpread.toFixed(1)}% grade:${pair.viability} OI:$${formatUsd(pair.minOiUsd)}` +
-                                    `\n         Long ${pair.long.dex}:${pair.long.base} (${(pair.long.fundingRate * 100).toFixed(4)}%)` +
-                                    ` | Short ${pair.short.dex}:${pair.short.base} (${(pair.short.fundingRate * 100).toFixed(4)}%)` +
-                                    ` | ${size} units @ $${avgPrice.toFixed(2)}`));
+                }
+                // Check entry conditions
+                if (openPositions.length < maxPositions) {
+                    for (const pair of pairs) {
+                        if (openPositions.some(p => p.underlying === pair.underlying))
+                            continue;
+                        if (openPositions.length >= maxPositions)
+                            break;
+                        if (pair.annualSpread < minSpread)
+                            continue;
+                        if (pair.minOiUsd < minOi)
+                            continue;
+                        if (gradeOrder[pair.viability] > minGradeIdx)
+                            continue;
+                        // Calculate size in asset units
+                        const avgPrice = (pair.long.markPrice + pair.short.markPrice) / 2;
+                        if (avgPrice <= 0)
+                            continue;
+                        const szDecimals = Math.min(pair.long.szDecimals, pair.short.szDecimals);
+                        const rawSize = sizeUsd / avgPrice;
+                        const size = rawSize.toFixed(szDecimals);
+                        if (!isJson()) {
+                            console.log(chalk.green(`  ${now} ENTER ${pair.underlying} — spread ${pair.annualSpread.toFixed(1)}% grade:${pair.viability} OI:$${formatUsd(pair.minOiUsd)}` +
+                                `\n         Long ${pair.long.dex}:${pair.long.base} (${(pair.long.fundingRate * 100).toFixed(4)}%)` +
+                                ` | Short ${pair.short.dex}:${pair.short.base} (${(pair.short.fundingRate * 100).toFixed(4)}%)` +
+                                ` | ${size} units @ $${avgPrice.toFixed(2)}`));
+                        }
+                        if (!dryRun) {
+                            try {
+                                const longAdapter = await getHLAdapterForDex(pair.long.dex);
+                                const shortAdapter = await getHLAdapterForDex(pair.short.dex);
+                                await Promise.all([
+                                    longAdapter.marketOrder(pair.long.raw, "buy", size),
+                                    shortAdapter.marketOrder(pair.short.raw, "sell", size),
+                                ]);
+                                logExecution({
+                                    type: "arb_entry", exchange: `${pair.long.dex}+${pair.short.dex}`,
+                                    symbol: pair.underlying, side: "entry", size,
+                                    status: "success", dryRun: false,
+                                    meta: { longDex: pair.long.dex, shortDex: pair.short.dex, spread: pair.annualSpread, viability: pair.viability, avgPrice },
+                                });
+                                if (!isJson())
+                                    console.log(chalk.green(`  ${now} FILLED ${pair.underlying} — both legs`));
                             }
-                            if (!dryRun) {
-                                try {
-                                    const longAdapter = await getHLAdapterForDex(pair.long.dex);
-                                    const shortAdapter = await getHLAdapterForDex(pair.short.dex);
-                                    await Promise.all([
-                                        longAdapter.marketOrder(pair.long.raw, "buy", size),
-                                        shortAdapter.marketOrder(pair.short.raw, "sell", size),
-                                    ]);
-                                    logExecution({
-                                        type: "arb_entry", exchange: `${pair.long.dex}+${pair.short.dex}`,
-                                        symbol: pair.underlying, side: "entry", size,
-                                        status: "success", dryRun: false,
-                                        meta: { longDex: pair.long.dex, shortDex: pair.short.dex, spread: pair.annualSpread, viability: pair.viability, avgPrice },
-                                    });
-                                    if (!isJson())
-                                        console.log(chalk.green(`  ${now} FILLED ${pair.underlying} — both legs`));
-                                }
-                                catch (err) {
-                                    logExecution({
-                                        type: "arb_entry", exchange: `${pair.long.dex}+${pair.short.dex}`,
-                                        symbol: pair.underlying, side: "entry", size,
-                                        status: "failed", dryRun: false,
-                                        error: err instanceof Error ? err.message : String(err),
-                                        meta: { longDex: pair.long.dex, shortDex: pair.short.dex, spread: pair.annualSpread },
-                                    });
-                                    if (!isJson())
-                                        console.error(chalk.red(`  ${now} ENTRY FAILED ${pair.underlying}: ${err instanceof Error ? err.message : err}`));
-                                    continue;
-                                }
+                            catch (err) {
+                                logExecution({
+                                    type: "arb_entry", exchange: `${pair.long.dex}+${pair.short.dex}`,
+                                    symbol: pair.underlying, side: "entry", size,
+                                    status: "failed", dryRun: false,
+                                    error: err instanceof Error ? err.message : String(err),
+                                    meta: { longDex: pair.long.dex, shortDex: pair.short.dex, spread: pair.annualSpread },
+                                });
+                                if (!isJson())
+                                    console.error(chalk.red(`  ${now} ENTRY FAILED ${pair.underlying}: ${err instanceof Error ? err.message : err}`));
+                                continue;
                             }
-                            openPositions.push({
-                                underlying: pair.underlying,
-                                longDex: pair.long.dex,
-                                longSymbol: pair.long.raw,
-                                shortDex: pair.short.dex,
-                                shortSymbol: pair.short.raw,
-                                size,
-                                entrySpread: pair.annualSpread,
-                                entryTime: new Date().toISOString(),
-                                longPrice: pair.long.markPrice,
-                                shortPrice: pair.short.markPrice,
-                            });
                         }
-                    }
-                    // Status
-                    if (isJson()) {
-                        printJson(jsonOk({
-                            timestamp: new Date().toISOString(),
-                            openPositions,
-                            availablePairs: pairs.filter(p => p.annualSpread >= minSpread && p.minOiUsd >= minOi).length,
-                        }));
-                    }
-                    else if (openPositions.length > 0) {
-                        console.log(chalk.gray(`  ${now} Positions: ${openPositions.length}/${maxPositions} — ` +
-                            openPositions.map(p => `${p.underlying}(${p.entrySpread.toFixed(0)}%)`).join(", ")));
-                    }
-                    else {
-                        console.log(chalk.gray(`  ${now} No positions. ${pairs.filter(p => p.annualSpread >= minSpread).length} pairs above ${minSpread}%`));
+                        openPositions.push({
+                            underlying: pair.underlying,
+                            longDex: pair.long.dex,
+                            longSymbol: pair.long.raw,
+                            shortDex: pair.short.dex,
+                            shortSymbol: pair.short.raw,
+                            size,
+                            entrySpread: pair.annualSpread,
+                            entryTime: new Date().toISOString(),
+                            longPrice: pair.long.markPrice,
+                            shortPrice: pair.short.markPrice,
+                        });
                     }
                 }
-                catch (err) {
-                    if (!isJson())
-                        console.error(chalk.gray(`  Error: ${err instanceof Error ? err.message : String(err)}`));
+                // Status
+                if (isJson()) {
+                    printJson(jsonOk({
+                        timestamp: new Date().toISOString(),
+                        openPositions,
+                        availablePairs: pairs.filter(p => p.annualSpread >= minSpread && p.minOiUsd >= minOi).length,
+                    }));
                 }
-            };
-            await cycle();
-            setInterval(cycle, intervalMs);
-            await new Promise(() => { }); // keep alive
-        });
+                else if (openPositions.length > 0) {
+                    console.log(chalk.gray(`  ${now} Positions: ${openPositions.length}/${maxPositions} — ` +
+                        openPositions.map(p => `${p.underlying}(${p.entrySpread.toFixed(0)}%)`).join(", ")));
+                }
+                else {
+                    console.log(chalk.gray(`  ${now} No positions. ${pairs.filter(p => p.annualSpread >= minSpread).length} pairs above ${minSpread}%`));
+                }
+            }
+            catch (err) {
+                if (!isJson())
+                    console.error(chalk.gray(`  Error: ${err instanceof Error ? err.message : String(err)}`));
+            }
+        };
+        await cycle();
+        setInterval(cycle, intervalMs);
+        await new Promise(() => { }); // keep alive
     }
+    // Expose inner handlers for external use
+    handleArbPnlRef = _handleArbPnl;
+}
+// Module-level exported references (assigned inside registerArbAutoCommands)
+export let handleArbPnlRef;
+/**
+ * Exported wrapper for handleArbPnl.
+ */
+export async function handleArbPnl(getAdapterForExchange, isJson) {
+    if (handleArbPnlRef)
+        return handleArbPnlRef();
+    throw new Error("handleArbPnl not initialized -- call registerArbAutoCommands first");
 }
 // ── Orderbook helpers for monitor ──
 async function fetchHLOrderbook(symbol) {