perp-cli 0.4.0 → 0.4.2

package/dist/arb/utils.d.ts

@@ -2,6 +2,8 @@
  * Arb utilities: settlement timing strategy, basis risk monitoring, and webhook notifications.
  */
 import type { ExchangeAdapter } from "../exchanges/interface.js";
+/** Settlement schedules per exchange (UTC hours when settlement occurs) */
+export declare const SETTLEMENT_SCHEDULES: Record<string, number[]>;
 export type SettleStrategy = "block" | "aggressive" | "off";
 /**
  * Get the most recent settlement time for an exchange.

package/dist/arb/utils.js

@@ -3,7 +3,7 @@
  */
 // ── Settlement Timing Strategy ──
 /** Settlement schedules per exchange (UTC hours when settlement occurs) */
-const SETTLEMENT_SCHEDULES = {
+export 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

package/dist/commands/agent.js

@@ -142,14 +142,14 @@ export function registerAgentCommands(program, getAdapter, isJson) {
                     category: "trading",
                     commands: [
                         "perp trade check <symbol> <side> <size> --json",
-                        "perp trade market <symbol> <buy|sell> <size> --json --client-id <id>",
+                        "perp trade market <symbol> <buy|sell> <size> --json [--smart] --client-id <id>",
                         "perp trade limit <symbol> <buy|sell> <price> <size> --json --client-id <id>",
                         "perp trade cancel <symbol> <orderId> --json",
                         "perp trade cancel-all --json",
-                        "perp trade close <symbol> --json",
-                        "perp trade close-all --json",
-                        "perp trade flatten --json",
-                        "perp trade reduce <symbol> <percent> --json",
+                        "perp trade close <symbol> --json [--smart]",
+                        "perp trade close-all --json [--smart]",
+                        "perp trade flatten --json [--smart]",
+                        "perp trade reduce <symbol> <percent> --json [--smart]",
                         "perp trade stop <symbol> <side> <stopPrice> <size> --json",
                         "perp trade tpsl <symbol> <side> --tp <price> --sl <price> --json",
                         "perp trade twap <symbol> <side> <size> <duration> --json",

package/dist/commands/arb/index.js

@@ -4,12 +4,14 @@ import { readExecutionLog, logExecution } from "../../execution-log.js";
 import { computeAnnualSpread } from "../../funding.js";
 import { fetchPacificaPrices, fetchHyperliquidMeta, fetchLighterOrderBookDetails, fetchLighterFundingRates, } from "../../shared-api.js";
 import { computeBasisRisk } from "../../arb-utils.js";
+import { smartOrder } from "../../smart-order.js";
+import { removePosition as persistRemovePosition } from "../../arb-state.js";
 import { fetchAllBalances, computeRebalancePlan } from "../../rebalance.js";
 import { EXCHANGE_TO_CHAIN, getBestQuote } from "../../bridge-engine.js";
 import { computeEnhancedStats } from "../../arb-history-stats.js";
 // ── Helpers ──
+import { DEFAULT_TAKER_FEE as TAKER_FEE } from "../../constants.js";
 const EXCHANGES = ["hyperliquid", "lighter", "pacifica"];
-const TAKER_FEE = 0.00035; // ~0.035% typical taker fee
 function formatDuration(ms) {
     const hours = Math.floor(ms / (1000 * 60 * 60));
     const days = Math.floor(hours / 24);
@@ -293,6 +295,7 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
         .description("Manually close an arb position on both exchanges")
         .option("--dry-run", "Show what would happen without executing")
         .option("--pair <pair>", "Specify arb pair as longExchange:shortExchange (e.g. pacifica:hyperliquid)")
+        .option("--smart", "Smart execution: IOC limit at best bid/ask + 1 tick (reduces slippage)")
         .action(async (symbol, opts) => {
         const sym = symbol.toUpperCase();
         const dryRun = !!opts.dryRun || process.argv.includes("--dry-run");
@@ -436,10 +439,15 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
             for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
                 try {
                     const adapter = await getAdapterForExchange(exchange);
-                    await adapter.marketOrder(rawSymbol, side, String(size));
+                    if (opts.smart) {
+                        await smartOrder(adapter, rawSymbol, side, String(size), { reduceOnly: true });
+                    }
+                    else {
+                        await adapter.marketOrder(rawSymbol, side, String(size));
+                    }
                     results.push({ exchange, action: `${side} (close ${label})`, status: "success", retries: attempt });
                     if (!isJson())
-                        console.log(chalk.green(`  Closed ${label} on ${exchange}: ${side.toUpperCase()} ${size} ${sym}${attempt > 0 ? ` (retry ${attempt})` : ""}`));
+                        console.log(chalk.green(`  Closed ${label} on ${exchange}: ${side.toUpperCase()} ${size} ${sym}${opts.smart ? " (smart)" : ""}${attempt > 0 ? ` (retry ${attempt})` : ""}`));
                     return;
                 }
                 catch (err) {
@@ -488,6 +496,13 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
                 console.log(chalk.yellow(`\n  Warning: Position may not be fully closed on: ${notClosed.map(v => v.exchange).join(", ")}`));
             }
         }
+        // Remove from persisted daemon state (so daemon doesn't try to re-close)
+        if (allSuccess) {
+            try {
+                persistRemovePosition(sym);
+            }
+            catch { /* state may not exist */ }
+        }
         // Log to execution log
         const arbPairId = `${sym}:${longPos.exchange}:${shortPos.exchange}`;
         logExecution({

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,7 +892,7 @@ 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)
@@ -798,6 +968,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 +1059,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 +1137,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;
                 }
@@ -1048,7 +1227,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 +1579,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 +1589,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 },

package/dist/commands/settings.d.ts

@@ -1,2 +1,3 @@
 import { Command } from "commander";
-export declare function registerSettingsCommands(program: Command, isJson: () => boolean): void;
+import type { ExchangeAdapter } from "../exchanges/interface.js";
+export declare function registerSettingsCommands(program: Command, isJson: () => boolean, getAdapterForExchange?: (exchange: string) => Promise<ExchangeAdapter>): void;