perp-cli 0.14.3 → 0.16.0

package/dist/commands/pacifica-orders.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Pacifica-specific order types exposed through `perp -e pacifica trade …`.
+ *
+ * Of Pacifica's strategy order types (docs trading-on-pacifica/order-types/strategies) only Atomic
+ * has an API path: it is a batch of ordinary market orders (POST /orders/batch). Chase, OCO,
+ * Trailing Stop, Swarm, Trigger Swarm and Conditional Market / Limit have no documented API / SDK
+ * path (as of 2026-10-19): no REST endpoint, no signing operation type (api/signing/operation-types),
+ * no batch action type and no order-type code; the official python-sdk and Pacifica MCP server
+ * expose none. Nearest perp-cli equivalents: `trade twap` (≈ Swarm: a split market execution) and
+ * `trade tpsl` (≈ OCO bracket exit: position take-profit + stop-loss).
+ */
+import type { Command } from "commander";
+import type { ExchangeAdapter } from "../exchanges/interface.js";
+export declare function registerPacificaOrderCommands(trade: Command, getAdapter: () => Promise<ExchangeAdapter>, isJson: () => boolean, isDryRun: () => boolean): void;

package/dist/commands/pacifica-orders.js

@@ -0,0 +1,142 @@
+/**
+ * Pacifica-specific order types exposed through `perp -e pacifica trade …`.
+ *
+ * Of Pacifica's strategy order types (docs trading-on-pacifica/order-types/strategies) only Atomic
+ * has an API path: it is a batch of ordinary market orders (POST /orders/batch). Chase, OCO,
+ * Trailing Stop, Swarm, Trigger Swarm and Conditional Market / Limit have no documented API / SDK
+ * path (as of 2026-10-19): no REST endpoint, no signing operation type (api/signing/operation-types),
+ * no batch action type and no order-type code; the official python-sdk and Pacifica MCP server
+ * expose none. Nearest perp-cli equivalents: `trade twap` (≈ Swarm: a split market execution) and
+ * `trade tpsl` (≈ OCO bracket exit: position take-profit + stop-loss).
+ */
+import chalk from "chalk";
+import { supportsDryRun } from "../cli-flags.js";
+import { PerpError, extractErrorMessage, parsePositiveDecimal } from "../errors.js";
+import { atomicBasketRiskCheck, atomicDryRunPlan, atomicIncompleteError, atomicLegClientOrderId, atomicLegPayload, atomicMarketsOf, executeAtomic, parseAtomicLegs, requireAtomicReduceOnly, sizeAtomicLegs, } from "../exchanges/pacifica-atomic.js";
+import { resolveSlippage } from "../exchanges/slippage.js";
+import { parseSlippageBpsFlag } from "./trade.js";
+import { reduceOnlyGateOf, unsupported } from "../exchanges/trading-v2.js";
+import { getVenue } from "../exchanges/venue.js";
+import { quarantineEntryFor, quarantineSymbol } from "../bot/quarantine.js";
+import { enforceOrderRisk } from "../trade-validator.js";
+import { assessRisk, loadRiskLimits } from "../risk.js";
+import { logExecution } from "../execution-log.js";
+import { invalidateCache } from "../cache.js";
+import { printJson, jsonOk } from "../utils.js";
+export function registerPacificaOrderCommands(trade, getAdapter, isJson, isDryRun) {
+    supportsDryRun(trade.command("atomic"))
+        .description("Pacifica only: weighted basket of market orders across markets, sent in ONE batch request. Each leg fills or fails on its own (not all-or-nothing). "
+        + "An unconfirmed leg → ORDER_PENDING and its symbol is quarantined; a batch failure other than HTTP 400 / 429 (timeout, 5xx, unreadable answer) quarantines EVERY leg. "
+        + "Pacifica Chase / OCO / Trailing / Swarm have no documented API (as of 2026-10-19) — nearest here: trade twap (≈ Swarm), trade tpsl (≈ OCO)")
+        .requiredOption("--usd <total>", "Total basket notional in USD, split across the legs by weight at each mark price")
+        .option("--long <legs...>", "Buy legs: SYMBOL[:WEIGHT] (up to 5; no weight = 1)")
+        .option("--short <legs...>", "Sell legs: SYMBOL[:WEIGHT] (up to 5; no weight = 1)")
+        .option("--reduce-only", "Every leg reduce-only: --long legs must close shorts, --short legs must close longs")
+        .option("--slippage-bps <n>", "Per-leg slippage bound in bps (default: settings slippageBps.pacifica → defaultSlippageBps)")
+        .option("--force", "Bypass local risk-limit checks (maxPosition / total exposure) for every leg")
+        .action(async (opts) => {
+        const adapter = await getAdapter();
+        if (adapter.name !== "pacifica") {
+            const def = getVenue(adapter.name);
+            throw unsupported(def.displayName, "atomicOrder", "Atomic is a Pacifica basket order (POST /orders/batch of market orders)", "Run it on Pacifica (perp -e pacifica trade atomic …), or use perp trade multi for a cross-venue multi-leg order");
+        }
+        const pac = adapter;
+        const specs = parseAtomicLegs(opts.long ?? [], opts.short ?? []);
+        const usd = parsePositiveDecimal(opts.usd, "--usd");
+        const slippage = resolveSlippage("pacifica", parseSlippageBpsFlag(opts.slippageBps));
+        const reduceOnly = opts.reduceOnly === true;
+        const [info, prices] = await Promise.all([pac.sdk.getInfo(), pac.sdk.getPrices()]);
+        const legs = sizeAtomicLegs(specs, usd, atomicMarketsOf(specs, info, prices), slippage.bps);
+        // Pre-send gates (read only), before the dry-run return so a dry run reports the same refusal.
+        if (reduceOnly) {
+            const gate = reduceOnlyGateOf(adapter);
+            if (gate !== null)
+                throw gate;
+            invalidateCache("acct");
+            requireAtomicReduceOnly(legs, await adapter.getPositions());
+        }
+        else {
+            for (const l of legs) {
+                const q = quarantineEntryFor(l.symbol, (m) => { if (!isJson())
+                    console.error(m); });
+                if (q !== null) {
+                    throw new PerpError("RISK_VIOLATION", `${l.symbol} is quarantined by ${q.strategy}: ${q.reason}`, {
+                        exchange: "pacifica",
+                        remediation: `${q.remediation} — only reduce-only orders are accepted until a human clears it (perp strategy quarantine-clear ${l.symbol})`,
+                    });
+                }
+                await enforceOrderRisk(adapter, { symbol: l.symbol, size: Number(l.size), price: Number(l.mark), force: opts.force });
+            }
+            // The basket as one order: total notional vs total exposure, new markets vs max positions.
+            if (opts.force !== true) {
+                const [balance, positions] = await Promise.all([adapter.getBalance(), adapter.getPositions()]);
+                const assessment = assessRisk([{ exchange: adapter.name, balance }], positions.map(position => ({ exchange: adapter.name, position })), loadRiskLimits());
+                atomicBasketRiskCheck(assessment, legs, positions);
+            }
+        }
+        const builder = await pac.builderDecision();
+        const builderCode = builder.applied === null ? null : builder.applied.identity;
+        const payloads = legs.map(l => atomicLegPayload(l, { reduceOnly, slippageBps: slippage.bps, clientOrderId: atomicLegClientOrderId(), builderCode }));
+        const legView = legs.map((l, i) => ({
+            symbol: l.symbol, side: l.side, weight: l.weight, share: Number(l.share.toFixed(6)), mark: l.mark, lotSize: l.lotSize,
+            size: l.size, notionalUsd: Number(l.notionalUsd.toFixed(2)), clientOrderId: payloads[i].client_order_id,
+        }));
+        const summary = { exchange: "pacifica", totalUsd: usd, reduceOnly, slippageBps: slippage.bps, legs: legView, builderFee: builder.applied, ...(builder.note !== null ? { builderNote: builder.note } : {}) };
+        if (isDryRun()) {
+            const tier = pac.activeSignerTier;
+            const plan = atomicDryRunPlan(payloads, {
+                account: pac.isReadOnly ? "<no signer configured: a live run needs a Pacifica key>" : pac.publicKey,
+                agentWallet: tier === "agent" ? "<agent wallet public key>" : null,
+                timestamp: Date.now(),
+            });
+            for (const l of legs) {
+                logExecution({ type: "multi_leg", exchange: "pacifica", symbol: l.symbol, side: l.side, size: l.size, status: "simulated", dryRun: true, meta: { atomic: true, reduceOnly } });
+            }
+            if (isJson())
+                return printJson(jsonOk({ dryRun: true, sent: false, action: "atomic_order", ...summary, request: plan }));
+            console.log(chalk.yellow("\n  [DRY RUN] Would send a Pacifica Atomic basket (nothing signed or sent):"));
+            for (const l of legView)
+                console.log(chalk.gray(`    ${l.side.toUpperCase().padEnd(4)} ${l.size} ${l.symbol} ≈ $${l.notionalUsd} (weight ${l.weight}, mark ${l.mark})`));
+            console.log(chalk.gray(`    reduce-only: ${reduceOnly} · slippage: ${slippage.bps} bps per leg · builder: ${builder.applied === null ? "none" : builder.applied.identity}`));
+            console.log(chalk.gray(`    ${plan.endpoint}\n${JSON.stringify(plan.body, null, 2).split("\n").map(s => `    ${s}`).join("\n")}`));
+            console.log(chalk.gray(`    signed messages (create_market_order, one per leg):\n${plan.signedMessages.map(s => `    ${s}`).join("\n")}\n`));
+            return;
+        }
+        let outcomes;
+        let venueRaw;
+        try {
+            ({ outcomes, venueRaw } = await executeAtomic(pac, legs, payloads));
+        }
+        catch (e) {
+            for (const l of legs) {
+                logExecution({ type: "multi_leg", exchange: "pacifica", symbol: l.symbol, side: l.side, size: l.size, status: e instanceof PerpError && e.structured.code === "ORDER_PENDING" ? "unverified" : "failed", dryRun: false, error: extractErrorMessage(e), meta: { atomic: true, reduceOnly } });
+                if (!reduceOnly && e instanceof PerpError && e.structured.code === "ORDER_PENDING")
+                    quarantineAtomicLeg(l.symbol, extractErrorMessage(e), isJson);
+            }
+            throw e;
+        }
+        for (const o of outcomes) {
+            logExecution({
+                type: "multi_leg", exchange: "pacifica", symbol: o.symbol, side: o.side, size: o.size,
+                status: o.status === "unknown" ? "unverified" : o.status === "filled" || o.status === "partiallyFilled" ? "success" : "failed",
+                dryRun: false, ...(o.detail !== null && o.status !== "filled" ? { error: o.detail } : {}),
+                meta: { atomic: true, reduceOnly, orderId: o.orderId, clientOrderId: o.clientOrderId, filledSize: o.filledSize },
+            });
+            if (o.status === "unknown" && !reduceOnly)
+                quarantineAtomicLeg(o.symbol, o.detail ?? "outcome unknown", isJson);
+        }
+        const incomplete = atomicIncompleteError(outcomes);
+        if (incomplete !== null)
+            throw incomplete;
+        if (isJson())
+            return printJson(jsonOk({ ...summary, outcomes, venueRaw }));
+        console.log(chalk.green(`\n  Atomic basket filled on Pacifica ($${usd}):`));
+        for (const o of outcomes)
+            console.log(`  ${chalk.green("FILLED")}  ${o.side.toUpperCase().padEnd(4)} ${o.filledSize ?? o.size} ${o.symbol}  order ${o.orderId ?? "-"}`);
+        console.log();
+    });
+}
+function quarantineAtomicLeg(symbol, reason, isJson) {
+    quarantineSymbol("trade-atomic", symbol, `atomic leg on ${symbol}: outcome unknown (${reason})`, `Check the position and fills: perp -e pacifica account positions / trade fills ${symbol}`, (m) => { if (!isJson())
+        console.error(m); });
+}

