perp-cli 0.4.0 → 0.4.8

package/dist/commands/arb-auto.js

@@ -5,19 +5,12 @@ import { computeAnnualSpread, toHourlyRate } from "../funding.js";
 import { fetchPacificaPricesRaw, parsePacificaRaw, fetchHyperliquidMetaRaw, parseHyperliquidMetaRaw, fetchLighterOrderBookDetailsRaw, fetchLighterFundingRatesRaw, parseLighterRaw, } from "../shared-api.js";
 import { scanDexArb } from "../dex-asset-map.js";
 import { logExecution, readExecutionLog } from "../execution-log.js";
+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, createInitialState, } from "../arb-state.js";
+import { loadArbState, saveArbState, addPosition as persistAddPosition, removePosition as persistRemovePosition, createInitialState, } from "../arb-state.js";
 // ── Fee-Adjusted Net Spread Calculation ──
-/** Default taker fee per exchange (as fraction, e.g. 0.00035 = 0.035%) */
-const TAKER_FEES = {
-    hyperliquid: 0.00035,
-    pacifica: 0.00035,
-    lighter: 0.00035,
-};
-function getTakerFee(exchange) {
-    return TAKER_FEES[exchange.toLowerCase()] ?? 0.00035;
-}
+import { getTakerFee } from "../constants.js";
 /**
  * Compute the estimated round-trip cost as a percentage of notional.
  * Round-trip = 4 × taker fee + 2 × slippage (entry + exit for both legs).
@@ -50,12 +43,7 @@ export function computeNetSpread(grossAnnualPct, holdDays, roundTripCostPct, bri
     return grossAnnualPct - annualizedCostPct - bridgeCostAnnualPct;
 }
 // ── Funding Settlement Timing ──
-/** Settlement schedules per exchange (UTC hours when settlement occurs) */
-const SETTLEMENT_SCHEDULES = {
-    hyperliquid: Array.from({ length: 24 }, (_, i) => i), // every hour
-    pacifica: Array.from({ length: 24 }, (_, i) => i), // every hour
-    lighter: Array.from({ length: 24 }, (_, i) => i), // every hour
-};
+import { SETTLEMENT_SCHEDULES } from "../arb-utils.js";
 /**
  * Get the next settlement time for an exchange.
  * @returns Date of next settlement
@@ -188,6 +176,7 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
         .option("--max-basis <pct>", "Max basis risk (mark price divergence %)", "3")
         .option("--notify <url>", "Webhook URL for notifications (Discord/Telegram/generic)")
         .option("--notify-events <events>", "Comma-separated events: entry,exit,reversal,margin,basis", "entry,exit,reversal,margin,basis")
+        .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)")
         .action(async (opts) => {
@@ -202,6 +191,7 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
                 `--hold-days`, opts.holdDays,
                 `--bridge-cost`, opts.bridgeCost,
                 `--min-margin`, opts.minMargin,
+                `--cooldown`, opts.cooldown,
                 ...(opts.symbols ? [`--symbols`, opts.symbols] : []),
                 ...(opts.dryRun ? [`--dry-run`] : []),
                 ...(opts.reversalExit === false ? [`--no-reversal-exit`] : []),
@@ -233,7 +223,8 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
         const bridgeCostUsd = parseFloat(opts.bridgeCost);
         const reversalExitEnabled = opts.reversalExit !== false;
         const settleAwareEnabled = opts.settleAware !== false;
-        const settleStrategy = (opts.settleStrategy || "block");
+        // --no-settle-aware overrides --settle-strategy to "off"
+        const settleStrategy = !settleAwareEnabled ? "off" : (opts.settleStrategy || "block");
         const maxBasisPct = parseFloat(opts.maxBasis);
         const webhookUrl = opts.notify;
         const notifyEvents = opts.notifyEvents
@@ -242,9 +233,12 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
         const minSizeUsd = parseFloat(opts.minSize);
         const filterSymbols = opts.symbols?.split(",").map(s => s.trim().toUpperCase());
         const dryRun = !!opts.dryRun || process.argv.includes("--dry-run");
+        const cooldownMinutes = parseFloat(opts.cooldown);
         const openPositions = [];
         // Track which exchanges have low margin (block entries)
         const blockedExchanges = new Set();
+        // Track close times per symbol to prevent close→re-entry loops
+        const closeCooldowns = new Map(); // symbol → close timestamp ms
         // -- State Persistence: Initialize or recover --
         const daemonConfig = {
             minSpread,
@@ -263,7 +257,7 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
                     symbol: persisted.symbol,
                     longExchange: persisted.longExchange,
                     shortExchange: persisted.shortExchange,
-                    size: String(persisted.longSize),
+                    size: persisted.longSize,
                     entrySpread: persisted.entrySpread,
                     entryTime: persisted.entryTime,
                     entryMarkPrice: persisted.entryLongPrice,
@@ -281,8 +275,11 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
             daemonState = createInitialState(daemonConfig);
             saveArbState(daemonState);
         }
-        // SIGINT handler: save final state before exit
+        // SIGINT handler: clean up interval and save final state before exit
+        let cycleInterval = null;
         const handleSigint = () => {
+            if (cycleInterval)
+                clearInterval(cycleInterval);
             const finalState = loadArbState();
             if (finalState) {
                 finalState.lastScanTime = new Date().toISOString();
@@ -308,12 +305,42 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
             console.log(`  Max basis:     ${maxBasisPct}% (warn on price divergence)`);
             console.log(`  Reversal exit: ${reversalExitEnabled ? chalk.green("ON") : chalk.yellow("OFF")}`);
             console.log(`  Settle strat:  ${settleStrategy === "aggressive" ? chalk.cyan("AGGRESSIVE") : settleStrategy === "off" ? chalk.yellow("OFF") : chalk.green("BLOCK")}`);
+            console.log(`  Cooldown:      ${cooldownMinutes}m (re-entry delay after close)`);
             console.log(`  Notifications: ${webhookUrl ? chalk.green("ON") : chalk.gray("OFF")}${webhookUrl ? ` (${notifyEvents.join(",")})` : ""}`);
             console.log(`  Symbols:       ${filterSymbols?.join(", ") || "all"}`);
             console.log(`  Interval:      ${opts.interval}s`);
             console.log(chalk.gray("\n  Monitoring... (Ctrl+C to stop)\n"));
         }
         const cycle = async () => {
+            // Sync in-memory positions with persisted state (handles CLI manual closes)
+            const syncState = loadArbState();
+            if (syncState) {
+                const persistedSymbols = new Set(syncState.positions.map(p => p.symbol));
+                // Remove positions that were closed externally (e.g. via `perp arb close`)
+                for (let i = openPositions.length - 1; i >= 0; i--) {
+                    if (!persistedSymbols.has(openPositions[i].symbol)) {
+                        console.log(chalk.gray(`  ${new Date().toLocaleTimeString()} SYNC: ${openPositions[i].symbol} removed (closed externally)`));
+                        openPositions.splice(i, 1);
+                    }
+                }
+                // Recover positions that exist in state but not in memory (e.g. added by another process)
+                for (const persisted of syncState.positions) {
+                    if (!openPositions.some(p => p.symbol === persisted.symbol)) {
+                        console.log(chalk.gray(`  ${new Date().toLocaleTimeString()} SYNC: recovering ${persisted.symbol} from state`));
+                        openPositions.push({
+                            symbol: persisted.symbol,
+                            longExchange: persisted.longExchange,
+                            shortExchange: persisted.shortExchange,
+                            size: persisted.longSize,
+                            entrySpread: persisted.entrySpread,
+                            entryTime: persisted.entryTime,
+                            entryMarkPrice: persisted.entryLongPrice,
+                            accumulatedFundingUsd: persisted.accumulatedFunding,
+                            lastCheckTime: new Date(persisted.lastCheckTime).getTime(),
+                        });
+                    }
+                }
+            }
             // Heartbeat check
             const heartbeatState = loadArbState();
             if (heartbeatState?.lastSuccessfulScanTime) {
@@ -375,45 +402,120 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
                     }
                     if (shouldClose) {
                         console.log(chalk.yellow(`  ${now} CLOSE ${pos.symbol} — ${closeReason}`));
+                        const exitReason = closeReason.includes("REVERSAL") ? "reversal"
+                            : closeReason.includes("spread") ? "spread"
+                                : "manual";
                         if (!dryRun) {
                             try {
-                                // Close both legs
                                 const longAdapter = await getAdapterForExchange(pos.longExchange);
                                 const shortAdapter = await getAdapterForExchange(pos.shortExchange);
-                                await longAdapter.marketOrder(pos.symbol, "sell", pos.size);
-                                await shortAdapter.marketOrder(pos.symbol, "buy", pos.size);
-                                // Determine exit reason tag
-                                const exitReason = closeReason.includes("REVERSAL") ? "reversal"
-                                    : closeReason.includes("spread") ? "spread"
-                                        : "manual";
-                                logExecution({
-                                    type: "arb_close", exchange: `${pos.longExchange}+${pos.shortExchange}`,
-                                    symbol: pos.symbol, side: "close", size: pos.size,
-                                    status: "success", dryRun: false,
-                                    meta: { longExchange: pos.longExchange, shortExchange: pos.shortExchange, currentSpread, reason: closeReason, exitReason },
-                                });
-                                console.log(chalk.green(`  ${now} CLOSED ${pos.symbol} — both legs`));
-                                await notifyIfEnabled(webhookUrl, notifyEvents, "exit", {
-                                    symbol: pos.symbol, longExchange: pos.longExchange, shortExchange: pos.shortExchange,
-                                    pnl: pos.accumulatedFundingUsd,
-                                    duration: `${Math.round((Date.now() - new Date(pos.entryTime).getTime()) / 3600000)}h`,
-                                });
+                                // Close both legs simultaneously with verification
+                                const [longResult, shortResult] = await Promise.allSettled([
+                                    longAdapter.marketOrder(pos.symbol, "sell", String(pos.size)),
+                                    shortAdapter.marketOrder(pos.symbol, "buy", String(pos.size)),
+                                ]);
+                                const longOk = longResult.status === "fulfilled";
+                                const shortOk = shortResult.status === "fulfilled";
+                                if (longOk && shortOk) {
+                                    logExecution({
+                                        type: "arb_close", exchange: `${pos.longExchange}+${pos.shortExchange}`,
+                                        symbol: pos.symbol, side: "close", size: String(pos.size),
+                                        status: "success", dryRun: false,
+                                        meta: { longExchange: pos.longExchange, shortExchange: pos.shortExchange, currentSpread, reason: closeReason, exitReason },
+                                    });
+                                    console.log(chalk.green(`  ${now} CLOSED ${pos.symbol} — both legs`));
+                                    persistRemovePosition(pos.symbol);
+                                    closeCooldowns.set(pos.symbol, Date.now());
+                                    openPositions.splice(i, 1);
+                                    await notifyIfEnabled(webhookUrl, notifyEvents, "exit", {
+                                        symbol: pos.symbol, longExchange: pos.longExchange, shortExchange: pos.shortExchange,
+                                        pnl: pos.accumulatedFundingUsd,
+                                        duration: `${Math.round((Date.now() - new Date(pos.entryTime).getTime()) / 3600000)}h`,
+                                    });
+                                }
+                                else if (longOk !== shortOk) {
+                                    // One leg closed, one failed — retry the failed leg
+                                    const failedSide = longOk ? "short" : "long";
+                                    const failedAdapter = longOk ? shortAdapter : longAdapter;
+                                    const retryAction = longOk ? "buy" : "sell";
+                                    const failedErr = longOk
+                                        ? shortResult.reason
+                                        : longResult.reason;
+                                    console.log(chalk.yellow(`  ${now} PARTIAL CLOSE ${pos.symbol}: ${failedSide} leg failed — retrying...`));
+                                    let retryOk = false;
+                                    for (let attempt = 1; attempt <= 2; attempt++) {
+                                        try {
+                                            await failedAdapter.marketOrder(pos.symbol, retryAction, String(pos.size));
+                                            retryOk = true;
+                                            console.log(chalk.green(`  ${now} RETRY OK ${pos.symbol}: ${failedSide} leg closed (attempt ${attempt})`));
+                                            break;
+                                        }
+                                        catch (retryErr) {
+                                            console.log(chalk.red(`  ${now} RETRY ${attempt}/2 FAILED ${pos.symbol}: ${retryErr instanceof Error ? retryErr.message : retryErr}`));
+                                        }
+                                    }
+                                    if (retryOk) {
+                                        logExecution({
+                                            type: "arb_close", exchange: `${pos.longExchange}+${pos.shortExchange}`,
+                                            symbol: pos.symbol, side: "close", size: String(pos.size),
+                                            status: "success", dryRun: false,
+                                            meta: { longExchange: pos.longExchange, shortExchange: pos.shortExchange, currentSpread, reason: closeReason, exitReason, retried: failedSide },
+                                        });
+                                        persistRemovePosition(pos.symbol);
+                                        closeCooldowns.set(pos.symbol, Date.now());
+                                        openPositions.splice(i, 1);
+                                    }
+                                    else {
+                                        // One leg is closed, other still open — log but DON'T remove from tracking
+                                        logExecution({
+                                            type: "arb_close", exchange: `${pos.longExchange}+${pos.shortExchange}`,
+                                            symbol: pos.symbol, side: "close", size: String(pos.size),
+                                            status: "failed", dryRun: false,
+                                            error: `Partial close: ${failedSide} failed (${failedErr instanceof Error ? failedErr.message : String(failedErr)}). Retry failed.`,
+                                            meta: { longExchange: pos.longExchange, shortExchange: pos.shortExchange, reason: closeReason, exitReason, partialClose: true },
+                                        });
+                                        console.log(chalk.red.bold(`  ${now} PARTIAL CLOSE ${pos.symbol}: ${failedSide} still open — MANUAL CLOSE REQUIRED`));
+                                        await notifyIfEnabled(webhookUrl, notifyEvents, "margin", {
+                                            exchange: longOk ? pos.shortExchange : pos.longExchange,
+                                            marginPct: 0, threshold: 0, symbol: pos.symbol,
+                                            message: `PARTIAL CLOSE: ${failedSide} leg still open after retry. Manual close required.`,
+                                        });
+                                        // Do NOT splice — keep tracking so next cycle retries
+                                    }
+                                }
+                                else {
+                                    // Both legs failed — keep position, retry next cycle
+                                    const longErr = longResult.reason;
+                                    const shortErr = shortResult.reason;
+                                    logExecution({
+                                        type: "arb_close", exchange: `${pos.longExchange}+${pos.shortExchange}`,
+                                        symbol: pos.symbol, side: "close", size: String(pos.size),
+                                        status: "failed", dryRun: false,
+                                        error: `Both legs failed. Long: ${longErr instanceof Error ? longErr.message : String(longErr)}, Short: ${shortErr instanceof Error ? shortErr.message : String(shortErr)}`,
+                                        meta: { longExchange: pos.longExchange, shortExchange: pos.shortExchange, reason: closeReason, exitReason },
+                                    });
+                                    console.error(chalk.red(`  ${now} CLOSE FAILED ${pos.symbol}: both legs — will retry next cycle`));
+                                    // Do NOT splice — retry next cycle
+                                }
                             }
                             catch (err) {
-                                const exitReason = closeReason.includes("REVERSAL") ? "reversal"
-                                    : closeReason.includes("spread") ? "spread"
-                                        : "manual";
                                 logExecution({
                                     type: "arb_close", exchange: `${pos.longExchange}+${pos.shortExchange}`,
-                                    symbol: pos.symbol, side: "close", size: pos.size,
+                                    symbol: pos.symbol, side: "close", size: String(pos.size),
                                     status: "failed", dryRun: false,
                                     error: err instanceof Error ? err.message : String(err),
                                     meta: { longExchange: pos.longExchange, shortExchange: pos.shortExchange, reason: closeReason, exitReason },
                                 });
                                 console.error(chalk.red(`  ${now} CLOSE FAILED ${pos.symbol}: ${err instanceof Error ? err.message : err}`));
+                                // Do NOT splice — retry next cycle
                             }
                         }
-                        openPositions.splice(i, 1);
+                        else {
+                            // Dry run — remove from tracking
+                            persistRemovePosition(pos.symbol);
+                            closeCooldowns.set(pos.symbol, Date.now());
+                            openPositions.splice(i, 1);
+                        }
                     }
                 }
                 // Log next settlement times and funding estimation
@@ -434,7 +536,7 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
                         const fRateFor = (e) => e === "pacifica" ? fSnap.pacRate : e === "hyperliquid" ? fSnap.hlRate : fSnap.ltRate;
                         const fHlHourly = toHourlyRate(fRateFor("hyperliquid"), "hyperliquid");
                         const fPacHourly = toHourlyRate(fRateFor("pacifica"), "pacifica");
-                        const fNotional = parseFloat(fPos.size) * fSnap.markPrice;
+                        const fNotional = fPos.size * fSnap.markPrice;
                         const fEst = estimateFundingUntilSettlement(fHlHourly, fPacHourly, fNotional, hoursUntilPAC);
                         console.log(chalk.gray(`  ${now} ${fPos.symbol} Next PAC: ${hUTC}:00 UTC (${hoursUntilPAC.toFixed(1)}h) | ` +
                             `HL cum: ~$${fEst.hlCumulative.toFixed(4)} | PAC pmt: ~$${fEst.pacPayment.toFixed(4)} | ` +
@@ -511,6 +613,17 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
                             continue;
                         if (openPositions.length >= maxPositions)
                             break;
+                        // Cooldown: skip if recently closed to prevent close→re-entry loops
+                        const lastCloseMs = closeCooldowns.get(snap.symbol);
+                        if (lastCloseMs && cooldownMinutes > 0) {
+                            const elapsedMin = (Date.now() - lastCloseMs) / 60000;
+                            if (elapsedMin < cooldownMinutes) {
+                                console.log(chalk.gray(`  ${now} SKIP ${snap.symbol}: cooldown ${(cooldownMinutes - elapsedMin).toFixed(0)}m remaining`));
+                                continue;
+                            }
+                            // Cooldown expired, clean up
+                            closeCooldowns.delete(snap.symbol);
+                        }
                         const grossSpread = Math.abs(snap.spread);
                         // Determine direction using all 3 exchanges: short the high-funding, long the low-funding
                         const longExchange = snap.longExch;
@@ -526,9 +639,6 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
                         const roundTripCost = computeRoundTripCostPct(longExchange, shortExchange);
                         const effectiveSizeUsd = sizeIsAuto ? 100 : sizeUsd; // Use $100 for net spread calc when auto
                         const netSpread = computeNetSpread(grossSpread, holdDays, roundTripCost, bridgeCostUsd, effectiveSizeUsd);
-                        // --min-spread now compares against NET spread
-                        if (netSpread < minSpread)
-                            continue;
                         // Settlement timing check with strategy
                         if (settleStrategy === "block") {
                             const settlCheck = isNearSettlement(longExchange, shortExchange);
@@ -545,6 +655,10 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
                                 console.log(chalk.cyan(`  ${now} BOOST ${snap.symbol}: post-settlement ${((settleBoostMultiplier - 1) * 100).toFixed(0)}% score boost`));
                             }
                         }
+                        // --min-spread compares against NET spread (with settle boost applied)
+                        const effectiveNetSpread = netSpread * settleBoostMultiplier;
+                        if (effectiveNetSpread < minSpread)
+                            continue;
                         const rateForExch = (e) => e === "pacifica" ? snap.pacRate : e === "hyperliquid" ? snap.hlRate : snap.ltRate;
                         console.log(chalk.green(`  ${now} ENTER ${snap.symbol} — gross ${grossSpread.toFixed(1)}% net ${netSpread.toFixed(1)}%` +
                             ` | Long ${longExchange} (${(rateForExch(longExchange) * 100).toFixed(4)}%)` +
@@ -597,6 +711,44 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
                                         meta: { longExchange, shortExchange, grossSpread, netSpread, roundTripCost, markPrice: snap.markPrice },
                                     });
                                     console.log(chalk.green(`  ${now} FILLED ${snap.symbol} — both legs @ ${sizeInAsset} units ($${actualSizeUsd} / $${snap.markPrice.toFixed(2)})`));
+                                    // Verify actual fill sizes by querying positions
+                                    let verifiedLongSize = sizeInAsset;
+                                    let verifiedShortSize = sizeInAsset;
+                                    try {
+                                        const [longPositions, shortPositions] = await Promise.all([
+                                            longAdapter.getPositions(),
+                                            shortAdapter.getPositions(),
+                                        ]);
+                                        const longPos = longPositions.find(p => p.symbol.toUpperCase().includes(snap.symbol));
+                                        const shortPos = shortPositions.find(p => p.symbol.toUpperCase().includes(snap.symbol));
+                                        if (longPos)
+                                            verifiedLongSize = longPos.size;
+                                        if (shortPos)
+                                            verifiedShortSize = shortPos.size;
+                                        if (verifiedLongSize !== sizeInAsset || verifiedShortSize !== sizeInAsset) {
+                                            console.log(chalk.yellow(`  ${now} SIZE MISMATCH ${snap.symbol}: requested ${sizeInAsset}, actual long=${verifiedLongSize} short=${verifiedShortSize}`));
+                                        }
+                                    }
+                                    catch {
+                                        // Position query failed — use requested size as fallback
+                                        console.log(chalk.gray(`  ${now} Could not verify fill sizes for ${snap.symbol}, using requested size`));
+                                    }
+                                    // Persist to state file immediately (crash-safe)
+                                    const entryTime = new Date().toISOString();
+                                    persistAddPosition({
+                                        id: `${snap.symbol}-${Date.now()}`,
+                                        symbol: snap.symbol,
+                                        longExchange,
+                                        shortExchange,
+                                        longSize: parseFloat(verifiedLongSize),
+                                        shortSize: parseFloat(verifiedShortSize),
+                                        entryTime,
+                                        entrySpread: grossSpread,
+                                        entryLongPrice: snap.markPrice,
+                                        entryShortPrice: snap.markPrice,
+                                        accumulatedFunding: 0,
+                                        lastCheckTime: entryTime,
+                                    });
                                     await notifyIfEnabled(webhookUrl, notifyEvents, "entry", {
                                         symbol: snap.symbol, longExchange, shortExchange,
                                         size: actualSizeUsd, netSpread,
@@ -672,17 +824,35 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
                                 continue;
                             }
                         }
+                        const posEntryTime = new Date().toISOString();
                         openPositions.push({
                             symbol: snap.symbol,
                             longExchange,
                             shortExchange,
-                            size: sizeInAsset,
+                            size: parseFloat(sizeInAsset),
                             entrySpread: grossSpread,
-                            entryTime: new Date().toISOString(),
+                            entryTime: posEntryTime,
                             entryMarkPrice: snap.markPrice,
                             accumulatedFundingUsd: 0,
                             lastCheckTime: Date.now(),
                         });
+                        // Persist for dry-run mode too (tracks what would have been entered)
+                        if (dryRun) {
+                            persistAddPosition({
+                                id: `${snap.symbol}-${Date.now()}`,
+                                symbol: snap.symbol,
+                                longExchange,
+                                shortExchange,
+                                longSize: parseFloat(sizeInAsset),
+                                shortSize: parseFloat(sizeInAsset),
+                                entryTime: posEntryTime,
+                                entrySpread: grossSpread,
+                                entryLongPrice: snap.markPrice,
+                                entryShortPrice: snap.markPrice,
+                                accumulatedFunding: 0,
+                                lastCheckTime: posEntryTime,
+                            });
+                        }
                     }
                 }
                 // Accumulate estimated funding income & show status
@@ -693,11 +863,11 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
                         if (!current)
                             continue;
                         const elapsedHours = (nowMs - pos.lastCheckTime) / (1000 * 60 * 60);
-                        const notional = parseFloat(pos.size) * current.markPrice;
-                        // Estimate funding collected: long collects from low-rate side, short from high-rate side
+                        const notional = pos.size * current.markPrice;
+                        // Estimate funding collected: normalize all rates to hourly before comparing
                         const rateFor = (e) => e === "pacifica" ? current.pacRate : e === "hyperliquid" ? current.hlRate : current.ltRate;
-                        const longHourly = rateFor(pos.longExchange);
-                        const shortHourly = rateFor(pos.shortExchange);
+                        const longHourly = toHourlyRate(rateFor(pos.longExchange), pos.longExchange);
+                        const shortHourly = toHourlyRate(rateFor(pos.shortExchange), pos.shortExchange);
                         // Income = short gets paid positive funding, long pays; net = (shortRate - longRate) * notional * hours
                         const hourlyIncome = (shortHourly - longHourly) * notional;
                         pos.accumulatedFundingUsd += hourlyIncome * elapsedHours;
@@ -722,13 +892,14 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
             }
         };
         await cycle();
-        setInterval(cycle, intervalMs);
+        cycleInterval = setInterval(cycle, intervalMs);
         await new Promise(() => { }); // keep alive
     });
     // ── arb scan ── (one-shot spread scan)
     arb
         .command("scan")
-        .description("Scan current funding rate spreads")
+        .description("Scan current funding rate spreads (perp-perp or spot-perp)")
+        .option("--mode <mode>", "Scan mode: perp-perp, spot-perp, all", "perp-perp")
         .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")
@@ -739,8 +910,50 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
         const holdDays = parseFloat(opts.holdDays);
         const bridgeCostUsd = parseFloat(opts.bridgeCost);
         const sizeUsd = parseFloat(opts.size);
+        // ── spot-perp mode ──
+        if (opts.mode === "spot-perp" || opts.mode === "all") {
+            if (!isJson())
+                console.log(chalk.cyan("\n  Scanning spot+perp funding opportunities...\n"));
+            const { fetchSpotPerpSpreads } = await import("../funding/rates.js");
+            const { spreads: spotSpreads } = await fetchSpotPerpSpreads({ minSpread });
+            if (isJson() && opts.mode === "spot-perp") {
+                let result = spotSpreads.map(s => ({
+                    mode: "spot-perp", symbol: s.symbol, perpExchange: s.perpExchange,
+                    spotExchanges: s.spotExchanges, annualSpreadPct: s.annualSpreadPct,
+                    perpFundingRate: s.perpFundingRate, direction: s.direction,
+                    markPrice: s.bestMarkPrice, estHourlyIncomeUsd: s.estHourlyIncomeUsd,
+                }));
+                if (opts.top)
+                    result = result.slice(0, parseInt(opts.top));
+                return printJson(jsonOk(result));
+            }
+            if (!isJson()) {
+                if (spotSpreads.length === 0) {
+                    console.log(chalk.gray(`  No spot+perp opportunities above ${minSpread}%\n`));
+                }
+                else {
+                    console.log(chalk.gray(`  ${"SYMBOL".padEnd(8)} ${"SPREAD".padEnd(8)} ${"PERP EX".padEnd(9)} ${"SPOT EX".padEnd(12)} ${"FUND".padEnd(12)} DIRECTION`));
+                    for (const s of spotSpreads.slice(0, parseInt(opts.top ?? "30"))) {
+                        const spreadColor = s.annualSpreadPct >= 30 ? chalk.green : chalk.yellow;
+                        const dir = s.direction === "long-spot-short-perp" ? "Spot+Short" : "Sell+Long";
+                        console.log(`  ${chalk.white.bold(s.symbol.padEnd(8))} ` +
+                            `${spreadColor(`${s.annualSpreadPct.toFixed(1)}%`.padEnd(8))} ` +
+                            `${s.perpExchange.slice(0, 8).padEnd(9)} ` +
+                            `${s.spotExchanges.join(",").slice(0, 11).padEnd(12)} ` +
+                            `${(s.perpFundingRate * 100).toFixed(4).padEnd(12)}% ` +
+                            dir);
+                    }
+                    console.log(chalk.gray(`\n  ${spotSpreads.length} spot+perp opportunities (spot funding = 0%)`));
+                }
+            }
+            if (opts.mode === "spot-perp")
+                return;
+            if (!isJson())
+                console.log(""); // separator
+        }
+        // ── perp-perp mode (default) ──
         if (!isJson())
-            console.log(chalk.cyan("\n  Scanning funding rate spreads...\n"));
+            console.log(chalk.cyan("  Scanning perp-perp funding rate spreads...\n"));
         const spreads = await fetchFundingSpreads();
         const filtered = spreads.filter(s => Math.abs(s.spread) >= minSpread);
         if (isJson()) {
@@ -748,14 +961,14 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
                 const grossSpread = Math.abs(s.spread);
                 const rtCost = computeRoundTripCostPct(s.longExch, s.shortExch);
                 const net = computeNetSpread(grossSpread, holdDays, rtCost, bridgeCostUsd, sizeUsd);
-                return { symbol: s.symbol, longExch: s.longExch, shortExch: s.shortExch, markPrice: s.markPrice, grossSpread, netSpread: net, estFeesPct: rtCost };
+                return { mode: "perp-perp", symbol: s.symbol, longExch: s.longExch, shortExch: s.shortExch, markPrice: s.markPrice, grossSpread, netSpread: net, estFeesPct: rtCost };
             }).sort((a, b) => b.netSpread - a.netSpread);
             if (opts.top)
                 enriched = enriched.slice(0, parseInt(opts.top));
             return printJson(jsonOk(enriched));
         }
         if (filtered.length === 0) {
-            console.log(chalk.gray(`  No spreads above ${minSpread}%\n`));
+            console.log(chalk.gray(`  No perp-perp spreads above ${minSpread}%\n`));
             return;
         }
         // Header
@@ -798,6 +1011,7 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
         .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)")
         .action(async (symbol, longExch, shortExch, sizeUsdStr, opts) => {
         const sym = symbol.toUpperCase();
         const sizeUsd = parseFloat(sizeUsdStr);
@@ -888,16 +1102,19 @@ 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}`));
+            console.log(chalk.cyan(`\n  Arb Exec: ${sym}${opts.smart ? " (smart order)" : ""}`));
             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`));
         }
         // 5. Execute both legs simultaneously
-        const [longResult, shortResult] = await Promise.allSettled([
-            longAdapter.marketOrder(sym, "buy", matchedSize),
-            shortAdapter.marketOrder(sym, "sell", matchedSize),
-        ]);
+        const execLong = opts.smart
+            ? smartOrder(longAdapter, sym, "buy", matchedSize).then(r => r.result)
+            : longAdapter.marketOrder(sym, "buy", matchedSize);
+        const execShort = opts.smart
+            ? smartOrder(shortAdapter, sym, "sell", matchedSize).then(r => r.result)
+            : shortAdapter.marketOrder(sym, "sell", matchedSize);
+        const [longResult, shortResult] = await Promise.allSettled([execLong, execShort]);
         const longOk = longResult.status === "fulfilled";
         const shortOk = shortResult.status === "fulfilled";
         if (longOk && shortOk) {
@@ -963,7 +1180,12 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
             let rollbackOk = false;
             for (let attempt = 1; attempt <= 2; attempt++) {
                 try {
-                    await filledAdapter.marketOrder(sym, rollbackAction, matchedSize);
+                    if (opts.smart) {
+                        await smartOrder(filledAdapter, sym, rollbackAction, matchedSize, { reduceOnly: true });
+                    }
+                    else {
+                        await filledAdapter.marketOrder(sym, rollbackAction, matchedSize);
+                    }
                     rollbackOk = true;
                     break;
                 }
@@ -1002,6 +1224,602 @@ 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) => {
+        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" };
+        spotExch = aliasMap[spotExch.toLowerCase()] || spotExch.toLowerCase();
+        perpExch = aliasMap[perpExch.toLowerCase()] || perpExch.toLowerCase();
+        // Validate spot exchange
+        if (!["hyperliquid", "lighter"].includes(spotExch)) {
+            const msg = `Spot exchange must be hl or lt (got ${spotExch}). Pacifica is perp-only.`;
+            if (isJson())
+                return printJson(jsonOk({ error: msg }));
+            console.log(chalk.red(`  ${msg}`));
+            return;
+        }
+        // Load spot adapter
+        const { HyperliquidSpotAdapter } = await import("../exchanges/hyperliquid-spot.js");
+        const { LighterSpotAdapter } = await import("../exchanges/lighter-spot.js");
+        let spotAdapter;
+        if (spotExch === "hyperliquid") {
+            const hlAdapter = await getAdapterForExchange("hyperliquid");
+            const hlSpot = new HyperliquidSpotAdapter(hlAdapter);
+            await hlSpot.init();
+            spotAdapter = hlSpot;
+        }
+        else {
+            const ltAdapter = await getAdapterForExchange("lighter");
+            const ltSpot = new LighterSpotAdapter(ltAdapter);
+            await ltSpot.init();
+            spotAdapter = ltSpot;
+        }
+        const perpAdapter = await getAdapterForExchange(perpExch);
+        // 1. Set perp leverage if requested
+        if (opts.leverage) {
+            const lev = parseInt(opts.leverage);
+            const mode = opts.isolated ? "isolated" : "cross";
+            if (!isJson())
+                console.log(chalk.gray(`  Setting perp leverage ${lev}x ${mode} on ${perpExch}...`));
+            try {
+                await perpAdapter.setLeverage(sym, lev, mode);
+            }
+            catch (e) {
+                const msg = `Failed to set leverage: ${e instanceof Error ? e.message : e}`;
+                if (isJson())
+                    return printJson(jsonOk({ error: msg }));
+                console.log(chalk.red(`  ${msg}`));
+                return;
+            }
+        }
+        // 2. Auto-transfer USDC to spot account if needed
+        if (spotExch === "hyperliquid") {
+            const hlSpot = spotAdapter;
+            const transferAmt = Math.ceil(sizeUsd * 1.1);
+            try {
+                const xferResult = await hlSpot.transferUsdcToSpot(transferAmt);
+                if (xferResult?.status === "err" && xferResult.response?.includes("unified")) {
+                    if (!isJson())
+                        console.log(chalk.gray(`  Unified account — no USDC transfer needed`));
+                }
+                else if (xferResult?.status !== "err") {
+                    if (!isJson())
+                        console.log(chalk.gray(`  Transferred $${transferAmt} USDC perp→spot`));
+                    await new Promise(r => setTimeout(r, 500));
+                }
+            }
+            catch {
+                // Non-critical — may be unified account or already have balance
+            }
+        }
+        else if (spotExch === "lighter") {
+            // Lighter requires explicit USDC transfer from perp → spot account
+            const ltSpot = spotAdapter;
+            const transferAmt = Math.ceil(sizeUsd * 1.1);
+            try {
+                const xferResult = await ltSpot.transferUsdcToSpot(transferAmt);
+                if (!isJson())
+                    console.log(chalk.gray(`  Transferred $${transferAmt} USDC perp→spot on Lighter`));
+                await new Promise(r => setTimeout(r, 300));
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                if (!isJson())
+                    console.log(chalk.yellow(`  USDC transfer warning: ${msg}`));
+                // Continue — spot order may still work if spot balance already exists
+            }
+        }
+        // 2b. Verify spot USDC balance is sufficient after transfer
+        try {
+            const spotBalances = await spotAdapter.getSpotBalances();
+            const spotUsdc = spotBalances.find(b => b.token === "USDC_SPOT" || b.token === "USDC");
+            const spotUsdcAvail = Number(spotUsdc?.available ?? 0);
+            // Also check perp balance for the perp leg
+            const perpBalance = await perpAdapter.getBalance();
+            const perpAvail = Number(perpBalance?.available ?? 0);
+            if (spotUsdcAvail < sizeUsd * 0.9) {
+                const msg = `Insufficient spot USDC: have $${spotUsdcAvail.toFixed(2)}, need ~$${sizeUsd}. Transfer may have failed.`;
+                if (isJson())
+                    return printJson(jsonOk({ error: msg, spotUsdcAvail, required: sizeUsd }));
+                console.log(chalk.red(`  ${msg}`));
+                return;
+            }
+            if (perpAvail < sizeUsd * 0.5) {
+                const msg = `Insufficient perp balance: have $${perpAvail.toFixed(2)} available on ${perpExch}, need margin for ~$${sizeUsd}`;
+                if (isJson())
+                    return printJson(jsonOk({ error: msg, perpAvail, required: sizeUsd }));
+                console.log(chalk.red(`  ${msg}`));
+                return;
+            }
+        }
+        catch {
+            // Balance check failed — continue with execution, let order placement catch errors
+        }
+        // 3. Fetch orderbooks simultaneously
+        const spotSymbol = `${sym}/USDC`;
+        if (!isJson())
+            console.log(chalk.gray(`  Checking orderbook depth (spot ${spotExch} + perp ${perpExch})...`));
+        const [spotBook, perpBook] = await Promise.all([
+            spotAdapter.getSpotOrderbook(spotSymbol),
+            perpAdapter.getOrderbook(sym),
+        ]);
+        // 3a. Price cross-validation: verify spot and perp are the same underlying
+        //     Prevents wrong-token trades if index mapping is incorrect
+        const spotMid = spotBook.bids.length > 0 && spotBook.asks.length > 0
+            ? (Number(spotBook.bids[0][0]) + Number(spotBook.asks[0][0])) / 2 : 0;
+        const perpMid = perpBook.bids.length > 0 && perpBook.asks.length > 0
+            ? (Number(perpBook.bids[0][0]) + Number(perpBook.asks[0][0])) / 2 : 0;
+        if (spotMid > 0 && perpMid > 0) {
+            const priceDeviation = Math.abs(spotMid - perpMid) / perpMid * 100;
+            if (priceDeviation > 5) {
+                const msg = `Price mismatch: spot mid $${spotMid.toFixed(4)} vs perp mid $${perpMid.toFixed(4)} (${priceDeviation.toFixed(1)}% deviation). Possible wrong token index — aborting.`;
+                if (isJson())
+                    return printJson(jsonOk({ error: msg, spotMid, perpMid, deviationPct: priceDeviation }));
+                console.log(chalk.red(`\n  ${msg}`));
+                return;
+            }
+        }
+        else if (spotMid === 0) {
+            const msg = `Empty spot orderbook for ${sym} — cannot verify token identity`;
+            if (isJson())
+                return printJson(jsonOk({ error: msg }));
+            console.log(chalk.red(`\n  ${msg}`));
+            return;
+        }
+        // 3b. Validate depth
+        const spotCheck = computeExecutableSize(spotBook.asks, sizeUsd, maxSlippage);
+        const perpCheck = computeExecutableSize(perpBook.bids, sizeUsd, maxSlippage);
+        if (!spotCheck.canFillFull || !perpCheck.canFillFull) {
+            const fillableUsd = Math.min(spotCheck.maxSize * spotCheck.avgFillPrice, perpCheck.maxSize * perpCheck.avgFillPrice);
+            if (isJson())
+                return printJson(jsonOk({
+                    error: "Insufficient orderbook depth",
+                    requestedUsd: sizeUsd, fillableUsd: Math.round(fillableUsd * 100) / 100,
+                    spot: { exchange: spotExch, depthUsd: spotCheck.depthUsd, canFill: spotCheck.canFillFull },
+                    perp: { exchange: perpExch, depthUsd: perpCheck.depthUsd, canFill: perpCheck.canFillFull },
+                }));
+            console.log(chalk.red(`\n  Insufficient depth for $${sizeUsd}:`));
+            console.log(chalk.gray(`    ${spotExch} spot asks: $${spotCheck.depthUsd.toFixed(0)}`));
+            console.log(chalk.gray(`    ${perpExch} perp bids: $${perpCheck.depthUsd.toFixed(0)}`));
+            return;
+        }
+        // 4. Compute matched size
+        const inferDecimals = (levels) => {
+            for (const [, s] of levels) {
+                const dot = s.indexOf(".");
+                if (dot >= 0)
+                    return s.length - dot - 1;
+            }
+            return 0;
+        };
+        const spotDecimals = inferDecimals(spotBook.asks);
+        const perpDecimals = inferDecimals(perpBook.bids);
+        const decimals = Math.min(spotDecimals, perpDecimals);
+        const matchedBase = Math.min(spotCheck.recommendedSize, perpCheck.recommendedSize);
+        const matchedSize = (Math.floor(matchedBase * 10 ** decimals) / 10 ** decimals).toFixed(decimals);
+        const avgPrice = (spotCheck.avgFillPrice + perpCheck.avgFillPrice) / 2;
+        const matchedUsd = matchedBase * avgPrice;
+        if (!isJson()) {
+            console.log(chalk.cyan(`\n  Spot+Perp Arb: ${sym}`));
+            console.log(chalk.gray(`    SPOT  ${spotExch}: buy  ${matchedSize} (~$${(matchedBase * spotCheck.avgFillPrice).toFixed(2)})`));
+            console.log(chalk.gray(`    PERP  ${perpExch}: sell ${matchedSize} (~$${(matchedBase * perpCheck.avgFillPrice).toFixed(2)})`));
+            console.log(chalk.gray(`    Executing both legs simultaneously...\n`));
+        }
+        // 5. Execute both legs (or return dry-run result)
+        if (dryRun) {
+            const result = {
+                status: "filled", mode: "spot-perp", symbol: sym, dryRun: true,
+                size: matchedSize, notionalUsd: Math.round(matchedUsd * 100) / 100,
+                spot: { exchange: spotExch, side: "buy", size: matchedSize },
+                perp: { exchange: perpExch, side: "sell", size: matchedSize },
+            };
+            if (isJson())
+                return printJson(jsonOk(result));
+            console.log(chalk.cyan(`  [DRY-RUN] Would execute: spot buy ${matchedSize} on ${spotExch} + perp sell ${matchedSize} on ${perpExch}`));
+            return;
+        }
+        // Same exchange (e.g. Lighter) shares nonce → must execute sequentially
+        // Different exchanges → execute simultaneously for speed
+        const validatePerpFill = (r) => {
+            const res = r;
+            const statuses = res?.response?.data?.statuses;
+            if (statuses && statuses.length > 0) {
+                const st = statuses[0];
+                if (st.error)
+                    throw new Error(`Perp sell ${sym}: ${st.error}`);
+                const filled = st.filled;
+                if (filled && Number(filled.totalSz ?? 0) === 0) {
+                    throw new Error(`Perp sell ${sym}: 0 fill`);
+                }
+            }
+            return r;
+        };
+        let spotResult;
+        let perpResult;
+        if (spotExch === perpExch) {
+            // Sequential: spot first, then perp (avoids nonce collision on same exchange)
+            spotResult = await spotAdapter.spotMarketOrder(spotSymbol, "buy", matchedSize)
+                .then(r => ({ status: "fulfilled", value: r }))
+                .catch(e => ({ status: "rejected", reason: e }));
+            if (spotResult.status === "fulfilled") {
+                perpResult = await perpAdapter.marketOrder(sym, "sell", matchedSize)
+                    .then(validatePerpFill)
+                    .then(r => ({ status: "fulfilled", value: r }))
+                    .catch(e => ({ status: "rejected", reason: e }));
+            }
+            else {
+                perpResult = { status: "rejected", reason: new Error("Skipped: spot failed") };
+            }
+        }
+        else {
+            // Parallel: different exchanges, no nonce conflict
+            [spotResult, perpResult] = await Promise.allSettled([
+                spotAdapter.spotMarketOrder(spotSymbol, "buy", matchedSize),
+                perpAdapter.marketOrder(sym, "sell", matchedSize).then(validatePerpFill),
+            ]);
+        }
+        const spotOk = spotResult.status === "fulfilled";
+        const perpOk = perpResult.status === "fulfilled";
+        if (spotOk && perpOk) {
+            // ── Post-execution fill verification ──
+            // Wait for exchange state to settle, then verify both legs actually filled
+            let fillVerified = true;
+            let verifyWarnings = [];
+            try {
+                await new Promise(r => setTimeout(r, 800));
+                // Verify spot: check base token balance appeared
+                const spotBals = await spotAdapter.getSpotBalances();
+                const baseToken = sym; // e.g. "ETH"
+                const spotTokenBal = spotBals.find(b => b.token.toUpperCase().startsWith(baseToken));
+                const spotTokenAmt = Number(spotTokenBal?.total ?? 0);
+                const expectedSize = parseFloat(matchedSize);
+                if (spotTokenAmt < expectedSize * 0.5) {
+                    fillVerified = false;
+                    verifyWarnings.push(`Spot buy may not have filled: expected ~${matchedSize} ${baseToken}, found ${spotTokenAmt.toFixed(6)}`);
+                }
+                // Verify perp: check short position exists
+                const perpPositions = await perpAdapter.getPositions();
+                const perpPos = perpPositions.find(p => p.symbol.replace("-PERP", "").toUpperCase() === sym && p.side === "short");
+                if (!perpPos) {
+                    fillVerified = false;
+                    verifyWarnings.push(`Perp short position not found for ${sym} on ${perpExch} — fill may not have executed`);
+                }
+                else if (Number(perpPos.size) < expectedSize * 0.5) {
+                    verifyWarnings.push(`Perp short size ${perpPos.size} < expected ${matchedSize} — partial fill?`);
+                }
+            }
+            catch (verifyErr) {
+                // Verification check itself failed — log but don't block
+                verifyWarnings.push(`Fill verification check failed: ${verifyErr instanceof Error ? verifyErr.message : String(verifyErr)}`);
+            }
+            if (verifyWarnings.length > 0 && !isJson()) {
+                for (const w of verifyWarnings) {
+                    console.log(chalk.yellow(`  ⚠ ${w}`));
+                }
+            }
+            if (!fillVerified) {
+                // Fills couldn't be confirmed — log as unverified but still persist
+                // (rolling back based on uncertain data is worse than persisting)
+                logExecution({
+                    type: "arb_entry", exchange: `spot:${spotExch}+${perpExch}`,
+                    symbol: sym, side: "entry", size: matchedSize,
+                    status: "unverified", dryRun: false,
+                    meta: { mode: "spot-perp", spotExch, perpExch, matchedUsd, warnings: verifyWarnings },
+                });
+            }
+            else {
+                // Log execution — verified
+                logExecution({
+                    type: "arb_entry", exchange: `spot:${spotExch}+${perpExch}`,
+                    symbol: sym, side: "entry", size: matchedSize,
+                    status: "success", dryRun: false,
+                    meta: { mode: "spot-perp", spotExch, perpExch, matchedUsd },
+                });
+            }
+            // Persist position state
+            persistAddPosition({
+                id: `${sym}-spot-${Date.now()}`,
+                symbol: sym,
+                longExchange: spotExch,
+                shortExchange: perpExch,
+                longSize: parseFloat(matchedSize),
+                shortSize: parseFloat(matchedSize),
+                entryTime: new Date().toISOString(),
+                entrySpread: 0, // Will be updated on next scan
+                entryLongPrice: spotCheck.avgFillPrice,
+                entryShortPrice: perpCheck.avgFillPrice,
+                accumulatedFunding: 0,
+                lastCheckTime: new Date().toISOString(),
+                mode: "spot-perp",
+                spotExchange: spotExch,
+                spotSymbol: spotSymbol,
+            });
+            // Return leftover USDC from spot back to perp (non-unified HL accounts)
+            if (spotExch === "hyperliquid") {
+                try {
+                    const hlSpot = spotAdapter;
+                    const bals = await hlSpot.getSpotBalances();
+                    const usdcBal = bals.find(b => b.token.startsWith("USDC"));
+                    const leftover = Number(usdcBal?.available ?? 0);
+                    if (leftover > 1) {
+                        const xfer = await hlSpot.transferUsdcToPerp(Math.floor(leftover));
+                        if (xfer?.status !== "err") {
+                            if (!isJson())
+                                console.log(chalk.gray(`  Returned ~$${Math.floor(leftover)} USDC to perp account`));
+                        }
+                    }
+                }
+                catch { /* non-critical — unified accounts don't need transfer */ }
+            }
+            const result = {
+                status: fillVerified ? "filled" : "filled_unverified",
+                mode: "spot-perp", symbol: sym,
+                size: matchedSize, notionalUsd: Math.round(matchedUsd * 100) / 100,
+                spot: { exchange: spotExch, side: "buy", size: matchedSize },
+                perp: { exchange: perpExch, side: "sell", size: matchedSize },
+                ...(verifyWarnings.length > 0 && { warnings: verifyWarnings }),
+            };
+            if (isJson())
+                return printJson(jsonOk(result));
+            if (fillVerified) {
+                console.log(chalk.green(`  FILLED (verified): ${sym} ${matchedSize} units (~$${matchedUsd.toFixed(2)})`));
+            }
+            else {
+                console.log(chalk.yellow(`  FILLED (unverified): ${sym} ${matchedSize} units (~$${matchedUsd.toFixed(2)})`));
+            }
+            console.log(chalk.green(`    SPOT  ${spotExch} ✓ (bought ${matchedSize})`));
+            console.log(chalk.green(`    PERP  ${perpExch} ✓ (shorted ${matchedSize})\n`));
+        }
+        else if (spotOk !== perpOk) {
+            // One leg failed — rollback
+            const filledSide = spotOk ? "spot" : "perp";
+            const failedSide = spotOk ? "perp" : "spot";
+            const failedErr = spotOk
+                ? perpResult.reason
+                : spotResult.reason;
+            const failedErrMsg = failedErr instanceof Error ? failedErr.message : String(failedErr);
+            if (!isJson()) {
+                console.log(chalk.yellow(`  PARTIAL: ${filledSide} OK, ${failedSide} FAILED — rolling back...`));
+                console.log(chalk.red(`    Reason: ${failedErrMsg}`));
+            }
+            let rollbackOk = false;
+            for (let attempt = 1; attempt <= 2; attempt++) {
+                try {
+                    if (spotOk) {
+                        await spotAdapter.spotMarketOrder(spotSymbol, "sell", matchedSize);
+                    }
+                    else {
+                        await perpAdapter.marketOrder(sym, "buy", matchedSize);
+                    }
+                    rollbackOk = true;
+                    break;
+                }
+                catch { /* retry */ }
+            }
+            logExecution({
+                type: "arb_entry", exchange: `spot:${spotExch}+${perpExch}`,
+                symbol: sym, side: "entry", size: matchedSize,
+                status: "failed", dryRun: false,
+                error: `Partial: ${failedSide} failed (${failedErrMsg}). Rollback: ${rollbackOk ? "ok" : "FAILED"}`,
+            });
+            const result = {
+                status: "partial_fill", mode: "spot-perp", symbol: sym,
+                filledSide, failedSide,
+                failedError: failedErrMsg,
+                rollback: rollbackOk ? "success" : "FAILED — MANUAL CLOSE REQUIRED",
+            };
+            if (isJson())
+                return printJson(jsonOk(result));
+            console.log(rollbackOk
+                ? chalk.yellow(`  Rollback OK — no open exposure.\n`)
+                : chalk.red.bold(`  ROLLBACK FAILED — ${filledSide} leg still open. Close manually!\n`));
+        }
+        else {
+            // Both failed
+            const spotErr = spotResult.reason;
+            const perpErr = perpResult.reason;
+            const result = {
+                status: "both_failed", mode: "spot-perp", symbol: sym,
+                spotError: spotErr instanceof Error ? spotErr.message : String(spotErr),
+                perpError: perpErr instanceof Error ? perpErr.message : String(perpErr),
+            };
+            if (isJson())
+                return printJson(jsonOk(result));
+            console.log(chalk.red(`  Both legs failed:`));
+            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();
+        // 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;
+        if (!spotExch || !perpExch) {
+            const msg = "Cannot determine exchanges. Specify --spot-exch and --perp-exch, or ensure the position is tracked in state.";
+            if (isJson())
+                return printJson(jsonOk({ error: msg }));
+            console.log(chalk.red(`  ${msg}`));
+            return;
+        }
+        // Load adapters
+        const { HyperliquidSpotAdapter } = await import("../exchanges/hyperliquid-spot.js");
+        const { LighterSpotAdapter } = await import("../exchanges/lighter-spot.js");
+        let spotAdapter;
+        if (spotExch === "hyperliquid") {
+            const hlAdapter = await getAdapterForExchange("hyperliquid");
+            const hlSpot = new HyperliquidSpotAdapter(hlAdapter);
+            await hlSpot.init();
+            spotAdapter = hlSpot;
+        }
+        else {
+            const ltAdapter = await getAdapterForExchange("lighter");
+            const ltSpot = new LighterSpotAdapter(ltAdapter);
+            await ltSpot.init();
+            spotAdapter = ltSpot;
+        }
+        const perpAdapter = await getAdapterForExchange(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())
+                return printJson(jsonOk({ error: msg }));
+            console.log(chalk.red(`  ${msg}`));
+            return;
+        }
+        const closeSize = perpPos.size;
+        if (!isJson()) {
+            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)`));
+            console.log(chalk.gray(`    Executing...\n`));
+        }
+        // Same exchange → sequential (nonce collision), different → parallel
+        let spotResult;
+        let perpResult;
+        if (spotExch === perpExch) {
+            // Sequential: sell spot first, then close perp
+            spotResult = await spotAdapter.spotMarketOrder(spotSymbol, "sell", closeSize)
+                .then(r => ({ status: "fulfilled", value: r }))
+                .catch(e => ({ status: "rejected", reason: e }));
+            perpResult = await perpAdapter.marketOrder(sym, "buy", closeSize)
+                .then(r => ({ status: "fulfilled", value: r }))
+                .catch(e => ({ status: "rejected", reason: e }));
+        }
+        else {
+            [spotResult, perpResult] = await Promise.allSettled([
+                spotAdapter.spotMarketOrder(spotSymbol, "sell", closeSize),
+                perpAdapter.marketOrder(sym, "buy", closeSize),
+            ]);
+        }
+        const spotOk = spotResult.status === "fulfilled";
+        const perpOk = perpResult.status === "fulfilled";
+        if (spotOk && perpOk) {
+            // ── Post-close fill verification ──
+            let closeVerified = true;
+            let closeWarnings = [];
+            try {
+                await new Promise(r => setTimeout(r, 800));
+                // Verify spot token was sold (balance should be near zero or gone)
+                const spotBals = await spotAdapter.getSpotBalances();
+                const baseToken = sym;
+                const spotTokenBal = spotBals.find(b => b.token.toUpperCase().startsWith(baseToken));
+                const remainingSpotAmt = Number(spotTokenBal?.total ?? 0);
+                const closedSize = parseFloat(closeSize);
+                if (remainingSpotAmt > closedSize * 0.5) {
+                    closeVerified = false;
+                    closeWarnings.push(`Spot sell may not have filled: still have ${remainingSpotAmt.toFixed(6)} ${baseToken} (expected ~0)`);
+                }
+                // Verify perp short was closed (position should be gone or reduced)
+                const perpPositionsAfter = await perpAdapter.getPositions();
+                const remainingPerpPos = perpPositionsAfter.find(p => p.symbol.replace("-PERP", "").toUpperCase() === sym && p.side === "short");
+                if (remainingPerpPos && Number(remainingPerpPos.size) > closedSize * 0.5) {
+                    closeVerified = false;
+                    closeWarnings.push(`Perp short still open: ${remainingPerpPos.size} ${sym} on ${perpExch} (expected closed)`);
+                }
+            }
+            catch (verifyErr) {
+                closeWarnings.push(`Close verification failed: ${verifyErr instanceof Error ? verifyErr.message : String(verifyErr)}`);
+            }
+            if (closeWarnings.length > 0 && !isJson()) {
+                for (const w of closeWarnings) {
+                    console.log(chalk.yellow(`  ⚠ ${w}`));
+                }
+            }
+            // Remove from state
+            persistRemovePosition(sym);
+            logExecution({
+                type: "arb_close", exchange: `spot:${spotExch}+${perpExch}`,
+                symbol: sym, side: "exit", size: closeSize,
+                status: closeVerified ? "success" : "unverified", dryRun: false,
+                meta: { mode: "spot-perp", ...(closeWarnings.length > 0 && { warnings: closeWarnings }) },
+            });
+            // Return spot USDC proceeds back to perp account
+            if (spotExch === "lighter") {
+                try {
+                    const ltSpot = spotAdapter;
+                    const bals = await ltSpot.getSpotBalances();
+                    const usdcBal = bals.find(b => b.token === "USDC");
+                    const leftover = Number(usdcBal?.available ?? 0);
+                    if (leftover > 0.01) {
+                        await ltSpot.transferUsdcToPerp(leftover);
+                        if (!isJson())
+                            console.log(chalk.gray(`  Returned ~$${leftover.toFixed(2)} USDC spot→perp on Lighter`));
+                    }
+                }
+                catch { /* non-critical */ }
+            }
+            else if (spotExch === "hyperliquid") {
+                try {
+                    const hlSpot = spotAdapter;
+                    const bals = await hlSpot.getSpotBalances();
+                    const usdcBal = bals.find(b => b.token.startsWith("USDC"));
+                    const leftover = Number(usdcBal?.available ?? 0);
+                    if (leftover > 1) {
+                        await hlSpot.transferUsdcToPerp(Math.floor(leftover));
+                    }
+                }
+                catch { /* non-critical */ }
+            }
+            const closeResult = {
+                status: closeVerified ? "closed" : "closed_unverified",
+                mode: "spot-perp", symbol: sym, size: closeSize,
+                ...(closeWarnings.length > 0 && { warnings: closeWarnings }),
+            };
+            if (isJson())
+                return printJson(jsonOk(closeResult));
+            if (closeVerified) {
+                console.log(chalk.green(`  CLOSED (verified): ${sym} ${closeSize} units`));
+            }
+            else {
+                console.log(chalk.yellow(`  CLOSED (unverified): ${sym} ${closeSize} units — check positions manually`));
+            }
+            console.log(chalk.green(`    SPOT  ${spotExch}: sold ✓`));
+            console.log(chalk.green(`    PERP  ${perpExch}: bought (closed short) ✓\n`));
+        }
+        else {
+            const errors = [];
+            if (!spotOk)
+                errors.push(`Spot sell failed: ${spotResult.reason}`);
+            if (!perpOk)
+                errors.push(`Perp buy failed: ${perpResult.reason}`);
+            const result = { status: "partial_close", symbol: sym, spotOk, perpOk, errors };
+            if (isJson())
+                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")
@@ -1048,7 +1866,7 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
         const spreads = await fetchFundingSpreads();
         const spreadMap = new Map(spreads.map(s => [s.symbol.toUpperCase(), s]));
         // Get fee rates (approximate)
-        const TAKER_FEE = 0.00035; // ~0.035% typical
+        const TAKER_FEE = getTakerFee("default");
         // Fetch actual settled funding payments from each exchange
         const actualFundingByExSymbol = new Map(); // "exchange:SYMBOL" → total settled USD
         for (const exName of exchangeNames) {
@@ -1400,7 +2218,7 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
                                     ]);
                                     logExecution({
                                         type: "arb_close", exchange: `${pos.longDex}+${pos.shortDex}`,
-                                        symbol: pos.underlying, side: "close", size: pos.size,
+                                        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 },
                                     });
@@ -1410,7 +2228,7 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
                                 catch (err) {
                                     logExecution({
                                         type: "arb_close", exchange: `${pos.longDex}+${pos.shortDex}`,
-                                        symbol: pos.underlying, side: "close", size: pos.size,
+                                        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 },