perp-cli 0.12.15 → 0.14.0

package/dist/commands/arb/index.js

@@ -1,18 +1,58 @@
+import { isDryRun, networkOf, supportsDryRun } from "../../cli-flags.js";
 import chalk from "chalk";
 import { makeTable, formatUsd, formatPnl, printJson, jsonOk, logSettledRejections } from "../../utils.js";
 import { SPOT_PERP_TOKEN_MAP } from "../../exchanges/index.js";
 import { readExecutionLog, logExecution } from "../../execution-log.js";
-import { toHourlyRate, computeAnnualSpread } from "../../funding.js";
+import { toHourlyRate } 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, getPositions as getArbStatePositions, loadArbState } 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";
+import { listBotSpotVenues, nonQuoteSpotBalances, requireSpotAdapter, spotNetworkOf } from "../../exchanges/spot-factory.js";
+import { listConfiguredAccountVenues } from "../../config.js";
+import { closePerpPairVerified, handleSpotClose } from "../arb-auto.js";
+import { quarantineEntryFor } from "../../bot/quarantine.js";
+import { PerpError, classifyError, parsePositiveDecimal } from "../../errors.js";
+import { listVenuesWithRole, resolveVenueId } from "../../exchanges/venue.js";
 // ── Helpers ──
 import { DEFAULT_TAKER_FEE as TAKER_FEE } from "../../constants.js";