package/dist/commands/portfolio.d.ts

@@ -16,10 +16,26 @@
  */
 import type { Command } from "commander";
 import type { ExchangeAdapter } from "../exchanges/index.js";
+import type { DashboardExchange } from "../dashboard/index.js";
 import "../exchanges/venues/index.js";
+/**
+ * HIP-3 dex names, read live from info `perpDexs` on the selected network (index 0 = the native
+ * dex, null). Throws on a failed or malformed read — never substitutes a fixed list (Rule #2):
+ * a stale list hides positions on any dex Hyperliquid adds later.
+ */
+export declare function fetchHip3DexNames(): Promise<string[]>;
 /**
  * Open-position count on a HIP-3 dex; null = the read failed (unknown — NOT "no positions").
  * The failure is warned on stderr; callers must treat null as "may hold positions".
  */
 export declare function checkDexPositions(address: string, dex: string): Promise<number | null>;
+/**
+ * HIP-3 dexes holding positions (or whose read failed) for `address`, scanning every dex of the
+ * live `perpDexs` list. `error` is set when the dex list itself could not be read: no dex is
+ * scanned and the caller must surface it (positions on HIP-3 dexes are unknown, not absent).
+ */
+export declare function autoDetectHip3Dexes(address: string, getHLAdapterForDex: (dex: string) => Promise<ExchangeAdapter>, verbose: boolean): Promise<{
+    exchanges: DashboardExchange[];
+    error: string | null;
+}>;
 export declare function registerPortfolioCommand(program: Command, getAdapterForExchange: (exchange: string) => Promise<ExchangeAdapter>, isJson: () => boolean, version: string, getHLAdapterForDex?: (dex: string) => Promise<ExchangeAdapter>): void;

