perp-cli 0.14.1 → 0.14.2

package/dist/exchanges/lighter.js

@@ -250,12 +250,12 @@ export function lighterTakerFilledBase(eventInfo, sentBaseAmount) {
  * A required open-order row field as a string (Rule #2): missing / empty / non-finite numeric →
  * EXCHANGE_ERROR, never listed as price / size "0" or status "open".
  */
-export function lighterRowField(o, key, venue) {
+export function lighterRowField(o, key, venue, what = "open order") {
     const v = o[key];
     if ((typeof v === "string" && v.trim() !== "") || (typeof v === "number" && Number.isFinite(v)))
         return String(v);
-    throw new PerpError("EXCHANGE_ERROR", `${venue} open order ${lighterOrderIdOf(o) || "(no id)"}: row has no ${key} (got ${JSON.stringify(v ?? null)})`, {
-        exchange: venue, remediation: `Retry: perp -e ${venue} account orders`,
+    throw new PerpError("EXCHANGE_ERROR", `${venue} ${what} ${lighterOrderIdOf(o) || "(no id)"}: row has no ${key} (got ${JSON.stringify(v ?? null)})`, {
+        exchange: venue, remediation: `Retry: perp -e ${venue} ${what === "open order" ? "account orders" : "account history"}`,
     });
 }
 /** `iocOutcomeOf` parser shared by LighterAdapter and LighterSpotAdapter. */
@@ -1438,7 +1438,7 @@ export class LighterAdapter {
                 size: lighterRowField(o, "initial_base_amount", this.name),
                 filled: lighterRowField(o, "filled_base_amount", this.name),
                 status: lighterRowField(o, "status", this.name),
-                type: String(o.type ?? "limit"),
+                type: lighterRowField(o, "type", this.name),
                 triggerPrice: Number(o.trigger_price) > 0 ? String(o.trigger_price) : null,
             };
         });
@@ -2097,15 +2097,17 @@ export class LighterAdapter {
         if (!this._address)
             throw new Error("No private key configured — account data unavailable. Run: perp setup");
         const orders = await this.historyRows("/accountInactiveOrders", "orders", { market_type: "perp" }, limit, true);
+        // Every field is required: a missing price / size / status / type is an unreadable row, never "0" / "done" / "limit".
+        const req = (o, k) => lighterRowField(o, k, this.name, "order history");
         return orders.map((o) => ({
             orderId: lighterOrderIdOf(o),
             symbol: this.historySymbol(o.market_index, "order history", o),
             side: this.sideOfIsAsk(o.is_ask, "order history", o),
-            price: String(o.price ?? "0"),
-            size: String(o.initial_base_amount ?? o.base_amount ?? ""),
-            filled: String(o.filled_base_amount ?? "0"),
-            status: String(o.status ?? "done"),
-            type: String(o.type ?? "limit"),
+            price: req(o, "price"),
+            size: req(o, "initial_base_amount"),
+            filled: req(o, "filled_base_amount"),
+            status: req(o, "status"),
+            type: req(o, "type"),
             triggerPrice: Number(o.trigger_price) > 0 ? String(o.trigger_price) : null,
         }));
     }

package/dist/exchanges/ondo/funds.d.ts

@@ -21,7 +21,6 @@ import { type OndoDepositChain } from "../venues/ondo.js";
 export interface OndoFundsClient {
     get<T>(path: string, query: null): Promise<T>;
     post<T>(path: string, body: unknown): Promise<T>;
-    postNoResult(path: string, body: unknown): Promise<void>;
 }
 export declare const ONDO_DEPOSIT_CREDIT_TIMEOUT_MS = 600000;
 export declare const ONDO_DEPOSIT_CREDIT_POLL_MS = 10000;

package/dist/exchanges/pacifica.d.ts

@@ -381,6 +381,13 @@ export declare class PacificaAdapter implements ExchangeAdapter {
      * readable field → EXCHANGE_ERROR, never an empty list or a placeholder value.
      */
     getOrderHistory(limit?: number): Promise<ExchangeOrder[]>;
+    /**
+     * Recent fills, newest first (GET /trades/history; the client unwraps `{success, data}`).
+     * `side` is the position effect — open_long / close_short buy, open_short / close_long sell
+     * (live 2026-10-13: `"side":"close_short"` on a buy-to-close fill); bid / ask are accepted for
+     * rows that carry an order side. Anything else, a non-list or an unreadable field → EXCHANGE_ERROR.
+     */
     getTradeHistory(limit?: number): Promise<ExchangeTrade[]>;
+    /** Funding paid / received per position (GET /funding/history, `payout` signed). Strict like getTradeHistory. */
     getFundingPayments(limit?: number): Promise<ExchangeFundingPayment[]>;
 }

package/dist/exchanges/pacifica.js

@@ -332,6 +332,23 @@ function spotInfoSymbols(rows) {
 export function isPacificaStopType(type) {
     return /^(stop|take_profit|stop_loss)_/.test(type);
 }
+/** Fill sides of GET /trades/history (position effect) plus the order sides bid / ask. */
+const PACIFICA_FILL_BUY_SIDES = new Set(["open_long", "close_short", "bid"]);
+const PACIFICA_FILL_SELL_SIDES = new Set(["open_short", "close_long", "ask"]);
+/** `created_at` (ms) of a Pacifica history row; non-numeric → EXCHANGE_ERROR (never NaN). */
+function pacificaTime(row, endpoint) {
+    const t = Number(pacificaField(row, "created_at", endpoint));
+    if (!Number.isFinite(t))
+        throw new PerpError("EXCHANGE_ERROR", `Pacifica ${endpoint} row with a non-numeric created_at`, { exchange: "pacifica" });
+    return t;
+}
+/** A required field of a Pacifica history row as a string; missing / empty → EXCHANGE_ERROR. */
+function pacificaField(row, key, endpoint) {
+    const v = row[key];
+    if ((typeof v === "string" && v !== "") || (typeof v === "number" && Number.isFinite(v)))
+        return String(v);
+    throw new PerpError("EXCHANGE_ERROR", `Pacifica ${endpoint} row without a readable ${key}: ${JSON.stringify(row).slice(0, 160)}`, { exchange: "pacifica" });
+}
 export class PacificaAdapter {
     name = "pacifica";
     chain = "solana";
@@ -1352,12 +1369,7 @@ export class PacificaAdapter {
         if (!Array.isArray(rows)) {
             throw new PerpError("EXCHANGE_ERROR", `Pacifica /orders/history returned no order list (${JSON.stringify(rows).slice(0, 120)})`, { exchange: "pacifica" });
         }
-        const field = (o, k) => {
-            const v = o[k];
-            if ((typeof v === "string" && v !== "") || typeof v === "number")
-                return String(v);
-            throw new PerpError("EXCHANGE_ERROR", `Pacifica order-history row without a readable ${k}: ${JSON.stringify(o).slice(0, 160)}`, { exchange: "pacifica" });
-        };
+        const field = (o, k) => pacificaField(o, k, "/orders/history");
         return rows.slice(0, limit).map((o) => {
             const side = field(o, "side");
             if (side !== "bid" && side !== "ask") {
@@ -1376,33 +1388,47 @@ export class PacificaAdapter {
             };
         });
     }
+    /**
+     * Recent fills, newest first (GET /trades/history; the client unwraps `{success, data}`).
+     * `side` is the position effect — open_long / close_short buy, open_short / close_long sell
+     * (live 2026-10-13: `"side":"close_short"` on a buy-to-close fill); bid / ask are accepted for
+     * rows that carry an order side. Anything else, a non-list or an unreadable field → EXCHANGE_ERROR.
+     */
     async getTradeHistory(limit = 30) {
         if (!this._hasRealKey)
             throw new Error("No private key configured — account data unavailable. Run: perp setup");
-        const raw = await this.client.getTradeHistory(this.account);
-        const trades = (raw.data ?? raw);
-        if (!Array.isArray(trades))
-            return [];
-        return trades.slice(0, limit).map((t) => ({
-            time: Number(t.created_at ?? 0),
-            symbol: String(t.symbol ?? ""),
-            side: String(t.side) === "bid" ? "buy" : "sell",
-            price: String(t.price ?? "0"),
-            size: String(t.amount ?? ""),
-            fee: String(t.fee ?? "0"),
-        }));
+        const rows = await this.client.getTradeHistory(this.account, { limit });
+        if (!Array.isArray(rows)) {
+            throw new PerpError("EXCHANGE_ERROR", `Pacifica /trades/history returned no list (${JSON.stringify(rows).slice(0, 120)})`, { exchange: "pacifica" });
+        }
+        return rows.slice(0, limit).map((t) => {
+            const side = pacificaField(t, "side", "/trades/history");
+            const buy = PACIFICA_FILL_BUY_SIDES.has(side);
+            if (!buy && !PACIFICA_FILL_SELL_SIDES.has(side)) {
+                throw new PerpError("EXCHANGE_ERROR", `Pacifica /trades/history row with unknown side "${side}"`, { exchange: "pacifica" });
+            }
+            return {
+                time: pacificaTime(t, "/trades/history"),
+                symbol: pacificaField(t, "symbol", "/trades/history"),
+                side: buy ? "buy" : "sell",
+                price: pacificaField(t, "price", "/trades/history"),
+                size: pacificaField(t, "amount", "/trades/history"),
+                fee: pacificaField(t, "fee", "/trades/history"),
+            };
+        });
     }
+    /** Funding paid / received per position (GET /funding/history, `payout` signed). Strict like getTradeHistory. */
     async getFundingPayments(limit = 200) {
         if (!this._hasRealKey)
             throw new Error("No private key configured — account data unavailable. Run: perp setup");
-        const raw = await this.client.getFundingAccountHistory(this.account);
-        const history = (raw.data ?? raw);
-        if (!Array.isArray(history))
-            return [];
-        return history.slice(0, limit).map((h) => ({
-            time: Number(h.created_at ?? 0),
-            symbol: String(h.symbol ?? ""),
-            payment: String(h.payout ?? "0"),
+        const rows = await this.client.getFundingAccountHistory(this.account, { limit });
+        if (!Array.isArray(rows)) {
+            throw new PerpError("EXCHANGE_ERROR", `Pacifica /funding/history returned no list (${JSON.stringify(rows).slice(0, 120)})`, { exchange: "pacifica" });
+        }
+        return rows.slice(0, limit).map((h) => ({
+            time: pacificaTime(h, "/funding/history"),
+            symbol: pacificaField(h, "symbol", "/funding/history"),
+            payment: pacificaField(h, "payout", "/funding/history"),
         }));
     }
 }

package/dist/rebalance.d.ts

@@ -28,10 +28,29 @@ export interface RebalanceMove {
     amount: number;
     reason: string;
 }
+/** A venue whose balance could not be read (left out of the snapshots). */
+export interface BalanceReadFailure {
+    exchange: string;
+    error: string;
+}
 /**
- * Fetch balances from all exchanges in parallel.
+ * Fetch balances from all exchanges in parallel. Venues whose read failed are warned on
+ * stderr and left out; callers that must know which (plan / execute) use fetchBalancesWithFailures.
  */
 export declare function fetchAllBalances(adapters: Map<string, ExchangeAdapter>): Promise<ExchangeBalanceSnapshot[]>;
+/**
+ * Fetch balances from all exchanges in parallel; a venue whose read failed (error, empty or
+ * non-finite field) is returned in `failed` — never dropped silently, never counted as $0.
+ * A read-only adapter (no credentials: `isReadOnly`) cannot hold funds the CLI trades, so it
+ * is not read and is returned in `notConfigured` — not a failure.
+ */
+export declare function fetchBalancesWithFailures(adapters: Map<string, ExchangeAdapter>): Promise<{
+    snapshots: ExchangeBalanceSnapshot[];
+    failed: BalanceReadFailure[];
+    notConfigured: string[];
+}>;
+/** An adapter built without credentials (read-only market data) — `isReadOnly` on the venue adapters. */
+export declare function isReadOnlyAdapter(a: ExchangeAdapter): boolean;
 /**
  * Compute a rebalancing plan to equalize available balance across exchanges.
  *

package/dist/rebalance.js

@@ -20,10 +20,26 @@ import { EXCHANGE_TO_CHAIN } from "./bridge-engine.js";
 // Re-export for backward compat
 const EXCHANGE_CHAINS = Object.fromEntries(Object.entries(EXCHANGE_TO_CHAIN).map(([ex, chain]) => [ex, { chain }]));
 /**
- * Fetch balances from all exchanges in parallel.
+ * Fetch balances from all exchanges in parallel. Venues whose read failed are warned on
+ * stderr and left out; callers that must know which (plan / execute) use fetchBalancesWithFailures.
  */
 export async function fetchAllBalances(adapters) {
-    const entries = [...adapters.entries()];
+    const { snapshots, failed, notConfigured } = await fetchBalancesWithFailures(adapters);
+    for (const f of failed)
+        process.stderr.write(`[warn] ${f.exchange} balance unavailable (left out): ${f.error}\n`);
+    for (const n of notConfigured)
+        process.stderr.write(`[info] ${n} not configured (no credentials) — left out\n`);
+    return snapshots;
+}
+/**
+ * Fetch balances from all exchanges in parallel; a venue whose read failed (error, empty or
+ * non-finite field) is returned in `failed` — never dropped silently, never counted as $0.
+ * A read-only adapter (no credentials: `isReadOnly`) cannot hold funds the CLI trades, so it
+ * is not read and is returned in `notConfigured` — not a failure.
+ */
+export async function fetchBalancesWithFailures(adapters) {
+    const notConfigured = [...adapters.entries()].filter(([, a]) => isReadOnlyAdapter(a)).map(([n]) => n);
+    const entries = [...adapters.entries()].filter(([, a]) => !isReadOnlyAdapter(a));
     const results = await Promise.allSettled(entries.map(async ([name, adapter]) => {
         const bal = await adapter.getBalance();
         // Strict policy (qa/2026-05-16): empty string is corruption, not
@@ -57,9 +73,19 @@ export async function fetchAllBalances(adapters) {
             unrealizedPnl,
         };
     }));
-    return results
-        .filter((r) => r.status === "fulfilled")
-        .map((r) => r.value);
+    const snapshots = [];
+    const failed = [];
+    results.forEach((r, i) => {
+        if (r.status === "fulfilled")
+            snapshots.push(r.value);
+        else
+            failed.push({ exchange: entries[i][0], error: r.reason instanceof Error ? r.reason.message : String(r.reason) });
+    });
+    return { snapshots, failed, notConfigured };
+}
+/** An adapter built without credentials (read-only market data) — `isReadOnly` on the venue adapters. */
+export function isReadOnlyAdapter(a) {
+    return a.isReadOnly === true;
 }
 /**
  * Compute a rebalancing plan to equalize available balance across exchanges.

package/dist/strategies/funding-arb.js

@@ -4,7 +4,7 @@ import { symbolMatch, logSettledRejections } from "../utils.js";
 import { logExecution } from "../execution-log.js";
 import { updateJobState } from "../jobs.js";
 import { invalidateCache } from "../cache.js";
-import { fetchAllBalances, computeRebalancePlan, hasEnoughBalance, marketLeverageOf, requiredArbMargin } from "../rebalance.js";
+import { fetchBalancesWithFailures, computeRebalancePlan, hasEnoughBalance, marketLeverageOf, requiredArbMargin } from "../rebalance.js";
 import { checkArbLiquidity } from "../liquidity.js";
 import { computeAnnualSpread } from "../funding.js";
 import { fetchPacificaPrices, fetchHyperliquidMeta, fetchLighterOrderBookDetails, fetchLighterFundingRates, } from "../shared-api.js";
@@ -15,6 +15,11 @@ import { isQuarantined, quarantineSymbol } from "../bot/quarantine.js";
 import { isPositionGone, matchSymbol } from "../bot/strategies/funding-arb-utils.js";
 /** Quarantine source for `perp strategy funding-arb` (src/bot/quarantine.ts). */
 const SOURCE = "funding-arb-cli";
+/** The market's published size decimals on `adapter` (null = not published / market not listed). */
+async function sizeDecimalsOf(adapter, symbol) {
+    const m = (await adapter.getMarkets()).find((x) => symbolMatch(x.symbol, symbol));
+    return m === undefined ? null : m.sizeDecimals;
+}
 async function fetchAllRates() {
     // SSOT rule #2: each DEX is independent. allSettled keeps the comparison
     // alive when one DEX errors out, while rejection reasons get logged to
@@ -147,9 +152,17 @@ export async function runFundingArb(adapters, params, jobId, log = console.log)
                 // ── Phase 2: Max drawdown check ──
                 if (params.maxDrawdown && params.autoExecute && positions.length > 0) {
                     try {
-                        const snapshots = await fetchAllBalances(adapters);
+                        const { snapshots, failed } = await fetchBalancesWithFailures(adapters);
                         const totalPnl = snapshots.reduce((s, e) => s + e.unrealizedPnl, 0);
-                        if (totalPnl < -params.maxDrawdown) {
+                        // Only a failed venue that holds one of the bot's legs makes the uPnL sum unknown; a venue
+                        // without credentials (notConfigured) cannot hold one.
+                        const legVenues = new Set(positions.flatMap(p => [p.longExchange, p.shortExchange]));
+                        const failedLegs = failed.filter(f => legVenues.has(f.exchange));
+                        if (failedLegs.length > 0) {
+                            // A partial uPnL sum is not the bot's drawdown: never close everything on it.
+                            log(`[ARB] Drawdown check skipped — balance unavailable on ${failedLegs.map(f => `${f.exchange} (${f.error})`).join(", ")}`);
+                        }
+                        else if (totalPnl < -params.maxDrawdown) {
                             log(`[ARB] MAX DRAWDOWN hit: uPnL $${totalPnl.toFixed(2)} < -$${params.maxDrawdown}`);
                             log(`[ARB] Closing all ${positions.length} positions...`);
                             const stillOpen = await closeAllPositions(positions, adapters, log);
@@ -166,7 +179,11 @@ export async function runFundingArb(adapters, params, jobId, log = console.log)
                 const shouldCheckBalance = params.autoRebalance && (Date.now() - lastRebalanceCheck > 300_000); // every 5 min
                 if (shouldCheckBalance || (params.autoExecute && positions.length < maxPos)) {
                     try {
-                        balanceSnapshots = await fetchAllBalances(adapters);
+                        const read = await fetchBalancesWithFailures(adapters);
+                        balanceSnapshots = read.snapshots;
+                        // A venue missing from the snapshots has no balance for entry checks (no entry there).
+                        for (const f of read.failed)
+                            log(`[ARB] ${f.exchange} balance unavailable — no entries / rebalance on it this cycle: ${f.error}`);
                         lastRebalanceCheck = Date.now();
                         if (params.autoRebalance) {
                             const threshold = params.rebalanceThreshold ?? 100;
@@ -229,8 +246,22 @@ export async function runFundingArb(adapters, params, jobId, log = console.log)
                                 const liq = await checkArbLiquidity(longAdapter, shortAdapter, symbol, requestedUsd, 0.5, log);
                                 if (!liq.viable)
                                     continue;
-                                // Compute matched size (same for both legs)
-                                let matched = computeMatchedSize(liq.adjustedSizeUsd, highest.markPrice, longEx, shortEx);
+                                // Compute matched size (same for both legs) at each venue's published size precision —
+                                // the per-venue defaults (HL 2 decimals) would reject small BTC legs or over-round.
+                                let longDec;
+                                let shortDec;
+                                try {
+                                    [longDec, shortDec] = await Promise.all([sizeDecimalsOf(longAdapter, symbol), sizeDecimalsOf(shortAdapter, symbol)]);
+                                }
+                                catch (e) {
+                                    log(`[ARB] Skip ${symbol}: could not read the market size precision (${e instanceof Error ? e.message : String(e)})`);
+                                    continue;
+                                }
+                                if (longDec === null || shortDec === null) {
+                                    log(`[ARB] Skip ${symbol}: size precision not published on ${longDec === null ? longEx : shortEx}`);
+                                    continue;
+                                }
+                                let matched = computeMatchedSize(liq.adjustedSizeUsd, highest.markPrice, longEx, shortEx, { longSizeDecimals: longDec, shortSizeDecimals: shortDec });
                                 if (!matched) {
                                     log(`[ARB] Skip ${symbol}: can't compute matched size (min notional or precision issue)`);
                                     continue;
@@ -266,7 +297,7 @@ export async function runFundingArb(adapters, params, jobId, log = console.log)
                                     // The LONG was definitely rejected for lot size (nothing placed): recompute once.
                                     const lotSize = res.lotSize;
                                     log(`[ARB] Lot size ${lotSize} on ${longEx} — recalculating (nothing was placed)`);
-                                    matched = computeMatchedSize(liq.adjustedSizeUsd, highest.markPrice, longEx, shortEx, { lotSize });
+                                    matched = computeMatchedSize(liq.adjustedSizeUsd, highest.markPrice, longEx, shortEx, { lotSize, longSizeDecimals: longDec, shortSizeDecimals: shortDec });
                                     if (!matched) {
                                         log(`[ARB] Skip ${symbol}: can't meet lot size ${lotSize}`);
                                         continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "perp-cli",
-  "version": "0.14.1",
+  "version": "0.14.2",
   "description": "Multi-DEX Perpetual Futures CLI - Pacifica, Hyperliquid, Lighter, Aster, Lighter RH, Ondo Perps, Arcus",
   "bin": {
     "perp": "dist/index.js",

package/skills/perp-cli/SKILL.md

@@ -6,7 +6,7 @@ allowed-tools: "Bash(perp:*), Bash(npx -y perp-cli:*), Bash(bash scripts/preflig
 compatibility: "Requires Node.js 20 or newer and the perp-cli npm package (global install or npx). Network access required for exchange APIs and bridge providers. Mutating commands need a wallet key imported into the OWS vault via 'perp wallet set EXCHANGE' (key on stdin or hidden prompt — never argv). Skill is portable across Claude Code, Claude.ai, Cursor, Codex, and Gemini CLI — no platform-specific features."
 metadata:
   author: hypurrquant
-  version: "0.14.1"
+  version: "0.14.2"
 ---
 
 # perp-cli
@@ -46,7 +46,7 @@ Also bundled under `scripts/`: `preflight.sh`, `arb-monitor.sh`, `funding-analys
 ### Step 1: Verify install + version
 
 ```bash
-perp --version 2>/dev/null || npx -y perp-cli@latest --version   # must be >= 0.14.1
+perp --version 2>/dev/null || npx -y perp-cli@latest --version   # must be >= 0.14.2
 ```
 
 If it is missing or older, ask the user before installing/upgrading (`npm install -g perp-cli@latest`) — never install on your own. If `perp` is not on PATH, prefix every command with `npx -y perp-cli@latest`.

package/skills/perp-cli/references/commands.md

@@ -37,6 +37,7 @@ perp --json -e <EX> account margin <SYMBOL>    # position margin info
 perp --json -e <EX> account pnl                # realized + unrealized + funding
 perp --json -e <EX> account twap-orders        # active TWAP orders
 perp --json portfolio                          # cross-exchange unified view
+# funding24h is null (with fundingError) when a venue's funding history is unreadable; totals.fundingIncomplete = true then
 perp --json portfolio --arb                    # full dashboard with arb top 5
 ```
 
@@ -255,7 +256,7 @@ perp --json arb scan --gaps                                 # cross-exchange pri
 perp --json arb scan --hip3                                 # HIP-3 cross-dex spreads
 perp --json arb scan --history [SYMBOL]                     # historical funding
 perp --json arb scan --compare <SYMBOL>                     # compare a symbol across exchanges
-perp --json arb scan --positions                            # position funding impact
+perp --json arb scan --positions                            # position funding impact; actual24h null + fundingHistoryErrors when a venue's history is unreadable
 perp --json arb scan --live --interval 60                   # continuous monitoring
 perp --json arb scan --top 10 --hold-days 7 --bridge-cost 0 --size 100  # cost-aware filtering
 perp --json arb scan --rates --include-unverified           # also show QFEX (unverified funding; display only, never ranked)
@@ -281,6 +282,7 @@ perp --json arb close <SYM> --state-only --yes              # drop a stale state
 
 # Status / history / config / rebalance
 perp --json arb status                                      # open arb positions + PnL + funding; check unconfirmedPairs, staleStateEntries
+# spot-perp entries: fundingSource actual | partial | estimate | recorded (+ fundingError) — only "actual" is complete settled funding
 perp --json arb status --period 7 --symbol BTC              # filter funding lookback / symbol
 perp --json arb history                                     # alias: arb log
 perp --json arb history --period 30                         # past arb trade performance
@@ -424,9 +426,9 @@ perp --json history list                       # execution audit trail
 perp --json history positions                  # position lifetime tracking
 perp --json history prune                      # purge old entries
 perp --json history summary                    # trading performance summary (replaces former 'stats')
-perp --json history pnl                        # P&L breakdown by exchange
+perp --json history pnl                        # P&L breakdown by exchange; errors + partial name venues whose reads failed (left out, not 0)
 perp --json history funding                    # funding payment aggregation
-perp --json history report                     # full performance report (summary + pnl + funding)
+perp --json history report                     # full performance report (summary + pnl + funding); errors + partial + venuesRead
 perp --json history compare                    # compare strategies / accounts
 perp --json history snapshot                   # equity snapshot
 perp --json history track                      # PnL tracking helper