-const EXCHANGES = ["hyperliquid", "lighter", "pacifica"];
+/**
+ * Venues an arb leg can sit on: every registered trading venue with a configured
+ * credential source (registry order). Never a hard-coded list — a venue added to the
+ * registry is covered by `arb status` / `arb close` without touching this file.
+ */
+export async function listArbVenues() {
+    const configured = await listConfiguredAccountVenues(); // registers the venues
+    const trading = new Set(listVenuesWithRole("trading").map(v => v.id));
+    return configured.filter(v => trading.has(v));
+}
+/**
+ * Positions of every venue in `venues`. A venue whose adapter cannot be built or whose
+ * positions read fails is an error (Rule #2): an unread venue is not "no positions" —
+ * a hidden leg would make a live pair look closed.
+ */
+export async function readArbVenuePositions(venues, getAdapter) {
+    const out = [];
+    for (const exchange of venues) {
+        let positions;
+        try {
+            positions = await (await getAdapter(exchange)).getPositions();
+        }
+        catch (e) {
+            const c = classifyError(e, exchange);
+            throw new PerpError(c.code, `Cannot read positions on ${exchange}: ${c.message}`, {
+                exchange,
+                venuesChecked: [...venues],
+                remediation: `Arb pairs are detected from every configured venue's positions, so none may be skipped. Check the venue: perp account positions -e ${exchange}`,
+            });
+        }
+        for (const position of positions)
+            out.push({ exchange, position });
+    }
+    return out;
+}
 function formatDuration(ms) {
     const hours = Math.floor(ms / (1000 * 60 * 60));
     const days = Math.floor(hours / 24);
@@ -24,6 +64,10 @@ function formatDuration(ms) {
     const minutes = Math.floor(ms / (1000 * 60));
     return `${minutes}m`;
 }
+/** hourly rate of a rate entry: the entry's own interval (Aster, per symbol) or the venue basis. */
+function entryHourly(e) {
+    return e.fundingHours !== null ? e.rate / e.fundingHours : toHourlyRate(e.rate, e.exchange);
+}
 async function fetchFundingRatesMap() {
     const rateMap = new Map();
     // SSOT rule #2: each DEX is independent. allSettled keeps the comparison
@@ -35,19 +79,28 @@ async function fetchFundingRatesMap() {
         fetchLighterOrderBookDetails(),
         fetchLighterFundingRates(),
         fetch("https://fapi.asterdex.com/fapi/v1/premiumIndex").then(r => r.json()),
+        fetch("https://fapi.asterdex.com/fapi/v3/fundingInfo").then(r => r.json()),
     ]);
-    logSettledRejections(settled, ["pacifica", "hyperliquid", "lighter:orderbook", "lighter:funding", "aster:premiumIndex"], "arb");
+    logSettledRejections(settled, ["pacifica", "hyperliquid", "lighter:orderbook", "lighter:funding", "aster:premiumIndex", "aster:fundingInfo"], "arb");
     const pacAssets = settled[0].status === "fulfilled" ? settled[0].value : [];
     const hlAssets = settled[1].status === "fulfilled" ? settled[1].value : [];
     const ltDetails = settled[2].status === "fulfilled" ? settled[2].value : [];
     const ltFunding = settled[3].status === "fulfilled" ? settled[3].value : [];
-    const asterPremiums = settled[4].status === "fulfilled" ? settled[4].value : [];
-    const addRate = (sym, exchange, rate, markPrice) => {
+    // Aster funding basis is per symbol: a rate is usable only with its fundingInfo interval.
+    const asterPremiums = settled[4].status === "fulfilled" && settled[5].status === "fulfilled" ? settled[4].value : [];
+    const asterInfo = settled[5].status === "fulfilled" ? settled[5].value : [];
+    const asterHours = new Map();
+    for (const row of Array.isArray(asterInfo) ? asterInfo : []) {
+        const h = Number(row.fundingIntervalHours);
+        if (typeof row.symbol === "string" && Number.isFinite(h) && h > 0)
+            asterHours.set(row.symbol, h);
+    }
+    const addRate = (sym, exchange, rate, markPrice, fundingHours = null) => {
         if (!sym)
             return;
         if (!rateMap.has(sym))
             rateMap.set(sym, []);
-        rateMap.get(sym).push({ exchange, rate, markPrice });
+        rateMap.get(sym).push({ exchange, rate, markPrice, fundingHours });
     };
     for (const p of pacAssets)
         addRate(p.symbol, "pacifica", p.funding, p.mark);
@@ -87,10 +140,71 @@ async function fetchFundingRatesMap() {
         const markPrice = Number(p.markPrice);
         if (!Number.isFinite(fundingRate) || !Number.isFinite(markPrice) || markPrice <= 0)
             continue;
-        addRate(rawSym.replace(/USDT$/, ""), "aster", fundingRate, markPrice);
+        const hours = asterHours.get(rawSym);
+        if (hours === undefined)
+            continue; // not in /fapi/v3/fundingInfo → cannot normalize
+        addRate(rawSym.replace(/USDT$/, ""), "aster", fundingRate, markPrice, hours);
     }
     return rateMap;
 }
+/**
+ * State-file entries the venues do not confirm: no live pair with the same symbol and
+ * legs. `arb status` reports them apart from the live pairs (the venue is the source of truth).
+ */
+export function staleArbStateEntries(persisted, livePerpPerp, liveSpotPerp) {
+    const out = [];
+    for (const st of persisted) {
+        const sym = st.symbol.toUpperCase();
+        const live = st.mode === "spot-perp"
+            ? liveSpotPerp.some(p => p.symbol === sym && p.perpExchange === st.shortExchange)
+            : livePerpPerp.some(p => p.symbol === sym && p.longExchange === st.longExchange && p.shortExchange === st.shortExchange);
+        if (live)
+            continue;
+        out.push({
+            id: st.id, symbol: sym, mode: st.mode === "spot-perp" ? "spot-perp" : "perp-perp",
+            longExchange: st.longExchange, shortExchange: st.shortExchange, entryTime: st.entryTime,
+            reason: st.mode === "spot-perp"
+                ? `no ${sym} perp short on ${st.shortExchange}`
+                : `no ${sym} long on ${st.longExchange} with a short on ${st.shortExchange}`,
+        });
+    }
+    return out;
+}
+/** Per-leg engine entries (funding-arb-strategy: one record per leg) within this window form one pair entry. */
+const LEG_PAIRING_WINDOW_MS = 10 * 60_000;
+/**
+ * Whether a live long/short pair was opened by arb: an arb state entry for exactly these legs
+ * ("state"), else the latest successful arb_entry for exactly these legs in the execution log —
+ * combined (meta.arbPairId / meta.longExchange + shortExchange) or per-leg (meta.leg long on the
+ * long venue + leg short on the short venue within 10 min) — with no successful arb_close of the
+ * pair after it ("executionLog"). Anything else is "inferred". Never a symbol-only match.
+ */
+export function arbPairProvenance(symbol, longExchange, shortExchange, persisted, records) {
+    const sym = symbol.toUpperCase();
+    if (persisted.some(p => p.mode !== "spot-perp" && p.symbol.toUpperCase() === sym && p.longExchange === longExchange && p.shortExchange === shortExchange))
+        return "state";
+    const pairId = `${sym}:${longExchange}:${shortExchange}`;
+    const mine = records.filter(r => r.status === "success" && r.symbol.toUpperCase() === sym);
+    const combined = (r) => r.meta?.arbPairId === pairId || (r.meta?.longExchange === longExchange && r.meta?.shortExchange === shortExchange);
+    const t = (r) => new Date(r.timestamp).getTime();
+    let entryAt = -Infinity;
+    for (const r of mine.filter(x => x.type === "arb_entry")) {
+        if (combined(r)) {
+            entryAt = Math.max(entryAt, t(r));
+            continue;
+        }
+        if (r.meta?.leg === "long" && r.exchange === longExchange) {
+            const short = mine.find(x => x.type === "arb_entry" && x.meta?.leg === "short" && x.exchange === shortExchange && Math.abs(t(x) - t(r)) <= LEG_PAIRING_WINDOW_MS);
+            if (short !== undefined)
+                entryAt = Math.max(entryAt, t(r), t(short));
+        }
+    }
+    if (entryAt === -Infinity)
+        return "inferred";
+    const closedAfter = mine.some(r => r.type === "arb_close" && t(r) > entryAt
+        && (combined(r) || (r.meta?.leg === "long" && r.exchange === longExchange) || (r.meta?.leg === "short" && r.exchange === shortExchange)));
+    return closedAfter ? "inferred" : "executionLog";
+}
 function findArbEntryForPair(symbol, longExchange, shortExchange) {
     const entries = readExecutionLog({ type: "arb_entry", symbol });
     const successful = entries.filter(e => e.status === "success");
@@ -118,7 +232,7 @@ function getCurrentSpreadForSymbol(symbol, longExchange, shortExchange, rateMap)
     const shortRate = rates.find(r => r.exchange === shortExchange);
     if (!longRate || !shortRate)
         return null;
-    return computeAnnualSpread(shortRate.rate, shortRate.exchange, longRate.rate, longRate.exchange);
+    return Math.abs(entryHourly(shortRate) - entryHourly(longRate)) * 24 * 365 * 100;
 }
 // ── Registration ──
 export function registerArbManageCommands(program, getAdapterForExchange, isJson) {
@@ -136,26 +250,18 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
             console.log(chalk.cyan("\n  Checking arb positions across exchanges...\n"));
         // Fetch positions from all exchanges
         const allPositions = [];
-        for (const exName of EXCHANGES) {
-            try {
-                const adapter = await getAdapterForExchange(exName);
-                const positions = await adapter.getPositions();
-                for (const p of positions) {
-                    allPositions.push({
-                        exchange: exName,
-                        symbol: p.symbol.replace("-PERP", "").toUpperCase(),
-                        side: p.side,
-                        size: Math.abs(Number(p.size)),
-                        entryPrice: Number(p.entryPrice),
-                        markPrice: Number(p.markPrice),
-                        unrealizedPnl: Number(p.unrealizedPnl),
-                        leverage: p.leverage,
-                    });
-                }
-            }
-            catch {
-                // exchange not configured, skip
-            }
+        const venuesChecked = await listArbVenues();
+        for (const { exchange, position: p } of await readArbVenuePositions(venuesChecked, getAdapterForExchange)) {
+            allPositions.push({
+                exchange,
+                symbol: p.symbol.replace("-PERP", "").toUpperCase(),
+                side: p.side,
+                size: Math.abs(Number(p.size)),
+                entryPrice: Number(p.entryPrice),
+                markPrice: Number(p.markPrice),
+                unrealizedPnl: Number(p.unrealizedPnl),
+                leverage: p.leverage,
+            });
         }
         // Group by symbol to detect arb pairs
         const bySymbol = new Map();
@@ -166,6 +272,8 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
         }
         // Find arb pairs: same symbol, different exchanges, one long + one short
         const arbPairs = [];
+        const persistedForPairs = getArbStatePositions(networkOf(program));
+        const arbRecords = [...readExecutionLog({ type: "arb_entry" }), ...readExecutionLog({ type: "arb_close" })];
         // Fetch current funding rates for spread calculation
         let rateMap;
         try {
@@ -222,6 +330,7 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
                         symbol,
                         longExchange: longPos.exchange,
                         shortExchange: shortPos.exchange,
+                        provenance: arbPairProvenance(symbol, longPos.exchange, shortPos.exchange, persistedForPairs, arbRecords),
                         longPosition: {
                             side: "long",
                             size: longPos.size,
@@ -270,34 +379,23 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
         };
         // Collect spot balances per exchange
         const spotBalancesByExchange = new Map();
-        const SPOT_EXCHANGES = ["hyperliquid", "lighter"];
-        for (const exName of SPOT_EXCHANGES) {
+        // Bot/arb spot scope (§12.4 #3): configured venues with a separate spot balance + transfer.
+        const configuredVenues = new Set(await listConfiguredAccountVenues());
+        for (const def of listBotSpotVenues()) {
+            if (!configuredVenues.has(def.id))
+                continue;
             try {
-                const adapter = await getAdapterForExchange(exName);
-                if (exName === "hyperliquid") {
-                    const { HyperliquidSpotAdapter } = await import("../../exchanges/hyperliquid-spot.js");
-                    const hlSpot = new HyperliquidSpotAdapter(adapter);
-                    await hlSpot.init();
-                    const balances = await hlSpot.getSpotBalances();
-                    spotBalancesByExchange.set(exName, balances.filter(b => {
-                        const base = b.token.replace(/-SPOT$/i, "").toUpperCase();
-                        return base !== "USDC" && Number(b.total) > 0;
-                    }));
-                }
-                else if (exName === "lighter") {
-                    const { LighterSpotAdapter } = await import("../../exchanges/lighter-spot.js");
-                    const ltSpot = new LighterSpotAdapter(adapter);
-                    await ltSpot.init();
-                    const balances = await ltSpot.getSpotBalances();
-                    spotBalancesByExchange.set(exName, balances.filter(b => b.token !== "USDC" && b.token !== "USDC_SPOT" && Number(b.total) > 0));
-                }
+                const adapter = await getAdapterForExchange(def.id);
+                const spot = await requireSpotAdapter(def.id, adapter);
+                spotBalancesByExchange.set(def.id, nonQuoteSpotBalances(def, spotNetworkOf(spot), await spot.getSpotBalances()));
             }
-            catch {
-                // exchange not configured or no spot support
+            catch (e) {
+                process.stderr.write(`[warn] ${def.displayName} spot balances unavailable: ${e instanceof Error ? e.message : String(e)}\n`);
             }
         }
         // Load persisted arb state for spot-perp entries
-        const persistedSpotPerp = getArbStatePositions().filter(p => p.mode === "spot-perp");
+        const persistedAll = getArbStatePositions(networkOf(program));
+        const persistedSpotPerp = persistedAll.filter(p => p.mode === "spot-perp");
         const persistedSymbols = new Set(persistedSpotPerp.map(p => p.symbol.toUpperCase()));
         // Match: spot balance + perp short on same symbol (different or same exchange)
         for (const [spotEx, balances] of spotBalancesByExchange) {
@@ -313,14 +411,18 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
                 if (refPrice > 0 && spotAmount * refPrice < 1)
                     continue;
                 for (const shortPos of matchingShorts) {
-                    // Check if this short is already used by a perp-perp pair
-                    const usedByPerpPerp = arbPairs.some(ap => ap.symbol === perpSymbol && ap.shortExchange === shortPos.exchange);
+                    // Check if this short is already used by a CONFIRMED perp-perp pair
+                    const usedByPerpPerp = arbPairs.some(ap => ap.symbol === perpSymbol && ap.shortExchange === shortPos.exchange && ap.provenance !== "inferred");
                     if (usedByPerpPerp)
                         continue;
                     // Look up persisted state for hold time and entry info
                     const persisted = persistedSpotPerp.find(p => p.symbol.toUpperCase() === perpSymbol
                         && p.spotExchange === spotEx
                         && p.shortExchange === shortPos.exchange);
+                    // The arb's own spot size (the state entry), never the whole holding (pre-existing spot is reported apart).
+                    const heldSpotAmount = spotAmount;
+                    const arbSpotAmount = persisted !== undefined ? Math.min(persisted.longSize, heldSpotAmount) : heldSpotAmount;
+                    const otherSpotAmount = Math.max(0, heldSpotAmount - arbSpotAmount);
                     const entryTime = persisted?.entryTime ?? null;
                     const holdDurationMs = entryTime ? Date.now() - new Date(entryTime).getTime() : null;
                     const holdDuration = holdDurationMs ? formatDuration(holdDurationMs) : null;
@@ -328,10 +430,10 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
                     const rates = rateMap.get(perpSymbol);
                     const perpRate = rates?.find(r => r.exchange === shortPos.exchange);
                     const fundingRate = perpRate?.rate ?? 0;
-                    const hourlyRate = fundingRate ? toHourlyRate(fundingRate, shortPos.exchange) : 0;
+                    const hourlyRate = perpRate && fundingRate ? entryHourly(perpRate) : 0;
                     const annualPct = hourlyRate * 8760 * 100;
                     const perpNotional = shortPos.size * shortPos.markPrice;
-                    const spotValueUsd = spotAmount * shortPos.markPrice; // approx using perp mark price
+                    const spotValueUsd = arbSpotAmount * shortPos.markPrice; // approx using perp mark price
                     // Funding income: fetch actual payments from exchange API
                     let actualFundingIncome = 0;
                     try {
@@ -368,7 +470,10 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
                         spotExchange: spotEx,
                         perpExchange: shortPos.exchange,
                         spotToken: bal.token.replace(/-SPOT$/i, ""),
-                        spotAmount,
+                        spotAmount: arbSpotAmount,
+                        heldSpotAmount,
+                        otherSpotAmount,
+                        confirmed: persisted !== undefined,
                         spotValueUsd,
                         perpSide: "short",
                         perpSize: shortPos.size,
@@ -383,7 +488,7 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
                         holdDurationMs,
                         estimatedFundingIncome,
                         estimatedFees: entryFees,
-                        netPnl: (spotValueUsd - shortPos.entryPrice * spotAmount) + shortPos.unrealizedPnl + estimatedFundingIncome - entryFees,
+                        netPnl: (spotValueUsd - shortPos.entryPrice * arbSpotAmount) + shortPos.unrealizedPnl + estimatedFundingIncome - entryFees,
                         dailyFundingEstimate,
                     });
                 }
@@ -402,7 +507,7 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
             const holdDurationMs = Date.now() - new Date(persisted.entryTime).getTime();
             const rates = rateMap.get(sym);
             const perpRate = rates?.find(r => r.exchange === persisted.shortExchange);
-            const hourlyRate = perpRate ? toHourlyRate(perpRate.rate, persisted.shortExchange) : 0;
+            const hourlyRate = perpRate ? entryHourly(perpRate) : 0;
             const perpNotional = shortPos.size * shortPos.markPrice;
             spotPerpPositions.push({
                 symbol: sym,
@@ -411,6 +516,9 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
                 perpExchange: persisted.shortExchange,
                 spotToken: "?",
                 spotAmount: 0,
+                heldSpotAmount: 0,
+                otherSpotAmount: 0,
+                confirmed: true,
                 spotValueUsd: 0,
                 perpSide: "short",
                 perpSize: shortPos.size,
@@ -429,6 +537,13 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
                 dailyFundingEstimate: Math.abs(hourlyRate) * perpNotional * 24,
             });
         }
+        // State vs venue: the venue is the source of truth. A pair is reported only when the
+        // venues show its legs; the state file contributes entry time / funding to a pair that
+        // is live. State entries with no live counterpart are listed apart, never as positions.
+        const staleStateEntries = staleArbStateEntries(persistedAll, arbPairs, spotPerpPositions);
+        // Pairs only inferred from a long and a short sharing the symbol are reported apart (never as arb positions).
+        const unconfirmedPairs = arbPairs.filter(p => p.provenance === "inferred");
+        arbPairs.splice(0, arbPairs.length, ...arbPairs.filter(p => p.provenance !== "inferred"));
         // ── JSON output ──
         if (isJson()) {
             const totalNotionalPP = arbPairs.reduce((s, p) => s + (p.longPosition.notionalUsd + p.shortPosition.notionalUsd) / 2, 0);
@@ -440,6 +555,9 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
             return printJson(jsonOk({
                 perpPerpPairs: arbPairs,
                 spotPerpPairs: spotPerpPositions,
+                venuesChecked,
+                staleStateEntries,
+                unconfirmedPairs,
                 aggregate: {
                     perpPerpCount: arbPairs.length,
                     spotPerpCount: spotPerpPositions.length,
@@ -454,8 +572,14 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
                 },
             }));
         }
+        for (const st of staleStateEntries) {
+            console.log(chalk.yellow(`  Stale state entry (not on the venue, not counted): ${st.symbol} ${st.mode} ${st.longExchange}/${st.shortExchange} since ${st.entryTime} — drop it: perp arb close ${st.symbol} --state-only`));
+        }
+        for (const u of unconfirmedPairs) {
+            console.log(chalk.gray(`  Unconfirmed (inferred, not counted): ${u.symbol} long ${u.longExchange} ${u.longPosition.size} / short ${u.shortExchange} ${u.shortPosition.size} — no arb state / entry record for these legs; close only knowingly: perp arb close ${u.symbol} --pair ${u.longExchange}:${u.shortExchange}`));
+        }
         if (arbPairs.length === 0 && spotPerpPositions.length === 0) {
-            console.log(chalk.gray("  No open arb positions found.\n"));
+            console.log(chalk.gray(`  No open arb positions found on ${venuesChecked.join(", ")}.\n`));
             return;
         }
         // ── Perp-Perp table ──
@@ -505,7 +629,7 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
                 const legRows = [
                     [
                         chalk.green("Spot"),
-                        `${sp.spotAmount.toFixed(4)} ${sp.spotToken}`,
+                        `${sp.spotAmount.toFixed(4)} ${sp.spotToken}${sp.otherSpotAmount > 0 ? chalk.gray(` (+${sp.otherSpotAmount.toFixed(4)} other)`) : ""}${sp.confirmed ? "" : chalk.yellow(" (unconfirmed)")}`,
                         `$${sp.perpEntryPrice.toFixed(4)}`,
                         `$${spotPriceEach.toFixed(4)}`,
                         formatPnl(spotPnl),
@@ -564,178 +688,107 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
         // Always show actual funding payments earned
         await printFundingEarned(getAdapterForExchange, isJson, { period: opts.period, symbol: opts.symbol });
     });
+    /**
+     * `arb close <sym> --state-only`: delete the arb state entry of `sym` ONLY when the venues show
+     * no live position for it (the same reconciliation as `arb status` staleStateEntries). Without
+     * --yes (or with --dry-run) the entry is only shown. Nothing is sent to any venue.
+     */
+    async function dropStaleStateEntry(sym, yes, dryRun) {
+        const net = networkOf(program);
+        const entries = getArbStatePositions(net).filter(p => p.symbol.toUpperCase() === sym);
+        if (entries.length === 0) {
+            throw new PerpError("POSITION_NOT_FOUND", `No arb state entry for ${sym} on ${net}`, { remediation: "See the state entries: perp arb status" });
+        }
+        const venuesChecked = await listArbVenues();
+        const live = (await readArbVenuePositions(venuesChecked, getAdapterForExchange))
+            .filter(x => x.position.symbol.replace("-PERP", "").toUpperCase() === sym)
+            .map(x => ({ exchange: x.exchange, side: x.position.side }));
+        const livePerp = live.filter(l => l.side === "long").flatMap(l => live.filter(s => s.side === "short" && s.exchange !== l.exchange).map(s => ({ symbol: sym, longExchange: l.exchange, shortExchange: s.exchange })));
+        const liveSpot = live.filter(l => l.side === "short").map(s => ({ symbol: sym, spotExchange: "", perpExchange: s.exchange }));
+        const stale = staleArbStateEntries(entries, livePerp, liveSpot);
+        if (stale.length !== entries.length) {
+            throw new PerpError("INVALID_PARAMS", `The ${sym} arb state entry is not stale: the venues still show its legs — close it instead: perp arb close ${sym}`, {
+                live, remediation: `Close the position: perp arb close ${sym}`,
+            });
+        }
+        if (!yes || dryRun) {
+            if (isJson())
+                return printJson(jsonOk({ symbol: sym, staleStateEntries: stale, deleted: false, remediation: `Confirm: perp arb close ${sym} --state-only --yes` }));
+            for (const st of stale)
+                console.log(chalk.yellow(`  Stale ${st.mode} ${st.symbol} ${st.longExchange}/${st.shortExchange} since ${st.entryTime} (${st.reason})`));
+            console.log(chalk.gray(`  Nothing deleted. Confirm: perp arb close ${sym} --state-only --yes\n`));
+            return;
+        }
+        persistRemovePosition(net, sym);
+        if (isJson())
+            return printJson(jsonOk({ symbol: sym, staleStateEntries: stale, deleted: true }));
+        console.log(chalk.green(`  Dropped the stale ${sym} arb state entry (${net}). No order was sent.\n`));
+    }
     // ── arb close ──
-    arb
-        .command("close <symbol>")
-        .description("Manually close an arb position on both exchanges")
-        .option("--dry-run", "Show what would happen without executing")
+    supportsDryRun(arb.command("close <symbol>"))
+        .description("Manually close an arb position on both exchanges (supports --dry-run)")
         .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)")
-        .option("--spot-exch <exchange>", "Override spot exchange for spot-perp close (hl or lt)")
-        .option("--perp-exch <exchange>", "Override perp exchange for spot-perp close")
-        .action(async (symbol, opts) => {
+        .option("--spot-exch <exchange>", "Override spot exchange for spot-perp close (a bot spot venue: hl, lt, lrh, aster, ondo)")
+        .option("--perp-exch <exchange>", "Override perp exchange for spot-perp close. With both --spot-exch and --perp-exch the close needs no arb-state entry: it sells the spot and buys back the live perp short of <symbol> on those venues")
+        .option("--force", "Act on a quarantined symbol (after checking its positions by hand)")
+        .option("--state-only", "Drop a STALE arb state entry of <symbol> (one `arb status` lists under staleStateEntries: no live position on the venues) — sends no order; refused while the venues still show it")
+        .option("--yes", "With --state-only: confirm the deletion (without it, the entry is only shown)")
+        .action(async (symbol, opts, cmd) => {
         const sym = symbol.toUpperCase();
-        const dryRun = !!opts.dryRun || process.argv.includes("--dry-run");
+        const dryRun = isDryRun(cmd);
+        if (opts.stateOnly) {
+            await dropStaleStateEntry(sym, opts.yes === true, dryRun);
+            return;
+        }
+        // Global quarantine (design §12.3): an unknown / unhedged outcome was recorded for
+        // this symbol. A human may still close it, but only knowingly (--force).
+        const quarantined = quarantineEntryFor(sym, (m) => console.error(chalk.red(m)));
+        if (quarantined !== null) {
+            if (!opts.force && !dryRun) {
+                throw new PerpError("RISK_VIOLATION", `${sym} is quarantined (${quarantined.strategy}: ${quarantined.reason})`, {
+                    remediation: `${quarantined.remediation}. To close it anyway after checking the positions: perp arb close ${sym} --force`,
+                });
+            }
+            if (!isJson())
+                console.error(chalk.yellow(`  WARNING: ${sym} is quarantined (${quarantined.strategy}: ${quarantined.reason})${opts.force ? " — proceeding (--force)" : ""}. The quarantine is NOT cleared by this close: perp strategy quarantine-clear ${sym}`));
+        }
         // Check if this is a spot-perp position (auto-detect from arb state)
-        const arbState = loadArbState();
+        const arbState = loadArbState(networkOf(program));
         const statePos = arbState?.positions?.find(p => p.symbol.toUpperCase() === sym && p.mode === "spot-perp");
-        if (statePos) {
+        // Explicit --spot-exch + --perp-exch select the spot-perp close without a state entry
+        // (e.g. a pair opened by a strategy bot); the handler sizes it from live positions.
+        if ((opts.spotExch === undefined) !== (opts.perpExch === undefined)) {
+            throw new PerpError("INVALID_PARAMS", "--spot-exch and --perp-exch must be given together", {
+                remediation: `perp arb close ${sym} --spot-exch <spot venue> --perp-exch <perp venue>`,
+            });
+        }
+        const explicitSpotPerp = opts.spotExch !== undefined && opts.perpExch !== undefined;
+        if (statePos || explicitSpotPerp) {
             // ── Inline spot-perp close logic ──
-            const aliasMap = { hl: "hyperliquid", pac: "pacifica", lt: "lighter" };
-            const spotExch = aliasMap[opts.spotExch?.toLowerCase() ?? ""] || opts.spotExch?.toLowerCase() || statePos.spotExchange || statePos.longExchange;
-            const perpExch = aliasMap[opts.perpExch?.toLowerCase() ?? ""] || opts.perpExch?.toLowerCase() || statePos.shortExchange;
+            // Venue ids through the registry (every alias, e.g. lrh / ast); a stored spot venue may carry "-spot".
+            const venueIdOf = (v) => resolveVenueId(v.replace(/-spot$/i, ""));
+            const spotRaw = opts.spotExch ?? statePos?.spotExchange ?? statePos?.longExchange;
+            const perpRaw = opts.perpExch ?? statePos?.shortExchange;
+            const spotExch = spotRaw === undefined ? undefined : venueIdOf(spotRaw);
+            const perpExch = perpRaw === undefined ? undefined : venueIdOf(perpRaw);
             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 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);
-            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) {
-                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;
-                const closeWarnings = [];
-                try {
-                    await new Promise(r => setTimeout(r, 800));
-                    const spotBals = await spotAdapter.getSpotBalances();
-                    const spotTokenBal = spotBals.find(b => b.token.toUpperCase().startsWith(sym));
-                    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)} ${sym} (expected ~0)`);
-                    }
-                    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(`  Warning: ${w}`));
-                }
-                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 }) },
+                throw new PerpError("INVALID_PARAMS", "Cannot determine the spot and perp exchanges of this spot-perp position", {
+                    remediation: `Pass both: perp arb close ${sym} --spot-exch <spot venue> --perp-exch <perp venue>`,
                 });
-                // 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 (dryRun) {
+                // Dry-run: nothing is sold, bought or transferred.
+                const plan = { status: "simulated", dryRun: true, sent: false, mode: "spot-perp", symbol: sym, spotExchange: spotExch, perpExchange: perpExch, longSize: statePos ? statePos.longSize : null, shortSize: statePos ? statePos.shortSize : null };
                 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`));
+                    return printJson(jsonOk(plan));
+                console.log(chalk.cyan(`  [DRY-RUN] Would close spot-perp ${sym}: sell spot on ${spotExch} + buy back the perp short on ${perpExch}`));
+                return;
             }
+            // One implementation for spot-perp close (fill-checked legs, §12.4 #5): arb-auto's handler.
+            if (handleSpotClose === undefined)
+                throw new Error("spot-perp close handler is not registered (registerArbAutoCommands not called)");
+            await handleSpotClose(sym, { spotExch, perpExch }, getAdapterForExchange, isJson);
             return;
         }
         // ── Perp-perp close logic (original) ──
@@ -746,91 +799,84 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
         }
         // Find positions for this symbol across all exchanges
         const allPositions = [];
-        for (const exName of EXCHANGES) {
-            try {
-                const adapter = await getAdapterForExchange(exName);
-                const positions = await adapter.getPositions();
-                for (const p of positions) {
-                    const normalized = p.symbol.replace("-PERP", "").toUpperCase();
-                    if (normalized === sym) {
-                        allPositions.push({
-                            exchange: exName,
-                            symbol: normalized,
-                            rawSymbol: p.symbol,
-                            side: p.side,
-                            size: Math.abs(Number(p.size)),
-                            entryPrice: Number(p.entryPrice),
-                            markPrice: Number(p.markPrice),
-                            unrealizedPnl: Number(p.unrealizedPnl),
-                        });
-                    }
-                }
-            }
-            catch {
-                // exchange not configured, skip
-            }
+        const venuesChecked = await listArbVenues();
+        for (const { exchange, position: p } of await readArbVenuePositions(venuesChecked, getAdapterForExchange)) {
+            const normalized = p.symbol.replace("-PERP", "").toUpperCase();
+            if (normalized !== sym)
+                continue;
+            allPositions.push({
+                exchange,
+                symbol: normalized,
+                rawSymbol: p.symbol,
+                side: p.side,
+                size: Math.abs(Number(p.size)),
+                sizeRaw: String(p.size).trim().replace(/^[-+]/, ""), // venue's own size string, used verbatim for the close
+                entryPrice: Number(p.entryPrice),
+                markPrice: Number(p.markPrice),
+                unrealizedPnl: Number(p.unrealizedPnl),
+            });
         }
-        // Find all possible arb pairs (long on one exchange, short on another)
+        // Find all possible arb pairs (long on one exchange, short on another), each with its provenance:
+        // only pairs opened by arb (state / entry record) are closed without --pair.
         const possiblePairs = [];
         const longs = allPositions.filter(p => p.side === "long");
         const shorts = allPositions.filter(p => p.side === "short");
+        const persistedForClose = getArbStatePositions(networkOf(program));
+        const closeRecords = [...readExecutionLog({ type: "arb_entry", symbol: sym }), ...readExecutionLog({ type: "arb_close", symbol: sym })];
         for (const l of longs) {
             for (const s of shorts) {
                 if (l.exchange !== s.exchange)
-                    possiblePairs.push({ long: l, short: s });
+                    possiblePairs.push({ long: l, short: s, provenance: arbPairProvenance(sym, l.exchange, s.exchange, persistedForClose, closeRecords) });
             }
         }
+        const confirmedPairs = possiblePairs.filter(p => p.provenance !== "inferred");
         // If --pair specified, filter to that specific pair
         let longPos;
         let shortPos;
         if (opts.pair) {
-            const [longEx, shortEx] = opts.pair.split(":");
+            const parts = opts.pair.split(":");
+            if (parts.length !== 2 || parts[0] === "" || parts[1] === "") {
+                throw new PerpError("INVALID_PARAMS", `--pair must be longExchange:shortExchange, got "${opts.pair}"`, { remediation: `Example: perp arb close ${sym} --pair aster:arcus` });
+            }
+            const longEx = resolveVenueId(parts[0]);
+            const shortEx = resolveVenueId(parts[1]);
             const match = possiblePairs.find(p => p.long.exchange === longEx && p.short.exchange === shortEx);
             if (match) {
                 longPos = match.long;
                 shortPos = match.short;
             }
         }
-        else if (possiblePairs.length === 1) {
-            longPos = possiblePairs[0].long;
-            shortPos = possiblePairs[0].short;
-        }
-        else if (possiblePairs.length > 1) {
-            // Multiple pairs found — require explicit --pair selection
-            const msg = `Multiple arb pairs found for ${sym}. Use --pair to specify which one to close.`;
-            if (isJson()) {
-                return printJson(jsonOk({
-                    error: msg,
-                    pairs: possiblePairs.map(p => ({
-                        arbPairId: `${sym}:${p.long.exchange}:${p.short.exchange}`,
-                        longExchange: p.long.exchange,
-                        shortExchange: p.short.exchange,
-                        longSize: p.long.size,
-                        shortSize: p.short.size,
-                    })),
-                }));
-            }
-            console.log(chalk.red(`  ${msg}\n`));
-            console.log(chalk.white("  Available pairs:"));
-            for (const p of possiblePairs) {
-                console.log(chalk.gray(`    --pair ${p.long.exchange}:${p.short.exchange}  (long ${p.long.size} / short ${p.short.size})`));
-            }
-            console.log();
-            return;
+        else if (confirmedPairs.length === 1) {
+            longPos = confirmedPairs[0].long;
+            shortPos = confirmedPairs[0].short;
+        }
+        else if (confirmedPairs.length > 1 || possiblePairs.length > 0) {
+            // Several arb pairs, or only pairs inferred from unrelated positions: never guessed — --pair required.
+            const onlyInferred = confirmedPairs.length === 0;
+            throw new PerpError("INVALID_PARAMS", onlyInferred
+                ? `No ${sym} pair opened by arb (no arb state / entry record for these legs); ${possiblePairs.length} unconfirmed long/short combination(s) found. Use --pair to close one knowingly.`
+                : `Multiple arb pairs found for ${sym}. Use --pair to specify which one to close.`, {
+                pairs: possiblePairs.map(p => ({
+                    arbPairId: `${sym}:${p.long.exchange}:${p.short.exchange}`,
+                    longExchange: p.long.exchange,
+                    shortExchange: p.short.exchange,
+                    longSize: p.long.size,
+                    shortSize: p.short.size,
+                    provenance: p.provenance,
+                })),
+                remediation: `Pick one: ${(onlyInferred ? possiblePairs : confirmedPairs).map(p => `--pair ${p.long.exchange}:${p.short.exchange}`).join(" | ")}`,
+            });
         }
         if (!longPos || !shortPos) {
-            const msg = `No arb pair found for ${sym}. Need long and short on different exchanges.`;
-            if (isJson())
-                return printJson(jsonOk({ error: msg, positions: allPositions }));
-            console.log(chalk.red(`  ${msg}`));
-            if (allPositions.length > 0) {
-                console.log(chalk.gray(`  Found ${allPositions.length} position(s) but no matching arb pair:`));
-                for (const p of allPositions) {
-                    console.log(chalk.gray(`    ${p.side.toUpperCase()} ${p.exchange} size=${p.size}`));
-                }
-            }
-            console.log();
-            return;
+            const found = allPositions.map(p => `${p.side} ${p.sizeRaw} on ${p.exchange}`).join(", ");
+            throw new PerpError("POSITION_NOT_FOUND", `No arb pair found for ${sym}${opts.pair ? ` on ${opts.pair}` : ""}. Need long and short on different exchanges.`, {
+                symbol: sym,
+                venuesChecked,
+                positions: allPositions.map(p => ({ exchange: p.exchange, side: p.side, size: p.sizeRaw })),
+                remediation: allPositions.length > 0
+                    ? `${sym} positions found: ${found}. Close a single leg with: perp trade close ${sym} -e <exchange>`
+                    : `No ${sym} position on ${venuesChecked.join(", ")}. See the live pairs: perp arb status`,
+            });
         }
         // Calculate estimated PnL
         const totalUpnl = longPos.unrealizedPnl + shortPos.unrealizedPnl;
@@ -851,6 +897,7 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
         if (dryRun) {
             const result = {
                 dryRun: true,
+                sent: false,
                 symbol: sym,
                 longExchange: longPos.exchange,
                 shortExchange: shortPos.exchange,
@@ -871,77 +918,36 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
             console.log(chalk.yellow(`    BUY ${shortPos.size} ${shortPos.rawSymbol} on ${shortPos.exchange} (close short)\n`));
             return;
         }
-        // Execute close on both exchanges with retry
-        const MAX_RETRIES = 2;
+        // Close the legs sequentially (long, then short), reduce-only and verified, each
+        // sized from the venue's own position size. No retries: a definite failure of the
+        // long close changes nothing; an unknown outcome or a leg left open after the
+        // other closed quarantines the symbol (design §12.3).
         const results = [];
-        async function closeWithRetry(exchange, rawSymbol, side, size, label) {
-            let lastError = "";
-            for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
-                try {
-                    const adapter = await getAdapterForExchange(exchange);
-                    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}${opts.smart ? " (smart)" : ""}${attempt > 0 ? ` (retry ${attempt})` : ""}`));
-                    return;
-                }
-                catch (err) {
-                    lastError = err instanceof Error ? err.message : String(err);
-                    if (attempt < MAX_RETRIES) {
-                        if (!isJson())
-                            console.log(chalk.yellow(`  Retry ${attempt + 1}/${MAX_RETRIES} for ${label} on ${exchange}...`));
-                        await new Promise(r => setTimeout(r, 1000 * (attempt + 1)));
-                    }
-                }
+        const closeRes = await closePerpPairVerified({
+            source: "arb-close", sym,
+            longAdapter: await getAdapterForExchange(longPos.exchange), longExch: longPos.exchange, longSym: longPos.rawSymbol, longSize: longPos.sizeRaw,
+            shortAdapter: await getAdapterForExchange(shortPos.exchange), shortExch: shortPos.exchange, shortSym: shortPos.rawSymbol, shortSize: shortPos.sizeRaw,
+            smart: !!opts.smart,
+            log: (m) => console.error(chalk.red(m)),
+        });
+        if (closeRes.status === "closed") {
+            results.push({ exchange: longPos.exchange, action: "sell (close long)", status: "success" });
+            results.push({ exchange: shortPos.exchange, action: "buy (close short)", status: "success" });
+            if (!isJson()) {
+                console.log(chalk.green(`  Closed long on ${longPos.exchange}: SELL ${longPos.sizeRaw} ${sym} (reduce-only, verified${opts.smart ? ", smart" : ""})`));
+                console.log(chalk.green(`  Closed short on ${shortPos.exchange}: BUY ${shortPos.sizeRaw} ${sym} (reduce-only, verified${opts.smart ? ", smart" : ""})`));
             }
-            results.push({ exchange, action: `${side} (close ${label})`, status: "failed", error: lastError, retries: MAX_RETRIES });
+        }
+        else {
+            results.push({ exchange: `${longPos.exchange}+${shortPos.exchange}`, action: "close", status: closeRes.status, error: closeRes.reason });
             if (!isJson())
-                console.error(chalk.red(`  Failed to close ${label} on ${exchange}: ${lastError}`));
-        }
-        // Close both legs concurrently
-        await Promise.all([
-            closeWithRetry(longPos.exchange, longPos.rawSymbol, "sell", longPos.size, "long"),
-            closeWithRetry(shortPos.exchange, shortPos.rawSymbol, "buy", shortPos.size, "short"),
-        ]);
-        const allSuccess = results.every(r => r.status === "success");
-        const anySuccess = results.some(r => r.status === "success");
-        // Verify positions are actually closed
-        let verification;
-        if (anySuccess) {
-            verification = [];
-            for (const r of results) {
-                if (r.status !== "success")
-                    continue;
-                try {
-                    const adapter = await getAdapterForExchange(r.exchange);
-                    const positions = await adapter.getPositions();
-                    const remaining = positions.find(p => p.symbol.replace("-PERP", "").toUpperCase() === sym);
-                    verification.push({
-                        exchange: r.exchange,
-                        remainingSize: remaining ? Math.abs(Number(remaining.size)) : 0,
-                        closed: !remaining || Math.abs(Number(remaining.size)) < 0.0001,
-                    });
-                }
-                catch {
-                    verification.push({ exchange: r.exchange, remainingSize: -1, closed: false });
-                }
-            }
-            const notClosed = verification.filter(v => !v.closed);
-            if (notClosed.length > 0 && !isJson()) {
-                console.log(chalk.yellow(`\n  Warning: Position may not be fully closed on: ${notClosed.map(v => v.exchange).join(", ")}`));
-            }
+                console.error(chalk.red(`  ${closeRes.status === "quarantined" ? "QUARANTINED" : "Close failed (nothing changed, both legs open)"}: ${closeRes.reason}`));
         }
+        const allSuccess = closeRes.status === "closed";
         // Remove from persisted daemon state (so daemon doesn't try to re-close)
         if (allSuccess) {
-            try {
-                persistRemovePosition(sym);
-            }
-            catch { /* state may not exist */ }
+            // No catch (Rule #2): an absent state file is a no-op; a wrong-network/unreadable one must surface.
+            persistRemovePosition(networkOf(program), sym);
         }
         // Log to execution log
         const arbPairId = `${sym}:${longPos.exchange}:${shortPos.exchange}`;
@@ -970,22 +976,21 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
                 symbol: sym,
                 longExchange: longPos.exchange,
                 shortExchange: shortPos.exchange,
-                status: allSuccess ? "success" : anySuccess ? "partial" : "failed",
+                status: allSuccess ? "success" : closeRes.status,
                 unrealizedPnl: totalUpnl,
                 estimatedFees: totalFees,
                 netPnl,
                 results,
-                verification,
             }));
         }
-        if (!allSuccess && anySuccess) {
-            console.log(chalk.yellow(`\n  Warning: Partial close — one leg failed. Manual intervention may be needed.\n`));
+        if (closeRes.status === "quarantined") {
+            console.log(chalk.red.bold(`\n  ${sym} quarantined — a leg may still be open. Check both venues by hand.\n`));
         }
         else if (allSuccess) {
             console.log(chalk.green(`\n  Arb position ${sym} closed successfully.\n`));
         }
         else {
-            console.log(chalk.red(`\n  Failed to close arb position ${sym}. Both legs failed.\n`));
+            console.log(chalk.red(`\n  Failed to close arb position ${sym}. Both legs are still open (hedged).\n`));
         }
     });
     // ── arb history ──
@@ -1280,15 +1285,15 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
         console.log(chalk.gray(`\n  Override with 'perp arb auto --min-spread 20 --size 50 ...'\n`));
         console.log(chalk.gray(`  Run 'perp arb auto --help' for all options.\n`));
     });
-    arb
-        .command("rebalance")
-        .description("Cross-exchange balance rebalancing for arb")
+    // Plan-only (never moves funds) — --dry-run only labels the plan.
+    supportsDryRun(arb.command("rebalance"))
+        .description("Cross-exchange balance rebalancing plan for arb (read-only; execute with perp funds rebalance execute)")
         .option("--check", "Show current balance distribution")
         .option("--target <ratio>", "Target distribution ratio (e.g., '50:50' for 2 exchanges, '33:33:33' for 3)")
         .option("--amount <usd>", "Total amount to rebalance")
-        .option("--dry-run", "Show plan without executing")
         .option("--exchanges <list>", "Comma-separated exchanges", "lighter,pacifica,hyperliquid")
-        .action(async (opts) => {
+        .action(async (opts, cmd) => {
+        const dryRun = isDryRun(cmd);
         const exchangeNames = opts.exchanges.split(",").map(e => e.trim());
         const adapters = new Map();
         for (const name of exchangeNames) {
@@ -1378,7 +1383,7 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
         // If --amount specified, scale moves proportionally
         let moves = plan.moves;
         if (opts.amount) {
-            const requestedAmount = parseFloat(opts.amount);
+            const requestedAmount = Number(parsePositiveDecimal(opts.amount, "--amount"));
             const totalMoveAmount = moves.reduce((s, m) => s + m.amount, 0);
             if (totalMoveAmount > 0) {
                 const scale = Math.min(1, requestedAmount / totalMoveAmount);
@@ -1416,7 +1421,7 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
         }));
         if (isJson()) {
             return printJson(jsonOk({
-                status: opts.dryRun ? "dry_run" : "planned",
+                status: dryRun ? "dry_run" : "planned",
                 target: weights,
                 moves: moveDetails,
                 snapshots,
@@ -1454,7 +1459,7 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
         }
         const totalFees = moveDetails.reduce((s, m) => s + m.bridgeFee, 0);
         console.log(chalk.gray(`  Total bridge fees: ~$${totalFees.toFixed(2)}`));
-        if (opts.dryRun) {
+        if (dryRun) {
             console.log(chalk.yellow("\n  [DRY RUN] No transfers executed.\n"));
         }
         else {
@@ -1469,24 +1474,15 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
             console.log(chalk.cyan(`\n  Fetching funding payments (last ${periodDays} days)...\n`));
         // Fetch positions to identify arb pairs
         const fundingPositions = [];
-        for (const exName of EXCHANGES) {
-            try {
-                const adapter = await getAdapter(exName);
-                const positions = await adapter.getPositions();
-                for (const p of positions) {
-                    const normalized = p.symbol.replace("-PERP", "").toUpperCase();
-                    fundingPositions.push({
-                        exchange: exName,
-                        symbol: normalized,
-                        side: p.side,
-                        size: Math.abs(Number(p.size)),
-                        markPrice: Number(p.markPrice),
-                    });
-                }
-            }
-            catch {
-                // exchange not configured
-            }
+        const fundingVenues = await listArbVenues();
+        for (const { exchange, position: p } of await readArbVenuePositions(fundingVenues, getAdapter)) {
+            fundingPositions.push({
+                exchange,
+                symbol: p.symbol.replace("-PERP", "").toUpperCase(),
+                side: p.side,
+                size: Math.abs(Number(p.size)),
+                markPrice: Number(p.markPrice),
+            });
         }
         // Identify arb pairs (long on one exchange, short on another)
         const arbPairKeys = new Set();
@@ -1508,7 +1504,7 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
         }
         const allPayments = [];
         const cutoff = Date.now() - periodDays * 24 * 60 * 60 * 1000;
-        for (const exName of EXCHANGES) {
+        for (const exName of fundingVenues) {
             try {
                 const adapter = await getAdapter(exName);
                 const payments = await adapter.getFundingPayments(200);
@@ -1526,8 +1522,9 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
                     });
                 }
             }
-            catch {
-                // exchange not configured or no payments
+            catch (e) {
+                // Reported, not hidden: this venue's payments are missing from the totals below.
+                process.stderr.write(`[warn] ${exName} funding payments unavailable (left out of the totals): ${e instanceof Error ? e.message : String(e)}\n`);
             }
         }
         // Group by symbol, then by exchange