package/dist/commands/portfolio.js

@@ -1,7 +1,7 @@
 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 { getVenue, listVenuesWithRole, roleUnsupported, tryResolveVenueId } from "../exchanges/venue.js";
 import { PerpError } from "../errors.js";
 import "../exchanges/venues/index.js";
 import { listConfiguredAccountVenues } from "../config.js";
@@ -9,6 +9,7 @@ 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";
+import { probeVenueHealth } from "../venue-health.js";
 // ── Types ──────────────────────────────────────────────────────────────────
 /** Venues with an account API (market-data-only venues are excluded). */
 function accountVenueIds() {
@@ -51,6 +52,12 @@ function validateExchanges(list) {
     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());
+    // A registered market-data-only venue (TxFlow) is a capability refusal, not an unknown name.
+    for (const id of ids) {
+        const known = tryResolveVenueId(id);
+        if (known !== null && !valid.includes(known))
+            throw roleUnsupported(getVenue(known), "account");
+    }
     const unknown = ids.filter(e => !valid.includes(e));
     if (unknown.length > 0) {
         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)` });
@@ -178,7 +185,7 @@ async function fetchExchangeEntry(exName, getAdapter) {
             adapter.getOpenOrders(),
             adapter.getFundingPayments(200).then((rows) => ({ rows, error: null }), (e) => ({ rows: null, error: e instanceof Error ? e.message : String(e) })),
         ]);
-        // Spot balances for every venue with def.spot (§12). Failures are surfaced on
+        // Spot balances for every venue with def.spot. Failures are surfaced on
         // stderr (the perp snapshot is still reported); unpriced tokens are excluded + warned.
         let spot = [];
         let isUnified = false;
@@ -205,7 +212,7 @@ async function fetchExchangeEntry(exName, getAdapter) {
         const funding24h = fundingPayments.rows === null
             ? null
             : fundingPayments.rows.filter(f => f.time >= cutoff24h).reduce((sum, f) => sum + Number(f.payment), 0);
-        // Shared balances (Pacifica USDC, HL unified USDC) are already in perp equity (§12.4 #8).
+        // Shared balances (Pacifica USDC, HL unified USDC) are already in perp equity.
         const nonUsdcSpotValue = spot.filter(b => !b.shared).reduce((s, b) => s + b.valueUsd, 0);
         return {
             name: exName,
@@ -288,46 +295,16 @@ function buildTotals(entries) {
 }
 // ── Health check (no balance fetches) ──────────────────────────────────────
 async function runHealth(exchangeList, network) {
-    const { pingPacifica, pingHyperliquid, pingLighter } = await import("../shared-api.js");
-    const pingAster = async () => {
-        const start = Date.now();
-        try {
-            const res = await fetch("https://fapi.asterdex.com/fapi/v1/time");
-            return { ok: res.ok, latencyMs: Date.now() - start, status: res.status };
-        }
-        catch {
-            return { ok: false, latencyMs: Date.now() - start, status: 0 };
-        }
-    };
-    const pingMap = {
-        pacifica: pingPacifica,
-        hyperliquid: pingHyperliquid,
-        lighter: pingLighter,
-        aster: pingAster,
-    };
+    // The same probe as `perp health` and the MCP health_check, over the selected venues.
+    const h = await probeVenueHealth(network, exchangeList);
     const exchanges = {};
-    await Promise.all(exchangeList.map(async (ex) => {
-        const fn = pingMap[ex];
-        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";
-        }
-        catch {
-            exchanges[ex] = "error";
-        }
-    }));
-    const anyDown = Object.values(exchanges).some(v => v === "error");
-    return { exchanges, anyDown };
+    for (const p of h.probes)
+        exchanges[p.venue] = p.ok ? "ok" : "error";
+    return { exchanges, anyDown: !h.allHealthy, probes: h.probes, skipped: h.skipped };
 }
 // ── Arb top-5 ──────────────────────────────────────────────────────────────
 async function fetchArbTop() {
-    const { fetchAllFundingRates, TOP_SYMBOLS } = await import("../funding-rates.js");
+    const { fetchAllFundingRates, isRankedComparison, TOP_SYMBOLS } = await import("../funding-rates.js");
     const { saveFundingSnapshot, getHistoricalAverages } = await import("../funding-history.js");
     let snapshot;
     try {
@@ -346,6 +323,7 @@ async function fetchArbTop() {
     }
     catch { /* ignore */ }
     const top = snapshot.symbols
+        .filter(isRankedComparison)
         .filter(s => s.maxSpreadAnnual >= 5)
         .sort((a, b) => b.maxSpreadAnnual - a.maxSpreadAnnual)
         .slice(0, 5);
@@ -514,11 +492,15 @@ function renderSnapshotText(data) {
 }
 function renderHealthText(h) {
     console.log(chalk.cyan.bold("\n  Exchange Health Check\n"));
-    const rows = Object.entries(h.exchanges).map(([ex, status]) => {
-        const statusIcon = status === "ok" ? chalk.green("OK") : chalk.red("DOWN");
-        return [chalk.white.bold(ex), statusIcon];
-    });
-    console.log(makeTable(["Exchange", "Status"], rows));
+    const rows = h.probes.map((p) => [
+        chalk.white.bold(p.venue),
+        p.ok ? chalk.green("OK") : chalk.red("DOWN"),
+        `${p.latencyMs}ms`,
+        p.error !== null ? chalk.red(p.error) : chalk.gray("-"),
+    ]);
+    console.log(makeTable(["Exchange", "Status", "Latency", "Error"], rows));
+    for (const s of h.skipped)
+        console.log(chalk.gray(`  ${s.venue}: not probed — ${s.reason}`));
     const overall = h.anyDown ? chalk.red("ISSUES DETECTED") : chalk.green("ALL HEALTHY");
     console.log(`\n  Overall: ${overall}\n`);
 }
@@ -546,7 +528,31 @@ async function runWatch(resolved, version, getAdapterForExchange, isJsonMode) {
     }
 }
 // ── Serve mode (delegates to dashboard infra) ──────────────────────────────
-const KNOWN_HIP3_DEXES = ["xyz", "flx", "hyna", "km", "cash", "vntl"];
+/**
+ * HIP-3 dex names, read live from info `perpDexs` on the selected network (index 0 = the native
+ * dex, null). Throws on a failed or malformed read — never substitutes a fixed list (Rule #2):
+ * a stale list hides positions on any dex Hyperliquid adds later.
+ */
+export async function fetchHip3DexNames() {
+    const res = await fetch(HYPERLIQUID_API_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ type: "perpDexs" }),
+    });
+    if (!res.ok)
+        throw new Error(`info perpDexs HTTP ${res.status}`);
+    const list = await res.json();
+    if (!Array.isArray(list))
+        throw new Error("info perpDexs: expected an array");
+    return list.flatMap((d, i) => {
+        if (d === null)
+            return [];
+        const name = d?.name;
+        if (typeof name !== "string" || name === "")
+            throw new Error(`info perpDexs: entry ${i} has no dex name`);
+        return [name];
+    });
+}
 /**
  * Open-position count on a HIP-3 dex; null = the read failed (unknown — NOT "no positions").
  * The failure is warned on stderr; callers must treat null as "may hold positions".
@@ -577,8 +583,22 @@ export async function checkDexPositions(address, dex) {
         return null;
     }
 }
-async function autoDetectHip3Dexes(address, getHLAdapterForDex, verbose) {
-    const checks = await Promise.all(KNOWN_HIP3_DEXES.map(async (dex) => ({
+/**
+ * HIP-3 dexes holding positions (or whose read failed) for `address`, scanning every dex of the
+ * live `perpDexs` list. `error` is set when the dex list itself could not be read: no dex is
+ * scanned and the caller must surface it (positions on HIP-3 dexes are unknown, not absent).
+ */
+export async function autoDetectHip3Dexes(address, getHLAdapterForDex, verbose) {
+    let dexes;
+    try {
+        dexes = await fetchHip3DexNames();
+    }
+    catch (e) {
+        const error = `HIP-3 dex list unavailable — HIP-3 positions unknown, pass --dexes to monitor specific dexes: ${e instanceof Error ? e.message : String(e)}`;
+        process.stderr.write(`[warn] hl:hip3 ${error}\n`);
+        return { exchanges: [], error };
+    }
+    const checks = await Promise.all(dexes.map(async (dex) => ({
         dex,
         count: await checkDexPositions(address, dex),
     })));
@@ -599,7 +619,7 @@ async function autoDetectHip3Dexes(address, getHLAdapterForDex, verbose) {
             process.stderr.write(`[warn] hl:${dex} left out of the dashboard (adapter unavailable${count === null ? ", positions unknown" : `, ${count} position(s)`}): ${e instanceof Error ? e.message : String(e)}\n`);
         }
     }
-    return results;
+    return { exchanges: results, error: null };
 }
 async function runServe(resolved, getAdapterForExchange, isJsonMode, getHLAdapterForDex) {
     const { startDashboard } = await import("../dashboard/index.js");
@@ -635,7 +655,9 @@ async function runServe(resolved, getAdapterForExchange, isJsonMode, getHLAdapte
                 const hlAddr = hlEx ? hlEx.adapter.address ?? "" : "";
                 if (hlAddr) {
                     const detected = await autoDetectHip3Dexes(hlAddr, getHLAdapterForDex, false);
-                    exchanges.push(...detected);
+                    exchanges.push(...detected.exchanges);
+                    if (detected.error !== null)
+                        errors["hl:hip3"] = detected.error;
                 }
             }
         }
@@ -694,8 +716,10 @@ async function runServe(resolved, getAdapterForExchange, isJsonMode, getHLAdapte
             if (hlAddr) {
                 console.log(chalk.gray("  Scanning HIP-3 dexes for active positions..."));
                 const detected = await autoDetectHip3Dexes(hlAddr, getHLAdapterForDex, true);
-                exchanges.push(...detected);
-                if (!detected.length)
+                exchanges.push(...detected.exchanges);
+                if (detected.error !== null)
+                    console.log(chalk.yellow(`  ✗ hl:hip3: ${detected.error.slice(0, 120)}`));
+                else if (!detected.exchanges.length)
                     console.log(chalk.gray("  No active HIP-3 dex positions found"));
             }
         }
@@ -773,7 +797,11 @@ export function registerPortfolioCommand(program, getAdapterForExchange, isJson,
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
             if (json) {
-                console.log(JSON.stringify(jsonError("INVALID_PARAMS", msg)));
+                // A typed refusal (CAPABILITY_UNSUPPORTED for a market-data-only venue) keeps its code.
+                const s = err instanceof PerpError ? err.structured : null;
+                console.log(JSON.stringify(s !== null
+                    ? jsonError(s.code, msg, { ...(s.details !== undefined ? { details: s.details } : {}), ...(s.remediation !== undefined ? { remediation: s.remediation } : {}) })
+                    : jsonError("INVALID_PARAMS", msg)));
             }
             else {
                 console.error(chalk.red(`Error: ${msg}`));
@@ -794,9 +822,9 @@ export function registerPortfolioCommand(program, getAdapterForExchange, isJson,
                     version,
                     scope: resolved.scope,
                     mode: "health",
-                    exchanges: [],
-                    totals: { equity: 0, spotValueUsd: 0, accountValueUsd: 0, marginUsed: 0, marginPct: 0, funding24h: 0, fundingIncomplete: false },
-                    risk: { level: "LOW", marginPct: 0 },
+                    exchanges: null,
+                    totals: null,
+                    risk: null,
                     health,
                 };
                 if (json)

package/dist/commands/rebalance.d.ts

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

package/dist/commands/rebalance.js

@@ -5,6 +5,10 @@ import { PerpError } from "../errors.js";
 import { fetchBalancesWithFailures, computeRebalancePlan, describeBridgeRoute, estimateMoveTime, } from "../rebalance.js";
 import { EXCHANGE_TO_CHAIN, assertBridgeNetwork, executeBestBridge } from "../bridge-engine.js";
 import { cliCredentialOptsFrom } from "../config.js";
+import { getVenue, roleUnsupported, tryResolveVenueId } from "../exchanges/venue.js";
+import { unsupported } from "../exchanges/trading-v2.js";
+import { RISEX_FUNDS_APP_ONLY } from "../exchanges/venues/risex.js";
+import "../exchanges/venues/index.js";
 export function registerFundsRebalanceCommands(parent, getAdapterForExchange, isJson, getNetwork) {
     const rebalance = parent.command("rebalance").description("Cross-exchange balance management");
     // ── rebalance check ──
@@ -149,6 +153,17 @@ export function registerFundsRebalanceCommands(parent, getAdapterForExchange, is
         if (opts.autoBridge && !dryRun)
             assertBridgeNetwork(getNetwork());
         const exchangeNames = opts.exchanges.split(",").map((e) => e.trim());
+        // Venues whose funds perp-cli cannot move are refused before any read (no partial plan).
+        for (const name of exchangeNames) {
+            const id = tryResolveVenueId(name);
+            if (id === null)
+                continue;
+            const def = getVenue(id);
+            if (!def.roles.includes("account"))
+                throw roleUnsupported(def, "rebalance");
+            if (id === "risex")
+                throw unsupported("risex", "rebalance", RISEX_FUNDS_APP_ONLY.reason, RISEX_FUNDS_APP_ONLY.remediation);
+        }
         const adapters = new Map();
         const unavailable = [];
         for (const name of exchangeNames) {

package/dist/commands/risk.d.ts

@@ -1,5 +1,14 @@
 import { Command } from "commander";
 import type { ExchangeAdapter } from "../exchanges/index.js";
-/** Run health check and return results + render. Exported for use by status --health. */
-export declare function runHealthCheck(isJson: () => boolean): Promise<void>;
+import type { Network } from "../exchanges/venue-types.js";
+/**
+ * `perp health`: probe EVERY registered venue on the selected network — the same probe as
+ * `perp portfolio --health` and the MCP health_check (src/venue-health.ts). A venue with no
+ * environment on that network is listed under `skipped`, never silently dropped.
+ *
+ * JSON: `exchanges` = official-API venues, `unofficial` = venues read through an undocumented API
+ * (TxFlow), each entry with `error` (null when ok). `healthy` = every OFFICIAL venue is up — an
+ * unofficial API being down does not make the CLI unhealthy; `allHealthy` includes them.
+ */
+export declare function runHealthCheck(isJson: () => boolean, network: Network): Promise<void>;
 export declare function registerRiskCommands(program: Command, getAdapterForExchange: (exchange: string) => Promise<ExchangeAdapter>, isJson: () => boolean): void;

package/dist/commands/risk.js

@@ -2,61 +2,55 @@ 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";
-import { pingPacifica, pingHyperliquid, pingLighter } from "../shared-api.js";
-/** Run health check and return results + render. Exported for use by status --health. */
-export async function runHealthCheck(isJson) {
-    const pingAster = async () => {
-        const start = Date.now();
-        try {
-            const res = await fetch("https://fapi.asterdex.com/fapi/v1/time");
-            return { ok: res.ok, latencyMs: Date.now() - start, status: res.status };
-        }
-        catch {
-            return { ok: false, latencyMs: Date.now() - start, status: 0 };
-        }
-    };
-    const [pacPing, hlPing, ltPing, astPing] = await Promise.all([
-        pingPacifica(),
-        pingHyperliquid(),
-        pingLighter(),
-        pingAster(),
-    ]);
-    const toPingResult = (name, p) => ({
-        exchange: name,
+import { probeVenueHealth } from "../venue-health.js";
+import { networkOf } from "../cli-flags.js";
+/**
+ * `perp health`: probe EVERY registered venue on the selected network — the same probe as
+ * `perp portfolio --health` and the MCP health_check (src/venue-health.ts). A venue with no
+ * environment on that network is listed under `skipped`, never silently dropped.
+ *
+ * JSON: `exchanges` = official-API venues, `unofficial` = venues read through an undocumented API
+ * (TxFlow), each entry with `error` (null when ok). `healthy` = every OFFICIAL venue is up — an
+ * unofficial API being down does not make the CLI unhealthy; `allHealthy` includes them.
+ */
+export async function runHealthCheck(isJson, network) {
+    const health = await probeVenueHealth(network);
+    const checks = health.probes.map(p => ({
+        exchange: p.venue,
         status: p.ok ? "ok" : "down",
         latency_ms: p.latencyMs,
-        error: p.ok ? undefined : `HTTP ${p.status}`,
-    });
-    const checks = [
-        toPingResult("pacifica", pacPing),
-        toPingResult("hyperliquid", hlPing),
-        toPingResult("lighter", ltPing),
-        toPingResult("aster", astPing),
-    ];
-    const allOk = checks.every(c => c.status === "ok");
+        error: p.error,
+        probe: p.probe,
+        apiStatus: p.apiStatus,
+    }));
+    const official = checks.filter(c => c.apiStatus === "official");
+    const unofficial = checks.filter(c => c.apiStatus === "unofficial");
+    const allOk = official.every(c => c.status === "ok");
     if (isJson()) {
-        return printJson(jsonOk({ healthy: allOk, exchanges: checks }));
+        return printJson(jsonOk({ healthy: allOk, allHealthy: health.allHealthy, network, exchanges: official, unofficial, skipped: health.skipped }));
     }
-    console.log(chalk.cyan.bold("\n  Exchange Health Check\n"));
+    console.log(chalk.cyan.bold(`\n  Exchange Health Check (${network})\n`));
     const rows = checks.map(c => {
-        const statusIcon = c.status === "ok"
-            ? chalk.green("OK")
-            : c.status === "degraded"
-                ? chalk.yellow("DEGRADED")
-                : chalk.red("DOWN");
+        const statusIcon = c.status === "ok" ? chalk.green("OK") : chalk.red("DOWN");
         const latency = c.latency_ms < 500
             ? chalk.green(`${c.latency_ms}ms`)
             : c.latency_ms < 2000
                 ? chalk.yellow(`${c.latency_ms}ms`)
                 : chalk.red(`${c.latency_ms}ms`);
         return [
-            chalk.white.bold(c.exchange),
+            chalk.white.bold(c.exchange) + (c.apiStatus === "unofficial" ? chalk.yellow(" *") : ""),
             statusIcon,
             latency,
-            c.error ? chalk.red(c.error) : chalk.gray("-"),
+            c.probe,
+            c.error !== null ? chalk.red(c.error) : chalk.gray("-"),
         ];
     });
-    console.log(makeTable(["Exchange", "Status", "Latency", "Error"], rows));
+    console.log(makeTable(["Exchange", "Status", "Latency", "Probe", "Error"], rows));
+    if (unofficial.length > 0) {
+        console.log(chalk.yellow("  * unofficial (undocumented) venue API — may change without notice; not counted in Overall"));
+    }
+    for (const s of health.skipped)
+        console.log(chalk.gray(`  ${s.venue}: not probed — ${s.reason}`));
     const overall = allOk ? chalk.green("ALL HEALTHY") : chalk.red("ISSUES DETECTED");
     console.log(`\n  Overall: ${overall}\n`);
 }
@@ -122,11 +116,12 @@ export function registerRiskCommands(program, getAdapterForExchange, isJson) {
             console.log(`  Positions:            ${assessment.metrics.positionCount}`);
             console.log(`  Largest Position:     $${formatUsd(assessment.metrics.largestPositionUsd)}`);
             console.log(`  Max Leverage Used:    ${assessment.metrics.maxLeverageUsed}x`);
-            if (assessment.metrics.minLiquidationDistancePct >= 0) {
-                const ldColor = assessment.metrics.minLiquidationDistancePct < assessment.limits.minLiquidationDistance
+            const minLiq = assessment.metrics.minLiquidationDistancePct;
+            if (minLiq !== null) {
+                const ldColor = minLiq < assessment.limits.minLiquidationDistance
                     ? chalk.red
                     : chalk.green;
-                console.log(`  Min Liq Distance:     ${ldColor(`${assessment.metrics.minLiquidationDistancePct.toFixed(1)}%`)}`);
+                console.log(`  Min Liq Distance:     ${ldColor(`${minLiq.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`);
@@ -367,6 +362,6 @@ export function registerRiskCommands(program, getAdapterForExchange, isJson) {
         .command("health")
         .description("Adapter health check: ping venue REST endpoints (connectivity + latency)")
         .action(async () => {
-        await runHealthCheck(isJson);
+        await runHealthCheck(isJson, networkOf(program));
     });
 }

package/dist/commands/trade.d.ts

@@ -3,6 +3,7 @@ import type { ExchangeAdapter } from "../exchanges/index.js";
 import { PerpError } from "../errors.js";
 import "../exchanges/venues/index.js";
 import { type CancelResult } from "../exchanges/venue-types.js";
+export declare function parseSlippageBpsFlag(raw: string | undefined): number | null;
 /**
  * A cancel with anything not proven cancelled (failed, or pending / still listed open after the
  * verifying re-list) → ORDER_PARTIAL carrying the whole result (non-zero exit, also in --json);