perp-cli 0.12.15 → 0.14.0

package/dist/commands/portfolio.js

@@ -1,8 +1,19 @@
 import chalk from "chalk";
 import { makeTable, formatUsd, formatPnl, printJson, jsonOk, jsonError, withJsonErrors } from "../utils.js";
 import { isDexCapable } from "../exchanges/capabilities.js";
+import { getVenue, listVenuesWithRole, tryResolveVenueId } from "../exchanges/venue.js";
+import { PerpError } from "../errors.js";
+import "../exchanges/venues/index.js";
+import { listConfiguredAccountVenues } from "../config.js";
+import { HYPERLIQUID_API_URL } from "../api/public/urls.js";
+import { fetchValuedSpotBalances, getSpotAdapter, spotSharesPerpMargin, withSpotTimeout } from "../exchanges/spot-factory.js";
+import { scrubSecretEnv } from "../secret-env.js";
+import { networkOf } from "../cli-flags.js";
 // ── Types ──────────────────────────────────────────────────────────────────
-const EXCHANGES = ["pacifica", "hyperliquid", "lighter", "aster"];
+/** Venues with an account API (market-data-only venues are excluded). */
+function accountVenueIds() {
+    return listVenuesWithRole("account").map(v => v.id);
+}
 // ── Helpers ────────────────────────────────────────────────────────────────
 function exAbbr(e) {
     return e === "pacifica" ? "PAC"
@@ -37,12 +48,14 @@ function parseList(input) {
     return input.split(",").map(s => s.trim()).filter(Boolean);
 }
 function validateExchanges(list) {
-    const lower = list.map(s => s.toLowerCase());
-    const unknown = lower.filter(e => !EXCHANGES.includes(e));
+    const valid = accountVenueIds();
+    // Aliases (hl, pac, lt, lrh, ast, …) resolve through the venue registry, like every other command.
+    const ids = list.map(s => tryResolveVenueId(s) ?? s.toLowerCase());
+    const unknown = ids.filter(e => !valid.includes(e));
     if (unknown.length > 0) {
-        throw new Error(`Unknown exchange: ${unknown.join(", ")}. Valid: ${EXCHANGES.join(", ")}`);
+        throw new PerpError("INVALID_PARAMS", `Unknown exchange: ${unknown.join(", ")}`, { remediation: `Use one of: ${valid.join(", ")} (or an alias such as hl, pac, lt, lrh, ast)` });
     }
-    return lower;
+    return ids;
 }
 /** Resolve global -e flag from program (only counts when the user typed it). */
 function explicitExchange(program) {
@@ -52,8 +65,8 @@ function explicitExchange(program) {
     }
     return undefined;
 }
-function resolveOptions(program, flags, stdinOpts) {
-    // 1) Build exchange list. Precedence: stdin > --exchanges > -e > all.
+function resolveOptions(program, flags, stdinOpts, defaultExchanges) {
+    // 1) Build exchange list. Precedence: stdin > --exchanges > -e > all configured.
     let exchangeList;
     let scope = "all";
     if (stdinOpts.exchanges && stdinOpts.exchanges.length > 0) {
@@ -73,7 +86,7 @@ function resolveOptions(program, flags, stdinOpts) {
             scope = "single";
         }
         else {
-            exchangeList = [...EXCHANGES];
+            exchangeList = [...defaultExchanges];
         }
     }
     // If only 1 entry and we got there via -e or stdin.exchange, scope is single.
@@ -135,7 +148,10 @@ function resolveOptions(program, flags, stdinOpts) {
                 watchIntervalMs = n;
         }
     }
-    const dexList = stdinOpts.dex ?? parseList(flags.dex);
+    // --dexes, or the root --dex when typed on the command line (backward compatible: `portfolio --serve --dex xyz`
+    // reaches the root option, which used to swallow a subcommand --dex silently).
+    const rootDex = program.getOptionValueSource("dex") === "cli" ? String(program.opts().dex) : undefined;
+    const dexList = stdinOpts.dex ?? parseList(flags.dexes ?? rootDex);
     const autoDex = stdinOpts.autoDex ?? (flags.autoDex !== false);
     return {
         exchangeList,
@@ -149,6 +165,7 @@ function resolveOptions(program, flags, stdinOpts) {
         pollIntervalMs,
         dexList,
         autoDex,
+        network: networkOf(program),
     };
 }
 // ── Per-exchange snapshot fetch ────────────────────────────────────────────
@@ -161,64 +178,32 @@ async function fetchExchangeEntry(exName, getAdapter) {
             adapter.getOpenOrders(),
             adapter.getFundingPayments(200).catch(() => []),
         ]);
-        // Spot balances (only HL + LT). Pacifica/Aster are perp-only.
+        // Spot balances for every venue with def.spot (§12). Failures are surfaced on
+        // stderr (the perp snapshot is still reported); unpriced tokens are excluded + warned.
         let spot = [];
         let isUnified = false;
+        const def = getVenue(exName);
+        const warn = (msg) => process.stderr.write(`[warn] ${msg}\n`);
         try {
-            if (exName === "hyperliquid") {
-                const { HyperliquidSpotAdapter } = await import("../exchanges/hyperliquid-spot.js");
-                const { HyperliquidAdapter } = await import("../exchanges/hyperliquid.js");
-                const hlSpot = new HyperliquidSpotAdapter(adapter);
-                await hlSpot.init();
-                const [raw, markets] = await Promise.all([hlSpot.getSpotBalances(), hlSpot.getSpotMarkets()]);
-                const priceMap = new Map(markets.map(m => [m.baseToken.toUpperCase(), Number(m.markPrice)]));
-                const strip = (t) => t.replace(/-SPOT$/i, "").toUpperCase();
-                spot = raw.filter(b => Number(b.total) > 0).map(b => {
-                    const base = strip(b.token);
-                    return {
-                        token: b.token,
-                        total: b.total,
-                        available: b.available,
-                        held: b.held,
-                        valueUsd: base === "USDC" ? Number(b.total) : (priceMap.get(base) ?? 0) * Number(b.total),
-                    };
-                });
-                // Read the actual abstraction mode (populated during init()) instead
-                // of assuming all main HL accounts are unified. Standard/default mode
-                // accounts must include spot USDC in totalAccountValueUsd because
-                // perp equity does NOT contain it. HIP-3 dex accounts always run
-                // standard semantics. Codex v0.12.12 final QA #1.
-                const hlAdapter = adapter;
-                const dexScoped = isDexCapable(adapter) && !!adapter.dex;
-                isUnified = !dexScoped && hlAdapter.isUnifiedAccount === true;
-            }
-            else if (exName === "lighter") {
-                const { LighterAdapter } = await import("../exchanges/lighter.js");
-                const { LighterSpotAdapter } = await import("../exchanges/lighter-spot.js");
-                const ltSpot = new LighterSpotAdapter(adapter);
-                await ltSpot.init();
-                const [raw, markets] = await Promise.all([ltSpot.getSpotBalances(), ltSpot.getSpotMarkets()]);
-                const priceMap = new Map(markets.map(m => [m.baseToken.toUpperCase(), Number(m.markPrice)]));
-                spot = raw.filter(b => Number(b.total) > 0).map(b => ({
-                    token: b.token,
-                    total: b.total,
-                    available: b.available,
-                    held: b.held,
-                    valueUsd: b.token === "USDC" || b.token === "USDC_SPOT"
-                        ? Number(b.total)
-                        : (priceMap.get(b.token.toUpperCase()) ?? 0) * Number(b.total),
+            const spotAdapter = await withSpotTimeout(getSpotAdapter(def.id, adapter), `${def.displayName} spot adapter`);
+            if (spotAdapter !== null) {
+                // Wallet-model venues (Arcus) price only held tokens; bounded by SPOT_VALUATION_TIMEOUT_MS.
+                spot = (await fetchValuedSpotBalances(def, spotAdapter, warn)).map(b => ({
+                    token: b.token, total: b.total, available: b.available, held: b.held, valueUsd: b.valueUsd, shared: b.shared,
                 }));
+                // HIP-3 dex accounts always run standard (non-unified) semantics. Codex v0.12.12 final QA #1.
+                const dexScoped = isDexCapable(adapter) && !!adapter.dex;
+                isUnified = !dexScoped && spotSharesPerpMargin(def, adapter);
             }
         }
-        catch { /* spot not available */ }
+        catch (e) {
+            warn(`${def.displayName} spot balances unavailable: ${e instanceof Error ? e.message : String(e)}`);
+        }
         const cutoff24h = Date.now() - 24 * 60 * 60 * 1000;
         const recent = fundingPayments.filter(f => f.time >= cutoff24h);
         const funding24h = recent.reduce((sum, f) => sum + Number(f.payment), 0);
-        // For unified accounts (HL), USDC spot is already in perp equity.
-        // Account value = perp equity + non-USDC spot; for non-unified, equity + all spot.
-        const nonUsdcSpotValue = isUnified
-            ? spot.filter(b => b.token.replace(/-SPOT$/i, "").toUpperCase() !== "USDC").reduce((s, b) => s + b.valueUsd, 0)
-            : spot.reduce((s, b) => s + b.valueUsd, 0);
+        // Shared balances (Pacifica USDC, HL unified USDC) are already in perp equity (§12.4 #8).
+        const nonUsdcSpotValue = spot.filter(b => !b.shared).reduce((s, b) => s + b.valueUsd, 0);
         return {
             name: exName,
             connected: true,
@@ -236,6 +221,7 @@ async function fetchExchangeEntry(exName, getAdapter) {
                 size: p.size,
                 entryPrice: p.entryPrice,
                 markPrice: p.markPrice,
+                liquidationPrice: p.liquidationPrice,
                 unrealizedPnl: p.unrealizedPnl,
                 leverage: p.leverage,
             })),
@@ -291,7 +277,7 @@ function buildTotals(entries) {
     };
 }
 // ── Health check (no balance fetches) ──────────────────────────────────────
-async function runHealth(exchangeList) {
+async function runHealth(exchangeList, network) {
     const { pingPacifica, pingHyperliquid, pingLighter } = await import("../shared-api.js");
     const pingAster = async () => {
         const start = Date.now();
@@ -312,11 +298,13 @@ async function runHealth(exchangeList) {
     const exchanges = {};
     await Promise.all(exchangeList.map(async (ex) => {
         const fn = pingMap[ex];
-        if (!fn) {
-            exchanges[ex] = "error";
-            return;
-        }
         try {
+            if (!fn) {
+                // No dedicated ping helper: probe the venue's public market-data path.
+                await getVenue(ex).publicData.fetchMarkets(network);
+                exchanges[ex] = "ok";
+                return;
+            }
             const r = await fn();
             exchanges[ex] = r.ok ? "ok" : "error";
         }
@@ -542,17 +530,17 @@ async function runWatch(resolved, version, getAdapterForExchange, isJsonMode) {
             process.stdout.write("");
             renderSnapshotText(data);
             if (resolved.health)
-                renderHealthText(await runHealth(resolved.exchangeList));
+                renderHealthText(await runHealth(resolved.exchangeList, resolved.network));
         }
         await new Promise(r => setTimeout(r, resolved.watchIntervalMs));
     }
 }
 // ── Serve mode (delegates to dashboard infra) ──────────────────────────────
 const KNOWN_HIP3_DEXES = ["xyz", "flx", "hyna", "km", "cash", "vntl"];
-const HL_INFO_URL = "https://api.hyperliquid.xyz/info";
 async function checkDexPositions(address, dex) {
     try {
-        const res = await fetch(HL_INFO_URL, {
+        // Selected network (review L7): follows -n via setSharedApiNetwork (live binding).
+        const res = await fetch(HYPERLIQUID_API_URL, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
             body: JSON.stringify({ type: "clearinghouseState", user: address, dex }),
@@ -689,9 +677,9 @@ async function runServe(resolved, getAdapterForExchange, isJsonMode, getHLAdapte
         const { exec } = await import("child_process");
         const url = `http://localhost:${dashboard.port}`;
         if (process.platform === "darwin")
-            exec(`open ${url}`);
+            exec(`open ${url}`, { env: scrubSecretEnv(process.env) });
         else if (process.platform === "linux")
-            exec(`xdg-open ${url}`);
+            exec(`xdg-open ${url}`, { env: scrubSecretEnv(process.env) });
     }
     catch { /* user can open manually */ }
     const ac = new AbortController();
@@ -713,13 +701,13 @@ export function registerPortfolioCommand(program, getAdapterForExchange, isJson,
     program
         .command("portfolio")
         .description("Unified account view: balances, positions, risk (replaces account balance / status / dashboard)")
-        .option("--exchanges <list>", "Comma-separated exchanges to include (default: all). Plural to avoid collision with global -e/--exchange.")
+        .option("--exchanges <list>", "Comma-separated exchanges to include (default: all with configured credentials). Plural to avoid collision with global -e/--exchange.")
         .option("--arb", "Include top arb opportunities (replaces 'perp status')")
         .option("--health", "Connectivity-only mode (replaces 'perp status --health')")
         .option("--watch [interval]", "Poll mode: clear screen + redraw each tick (ms; default 5000)")
         .option("--serve [port]", "Serve web dashboard (replaces 'perp dashboard')")
         .option("--interval <ms>", "Poll interval for --watch / --serve (default 5000)")
-        .option("--dex <list>", "Comma-separated HIP-3 dex names (only with --serve)")
+        .option("--dexes <list>", "Comma-separated HIP-3 dex names (only with --serve; the root --dex <name> is also accepted)")
         .option("--no-auto-dex", "Disable HIP-3 dex auto-detection")
         .option("--stdin", "Read JSON args from stdin (overrides flag args)")
         .action(async (flags) => {
@@ -742,7 +730,7 @@ export function registerPortfolioCommand(program, getAdapterForExchange, isJson,
         }
         let resolved;
         try {
-            resolved = resolveOptions(program, flags, stdinOpts);
+            resolved = resolveOptions(program, flags, stdinOpts, await listConfiguredAccountVenues());
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
@@ -763,7 +751,7 @@ export function registerPortfolioCommand(program, getAdapterForExchange, isJson,
         }
         await withJsonErrors(json, async () => {
             if (resolved.health) {
-                const health = await runHealth(resolved.exchangeList);
+                const health = await runHealth(resolved.exchangeList, resolved.network);
                 const data = {
                     version,
                     scope: resolved.scope,

package/dist/commands/rebalance.d.ts

@@ -1,3 +1,4 @@
 import { Command } from "commander";
 import type { ExchangeAdapter } from "../exchanges/index.js";
-export declare function registerFundsRebalanceCommands(parent: Command, getAdapterForExchange: (exchange: string) => Promise<ExchangeAdapter>, isJson: () => boolean): void;
+import type { Network } from "../exchanges/venue-types.js";
+export declare function registerFundsRebalanceCommands(parent: Command, getAdapterForExchange: (exchange: string) => Promise<ExchangeAdapter>, isJson: () => boolean, getNetwork: () => Network): void;

package/dist/commands/rebalance.js

@@ -1,9 +1,10 @@
+import { isDryRun, supportsDryRun } from "../cli-flags.js";
 import chalk from "chalk";
 import { formatUsd, makeTable, printJson, jsonOk } from "../utils.js";
 import { fetchAllBalances, computeRebalancePlan, describeBridgeRoute, estimateMoveTime, } from "../rebalance.js";
-import { EXCHANGE_TO_CHAIN, executeBestBridge } from "../bridge-engine.js";
-import { loadPrivateKey, parseSolanaKeypair } from "../config.js";
-export function registerFundsRebalanceCommands(parent, getAdapterForExchange, isJson) {
+import { EXCHANGE_TO_CHAIN, assertBridgeNetwork, executeBestBridge } from "../bridge-engine.js";
+import { cliCredentialOptsFrom } from "../config.js";
+export function registerFundsRebalanceCommands(parent, getAdapterForExchange, isJson, getNetwork) {
     const rebalance = parent.command("rebalance").description("Cross-exchange balance management");
     // ── rebalance check ──
     rebalance
@@ -118,16 +119,19 @@ export function registerFundsRebalanceCommands(parent, getAdapterForExchange, is
         console.log(chalk.yellow(`  To execute: perp funds rebalance execute --exchanges ${opts.exchanges}\n`));
     });
     // ── rebalance execute ──
-    rebalance
-        .command("execute")
-        .description("Execute rebalancing (withdraw → bridge → deposit)")
+    supportsDryRun(rebalance.command("execute"))
+        .description("Execute rebalancing (withdraw → bridge → deposit; supports --dry-run)")
         .option("--exchanges <list>", "Comma-separated exchanges", "pacifica,hyperliquid,lighter,aster")
         .option("--min-move <usd>", "Minimum move amount ($)", "50")
         .option("--reserve <usd>", "Keep at least this much per exchange ($)", "20")
-        .option("--dry-run", "Show what would happen without executing")
         .option("--withdraw-only", "Only execute withdrawals (manual bridge + deposit)")
         .option("--auto-bridge", "Auto-bridge via deBridge DLN (withdraw → bridge in one step)")
-        .action(async (opts) => {
+        .action(async (opts, cmd) => {
+        const dryRun = isDryRun(cmd);
+        // --auto-bridge signs mainnet-only bridge routes: refuse -n testnet up front,
+        // before any withdrawal is sent (not after, as a per-move bridge_failed).
+        if (opts.autoBridge && !dryRun)
+            assertBridgeNetwork(getNetwork());
         const exchangeNames = opts.exchanges.split(",").map((e) => e.trim());
         const adapters = new Map();
         for (const name of exchangeNames) {
@@ -159,7 +163,7 @@ export function registerFundsRebalanceCommands(parent, getAdapterForExchange, is
         for (const move of plan.moves) {
             if (!isJson())
                 console.log(chalk.white.bold(`  $${move.amount} ${move.from} → ${move.to}`));
-            if (opts.dryRun) {
+            if (dryRun) {
                 if (!isJson())
                     console.log(chalk.yellow("    [DRY RUN] Skipped.\n"));
                 moveResults.push({ from: move.from, to: move.to, amount: move.amount, status: "dry_run" });
@@ -202,8 +206,11 @@ export function registerFundsRebalanceCommands(parent, getAdapterForExchange, is
                     if (!isJson())
                         console.log(chalk.gray(`    Step 2: Bridging $${move.amount} (${srcChain} → ${dstChain})...`));
                     // Load keys for bridge
-                    const { senderAddress, recipientAddress, signerKey, dstSignerKey } = await loadBridgeKeys(move.from, move.to, srcChain, dstChain);
-                    const result = await executeBestBridge(srcChain, dstChain, move.amount, signerKey, senderAddress, recipientAddress, dstSignerKey);
+                    let root = cmd;
+                    while (root.parent)
+                        root = root.parent;
+                    const { senderAddress, recipientAddress, signer, dstSigner } = await loadBridgeKeys(move.from, move.to, srcChain, dstChain, cliCredentialOptsFrom(root.opts()));
+                    const result = await executeBestBridge(getNetwork(), srcChain, dstChain, move.amount, signer, senderAddress, recipientAddress, dstSigner);
                     if (!isJson()) {
                         console.log(chalk.green(`    Bridge submitted! TX: ${result.txHash}`));
                         console.log(chalk.gray(`    Provider: ${result.provider} | ~$${result.amountOut} arriving on ${dstChain}\n`));
@@ -227,7 +234,7 @@ export function registerFundsRebalanceCommands(parent, getAdapterForExchange, is
             }
         }
         if (isJson())
-            return printJson(jsonOk({ status: "executed", moves: moveResults }));
+            return printJson(jsonOk({ status: dryRun ? "simulated" : "executed", dryRun, sent: !dryRun, moves: moveResults }));
         console.log(chalk.cyan("  Rebalance initiated. Monitor progress with 'perp funds rebalance check'.\n"));
     });
 }
@@ -244,7 +251,8 @@ async function executeWithdraw(move, adapters) {
             if (!hasPacificaSdk(adapter))
                 throw new Error("Invalid adapter");
             const sdk = adapter.sdk;
-            await sdk.withdraw({ amount: String(move.amount), dest_address: adapter.publicKey }, adapter.publicKey, adapter.signer);
+            // Pacifica withdraws to the account owner's own wallet (no destination field).
+            await sdk.withdraw({ amount: String(move.amount) }, adapter.publicKey, adapter.signer);
             break;
         }
         case "hyperliquid": {
@@ -264,35 +272,17 @@ async function executeWithdraw(move, adapters) {
     }
 }
 /**
- * Load sender/recipient addresses and signer key for a bridge move.
+ * Sender / recipient (the master wallet's own public addresses) and master signers for a bridge
+ * move: OWS vault signers for an OWS master, raw-key signers for a raw-key master.
  */
-async function loadBridgeKeys(srcExchange, dstExchange, srcChain, dstChain) {
-    let senderAddress;
-    let recipientAddress;
-    let signerKey;
-    let dstSignerKey;
-    // Source
-    if (srcChain === "solana") {
-        const pk = await loadPrivateKey("pacifica");
-        senderAddress = parseSolanaKeypair(pk).publicKey.toBase58();
-        signerKey = pk;
-    }
-    else {
-        const pk = await loadPrivateKey(srcExchange);
-        const { ethers } = await import("ethers");
-        senderAddress = new ethers.Wallet(pk).address;
-        signerKey = pk;
-    }
-    // Destination
-    if (dstChain === "solana") {
-        const pk = await loadPrivateKey("pacifica");
-        recipientAddress = parseSolanaKeypair(pk).publicKey.toBase58();
-    }
-    else {
-        const pk = await loadPrivateKey(dstExchange);
-        const { ethers } = await import("ethers");
-        recipientAddress = new ethers.Wallet(pk).address;
-        dstSignerKey = pk; // For auto receiveMessage
-    }
-    return { senderAddress, recipientAddress, signerKey, dstSignerKey };
+async function loadBridgeKeys(srcExchange, dstExchange, srcChain, dstChain, credOpts) {
+    const { bridgeAddress, bridgeVenueForChain, loadBridgeSigner } = await import("../bridge-signers.js");
+    const srcVenue = bridgeVenueForChain(srcChain, srcExchange);
+    const dstVenue = bridgeVenueForChain(dstChain, dstExchange);
+    return {
+        senderAddress: await bridgeAddress(srcChain, srcVenue, credOpts),
+        recipientAddress: await bridgeAddress(dstChain, dstVenue, credOpts),
+        signer: await loadBridgeSigner(srcChain, srcVenue, credOpts),
+        dstSigner: await loadBridgeSigner(dstChain, dstVenue, credOpts),
+    };
 }

package/dist/commands/risk.js

@@ -1,3 +1,4 @@
+import { listConfiguredAccountVenues } from "../config.js";
 import chalk from "chalk";
 import { printJson, jsonOk, makeTable, formatUsd, withJsonErrors } from "../utils.js";
 import { loadRiskLimits, saveRiskLimits, assessRisk, getLiquidationDistances } from "../risk.js";
@@ -59,19 +60,26 @@ export async function runHealthCheck(isJson) {
     const overall = allOk ? chalk.green("ALL HEALTHY") : chalk.red("ISSUES DETECTED");
     console.log(`\n  Overall: ${overall}\n`);
 }
-const EXCHANGES = ["pacifica", "hyperliquid", "lighter", "aster"];
+/**
+ * Exchange filter (comma-separated) of a risk subcommand: the ROOT `-e, --exchange`, only when given
+ * on the command line. Commander hands `--exchange` to the root wherever it appears, so a subcommand
+ * copy was never set (the filter was silently dropped); the root's default venue is never a filter.
+ */
+function cliExchangeFilter(root) {
+    return root.getOptionValueSource("exchange") === "cli" ? String(root.opts().exchange) : undefined;
+}
 export function registerRiskCommands(program, getAdapterForExchange, isJson) {
     const risk = program.command("risk").description("Risk management and guardrails");
     // ── risk status ──
     risk
         .command("status")
-        .description("Assess current risk across all exchanges")
-        .option("--exchange <exchanges>", "Comma-separated exchanges (default: all)")
-        .action(async (opts) => {
+        .description("Assess current risk across all exchanges — -e <ex1,ex2> limits the exchanges (default: all with configured credentials)")
+        .action(async () => {
+        const exchangeFilter = cliExchangeFilter(program);
         await withJsonErrors(isJson(), async () => {
-            const exchanges = opts.exchange
-                ? opts.exchange.split(",").map(e => e.trim())
-                : [...EXCHANGES];
+            const exchanges = exchangeFilter
+                ? exchangeFilter.split(",").map(e => e.trim())
+                : await listConfiguredAccountVenues();
             const balances = [];
             const positions = [];
             const results = await Promise.allSettled(exchanges.map(async (ex) => {
@@ -120,6 +128,9 @@ export function registerRiskCommands(program, getAdapterForExchange, isJson) {
                     : chalk.green;
                 console.log(`  Min Liq Distance:     ${ldColor(`${assessment.metrics.minLiquidationDistancePct.toFixed(1)}%`)}`);
             }
+            for (const { exchange, position: p } of positions.filter(x => x.position.liquidationPrice === null)) {
+                console.log(`  Liq Price ${exchange}:${p.symbol}: ${chalk.yellow("unknown (venue does not report)")} — not in Min Liq Distance`);
+            }
             if (assessment.violations.length > 0) {
                 console.log(chalk.red.bold("\n  Violations"));
                 const vRows = assessment.violations.map(v => {
@@ -222,15 +233,15 @@ export function registerRiskCommands(program, getAdapterForExchange, isJson) {
     // ── risk check ── (pre-trade check, for agent use)
     risk
         .command("check")
-        .description("Pre-trade risk check (for agents)")
+        .description("Pre-trade risk check (for agents) — -e <ex1,ex2> limits the exchanges (default: all with configured credentials)")
         .requiredOption("--notional <usd>", "Order notional value in USD")
         .requiredOption("--leverage <n>", "Order leverage")
-        .option("--exchange <exchanges>", "Comma-separated exchanges (default: all)")
         .action(async (opts) => {
+        const exchangeFilter = cliExchangeFilter(program);
         await withJsonErrors(isJson(), async () => {
-            const exchanges = opts.exchange
-                ? opts.exchange.split(",").map(e => e.trim())
-                : [...EXCHANGES];
+            const exchanges = exchangeFilter
+                ? exchangeFilter.split(",").map(e => e.trim())
+                : await listConfiguredAccountVenues();
             const balances = [];
             const positions = [];
             await Promise.allSettled(exchanges.map(async (ex) => {
@@ -260,14 +271,14 @@ export function registerRiskCommands(program, getAdapterForExchange, isJson) {
     // ── risk liquidation-distance ──
     risk
         .command("liquidation-distance")
-        .description("Show % distance from liquidation price for all positions")
+        .description("Show % distance from liquidation price for all positions — -e <ex1,ex2> limits the exchanges (default: all with configured credentials)")
         .alias("liq-dist")
-        .option("--exchange <exchanges>", "Comma-separated exchanges (default: all)")
-        .action(async (opts) => {
+        .action(async () => {
+        const exchangeFilter = cliExchangeFilter(program);
         await withJsonErrors(isJson(), async () => {
-            const exchanges = opts.exchange
-                ? opts.exchange.split(",").map(e => e.trim())
-                : [...EXCHANGES];
+            const exchanges = exchangeFilter
+                ? exchangeFilter.split(",").map(e => e.trim())
+                : await listConfiguredAccountVenues();
             const positions = [];
             const results = await Promise.allSettled(exchanges.map(async (ex) => {
                 const adapter = await getAdapterForExchange(ex);
@@ -291,9 +302,14 @@ export function registerRiskCommands(program, getAdapterForExchange, isJson) {
             }
             const limits = loadRiskLimits();
             const distances = getLiquidationDistances(positions, limits);
+            // Positions whose venue reports no liquidation price are listed explicitly, never dropped.
+            const unknownLiq = positions
+                .filter(({ position: p }) => p.liquidationPrice === null)
+                .map(({ exchange, position: p }) => ({ exchange, symbol: p.symbol, side: p.side, markPrice: Number(p.markPrice), liquidationPrice: null }));
             if (isJson()) {
                 return printJson(jsonOk({
                     positions: distances,
+                    unknownLiquidation: unknownLiq,
                     limits: {
                         minLiquidationDistance: limits.minLiquidationDistance,
                     },
@@ -318,6 +334,17 @@ export function registerRiskCommands(program, getAdapterForExchange, isJson) {
                     statusColor(d.status.toUpperCase()),
                 ];
             });
+            for (const u of unknownLiq) {
+                rows.push([
+                    chalk.white(u.exchange),
+                    chalk.white.bold(u.symbol),
+                    u.side === "long" ? chalk.green("LONG") : chalk.red("SHORT"),
+                    `$${formatUsd(u.markPrice)}`,
+                    chalk.yellow("unknown (venue does not report)"),
+                    chalk.gray("n/a"),
+                    chalk.yellow("UNKNOWN"),
+                ]);
+            }
             console.log(makeTable(["Exchange", "Symbol", "Side", "Mark Price", "Liq Price", "Distance", "Status"], rows));
             // Summary warnings
             const critical = distances.filter(d => d.status === "critical");
@@ -338,7 +365,7 @@ export function registerRiskCommands(program, getAdapterForExchange, isJson) {
     });
     program
         .command("health")
-        .description("Adapter health check across all 4 DEX")
+        .description("Adapter health check: ping venue REST endpoints (connectivity + latency)")
         .action(async () => {
         await runHealthCheck(isJson);
     });

package/dist/commands/settings.d.ts

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