perp-cli 0.11.0 → 0.12.0

package/dist/smart-order.js

@@ -16,7 +16,10 @@
  * - Saves 5-50+ bps vs raw market orders on thin books
  * - Predictable execution price
  *
- * Fallback: if the IOC limit fails, falls back to market order.
+ * SSOT rule #2: silent fallback is forbidden. The opt-in `fallback: true` flag
+ * is preserved for callers that explicitly want best-effort market substitution
+ * after IOC reject, but the DEFAULT is `false` — failure must surface as a
+ * thrown error, never a silent market sweep.
  */
 /**
  * Infer tick size from orderbook prices.
@@ -77,12 +80,38 @@ function hasOrderError(result) {
         return true;
     return false;
 }
+/**
+ * Best-effort extraction of the embedded reject reason for the thrown error
+ * message. Falls back to JSON.stringify so the caller always gets actionable
+ * context.
+ */
+function describeOrderError(result) {
+    if (!result || typeof result !== "object")
+        return String(result);
+    const r = result;
+    const resp = r.response;
+    const data = resp?.data;
+    const statuses = data?.statuses;
+    if (Array.isArray(statuses) && statuses.length > 0 && statuses[0].error) {
+        return String(statuses[0].error);
+    }
+    if (typeof r.error === "string")
+        return r.error;
+    if (typeof r.message === "string")
+        return r.message;
+    try {
+        return JSON.stringify(result);
+    }
+    catch {
+        return String(result);
+    }
+}
 /**
  * Execute a smart order at best bid/ask + 1 tick.
  * Drop-in replacement for `adapter.marketOrder()`.
  */
 export async function smartOrder(adapter, symbol, side, size, opts = {}) {
-    const { tickTolerance = 1, fallback = true, reduceOnly = false } = opts;
+    const { tickTolerance = 1, fallback = false, reduceOnly = false } = opts;
     // 1. Fetch orderbook
     const book = await adapter.getOrderbook(symbol);
     // 2. Validate book has liquidity on the relevant side
@@ -111,15 +140,21 @@ export async function smartOrder(adapter, symbol, side, size, opts = {}) {
         });
         // Check for exchange-level rejection inside a "success" response
         // (e.g., Hyperliquid returns { status: "ok", response: { data: { statuses: [{ error: "..." }] } } })
-        if (fallback && hasOrderError(result)) {
-            const fallbackResult = await adapter.marketOrder(symbol, side, size);
-            return {
-                result: fallbackResult,
-                method: "market_fallback",
-                price: formattedPrice,
-                bestBookPrice: bestEntry[0],
-                tickSize: tick.toFixed(decimals),
-            };
+        // SSOT rule #2: when fallback is opt-out (default), an embedded reject
+        // must throw — otherwise the caller would silently receive a "limit_ioc"
+        // result for a rejected order and treat the failure as success.
+        if (hasOrderError(result)) {
+            if (fallback) {
+                const fallbackResult = await adapter.marketOrder(symbol, side, size);
+                return {
+                    result: fallbackResult,
+                    method: "market_fallback",
+                    price: formattedPrice,
+                    bestBookPrice: bestEntry[0],
+                    tickSize: tick.toFixed(decimals),
+                };
+            }
+            throw new Error(`smartOrder: exchange rejected IOC limit (${describeOrderError(result)})`);
         }
         return {
             result,

package/dist/strategies/funding-arb.js

@@ -1,4 +1,4 @@
-import { symbolMatch } from "../utils.js";
+import { symbolMatch, logSettledRejections } from "../utils.js";
 import { updateJobState } from "../jobs.js";
 import { fetchAllBalances, computeRebalancePlan, hasEnoughBalance } from "../rebalance.js";
 import { checkArbLiquidity } from "../liquidity.js";
@@ -6,6 +6,9 @@ import { computeAnnualSpread } from "../funding.js";
 import { fetchPacificaPrices, fetchHyperliquidMeta, fetchLighterOrderBookDetails, fetchLighterFundingRates, } from "../shared-api.js";
 import { computeMatchedSize, reconcileArbFills } from "../arb-sizing.js";
 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
+    // stderr (explicit failure, never silent).
     const [pacRates, hlRates, ltRates] = await Promise.allSettled([
         fetchPacificaPrices().then(assets => assets.map(p => ({
             exchange: "pacifica", symbol: p.symbol, fundingRate: p.funding, markPrice: p.mark,
@@ -20,14 +23,32 @@ async function fetchAllRates() {
             ]);
             const priceMap = new Map(details.map(d => [d.marketId, d.lastTradePrice]));
             const symMap = new Map(details.map(d => [d.marketId, d.symbol]));
-            return funding.map(fr => ({
-                exchange: "lighter",
-                symbol: fr.symbol || symMap.get(fr.marketId) || "",
-                fundingRate: fr.rate,
-                markPrice: fr.markPrice || priceMap.get(fr.marketId) || 0,
-            }));
+            const out = [];
+            for (const fr of funding) {
+                const symbol = fr.symbol || symMap.get(fr.marketId) || "";
+                if (!symbol)
+                    continue;
+                // Prefer fr.markPrice; fall back to orderBook last-trade as documented
+                // price source preference (NOT an error fallback).
+                const directMark = fr.markPrice;
+                const fallbackMark = priceMap.get(fr.marketId);
+                let markPrice;
+                if (directMark !== null && Number.isFinite(directMark) && directMark > 0) {
+                    markPrice = directMark;
+                }
+                else if (fallbackMark !== undefined && Number.isFinite(fallbackMark) && fallbackMark > 0) {
+                    markPrice = fallbackMark;
+                }
+                // SSOT rule #2: skip rows whose mark price cannot be resolved at all
+                // — never publish a 0 mark price downstream.
+                if (markPrice === undefined)
+                    continue;
+                out.push({ exchange: "lighter", symbol, fundingRate: fr.rate, markPrice });
+            }
+            return out;
         })(),
     ]);
+    logSettledRejections([pacRates, hlRates, ltRates], ["pacifica", "hyperliquid", "lighter"], "funding-arb");
     return [
         ...(pacRates.status === "fulfilled" ? pacRates.value : []),
         ...(hlRates.status === "fulfilled" ? hlRates.value : []),
@@ -141,7 +162,7 @@ export async function runFundingArb(adapters, params, jobId, log = console.log)
                                     for (const move of plan.moves) {
                                         log(`[ARB]   $${move.amount} ${move.from} → ${move.to}`);
                                     }
-                                    log(`[ARB] Run 'perp rebalance execute' to rebalance.`);
+                                    log(`[ARB] Run 'perp funds rebalance execute' to rebalance.`);
                                 }
                             }
                         }

package/dist/trade-validator.js

@@ -10,13 +10,26 @@ export async function validateTrade(adapter, params) {
     const checks = [];
     const warnings = [];
     const sym = params.symbol.toUpperCase();
-    // Fetch market data, balance, positions, orderbook in parallel
+    // Fetch market data, balance, positions, orderbook in parallel.
+    // SSOT rule #2: errors must propagate, never silently substitute defaults.
+    // getMarkets retains a tracked-error wrapper so the failed-load case surfaces
+    // a structured symbol_valid check (not a generic exception).
+    let marketsError = null;
     const [markets, balance, positions, orderbook] = await Promise.all([
-        adapter.getMarkets().catch(() => []),
-        adapter.getBalance().catch(() => ({ equity: "0", available: "0", marginUsed: "0", unrealizedPnl: "0" })),
-        adapter.getPositions().catch(() => []),
-        params.type !== "limit" ? adapter.getOrderbook(sym).catch(() => ({ bids: [], asks: [] })) : Promise.resolve({ bids: [], asks: [] }),
+        adapter.getMarkets().catch((e) => {
+            marketsError = e instanceof Error ? e.message : String(e);
+            return [];
+        }),
+        adapter.getBalance(),
+        adapter.getPositions(),
+        params.type !== "limit"
+            ? adapter.getOrderbook(sym)
+            : Promise.resolve({ bids: [], asks: [] }),
     ]);
+    if (markets.length === 0 && marketsError) {
+        checks.push({ check: "symbol_valid", passed: false, message: `Failed to load markets from ${adapter.name}: ${marketsError}` });
+        return { valid: false, checks, warnings, timestamp: new Date().toISOString() };
+    }
     // 1. Symbol validity (handle BTC vs BTC-PERP suffix variants)
     const market = markets.find(m => {
         const ms = m.symbol.toUpperCase();
@@ -30,9 +43,21 @@ export async function validateTrade(adapter, params) {
         return { valid: false, checks, warnings, timestamp: new Date().toISOString() };
     }
     const markPrice = Number(market.markPrice);
+    if (params.type === "limit" && (params.price === undefined || !Number.isFinite(params.price))) {
+        throw new Error(`Limit order requires explicit price (received ${params.price}); refusing silent mark-price substitution.`);
+    }
+    if (markPrice <= 0 && params.price === undefined) {
+        throw new Error(`No mark price available for ${sym} on ${adapter.name} and no override price supplied; cannot validate trade.`);
+    }
     const price = params.price ?? markPrice;
     const notional = params.size * price;
+    if (params.leverage !== undefined && (!Number.isFinite(params.leverage) || params.leverage <= 0)) {
+        throw new Error(`Leverage must be a positive number (received ${params.leverage}).`);
+    }
     const leverage = params.leverage ?? market.maxLeverage;
+    if (!Number.isFinite(leverage) || leverage <= 0) {
+        throw new Error(`No usable leverage for ${sym} (resolved=${leverage}); supply params.leverage explicitly.`);
+    }
     const marginRequired = notional / leverage;
     // 2. Balance check
     const available = Number(balance.available);

package/dist/utils.d.ts

@@ -38,3 +38,13 @@ export declare function jsonError(code: string, message: string, meta?: Partial<
  *  In JSON mode, errors are returned as JSON instead of crashing.
  */
 export declare function withJsonErrors<T>(isJson: boolean, fn: () => Promise<T>, exchange?: string): Promise<T | undefined>;
+/**
+ * Log each rejected outcome from Promise.allSettled to stderr with a
+ * per-source label. SSOT rule #2 helper: turn a quiet rejection inside a
+ * multi-DEX comparison into an explicit one-line failure on stderr.
+ *
+ * @param settled  Outcomes from Promise.allSettled.
+ * @param labels   Source label per index (e.g. ["pacifica", "hyperliquid", ...]).
+ * @param prefix   Bracketed prefix prepended to each line (e.g. "arb-auto").
+ */
+export declare function logSettledRejections(settled: PromiseSettledResult<unknown>[], labels: string[], prefix: string): void;

package/dist/utils.js

@@ -221,3 +221,22 @@ export async function withJsonErrors(isJson, fn, exchange) {
         return undefined;
     }
 }
+/**
+ * Log each rejected outcome from Promise.allSettled to stderr with a
+ * per-source label. SSOT rule #2 helper: turn a quiet rejection inside a
+ * multi-DEX comparison into an explicit one-line failure on stderr.
+ *
+ * @param settled  Outcomes from Promise.allSettled.
+ * @param labels   Source label per index (e.g. ["pacifica", "hyperliquid", ...]).
+ * @param prefix   Bracketed prefix prepended to each line (e.g. "arb-auto").
+ */
+export function logSettledRejections(settled, labels, prefix) {
+    for (let i = 0; i < settled.length; i++) {
+        const r = settled[i];
+        if (r.status === "rejected") {
+            const reason = r.reason instanceof Error ? r.reason.message : String(r.reason);
+            // eslint-disable-next-line no-console
+            console.error(`[${prefix}] ${labels[i] ?? `index-${i}`} fetch failed: ${reason}`);
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "perp-cli",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Multi-DEX Perpetual Futures CLI - Pacifica, Hyperliquid, Lighter, Aster",
   "bin": {
     "perp": "dist/index.js",
@@ -46,7 +46,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.27.1",
     "@msgpack/msgpack": "^3.1.3",
-    "@open-wallet-standard/core": "1.2.0",
+    "@open-wallet-standard/core": "1.3.2",
     "@solana/web3.js": "^1.98.0",
     "@types/react": "^19.2.14",
     "bs58": "^6.0.0",

package/skills/perp-cli/SKILL.md

@@ -99,20 +99,30 @@ perp --json arb close ETH                   # sells spot + buys back perp
 
 Spot exchanges: HL, LT. Pacifica and Aster are perp-only.
 
-## Bot Engine (19 Strategies)
+## Strategy Engine (19 bot algorithms + nested scripted plans)
 
 ```bash
-perp bot list-strategies                              # list all 19 strategies
-perp bot run <strategy> [symbol]                      # run any registered strategy
-perp bot run funding-auto                             # multi-exchange funding arb
-perp bot apex [symbol]                                # APEX orchestrator (Radar+Pulse+Guard)
-perp bot reflect                                      # performance analysis (win rate, fees, PnL)
-perp bot preset-list                                  # list strategy presets
-perp bot preset <name> [symbol]                       # run from preset
-perp bot start <config.yaml>                          # start from YAML/JSON config
-perp bot quick-grid <symbol>                          # quick grid bot
-perp bot quick-dca <symbol> <side> <amount> <interval>
-perp bot quick-arb                                    # quick funding arb
+perp strategy list-strategies                         # list all 19 strategies
+perp strategy run <strategy> [symbol]                 # run any registered strategy
+perp strategy run funding-auto                        # multi-exchange funding arb
+perp strategy apex [symbol]                           # APEX orchestrator (Radar+Pulse+Guard)
+perp strategy reflect                                 # performance analysis (win rate, fees, PnL)
+perp strategy preset-list                             # list strategy presets
+perp strategy preset <name> [symbol]                  # run from preset
+perp strategy start <config.yaml>                     # start from YAML/JSON config
+perp strategy quick-grid <symbol>                     # quick grid bot
+perp strategy quick-dca <symbol> <side> <amount> <interval>
+perp strategy quick-arb                               # quick funding arb
+
+# Scripted plans (one-shot multi-step execution)
+perp strategy plan example                            # show plan format
+perp --json strategy plan validate <file>             # validate before run
+perp --json strategy plan execute <file> --dry-run    # dry-run plan
+
+# Background process supervisor (tmux)
+perp background list                                  # list running jobs
+perp background stop <id>                             # stop a job
+perp background logs <id> -f                          # follow logs
 ```
 
 **Strategies:** grid, dca, funding-arb, funding-arb-v2, funding-auto, basis-arb, simple-mm, engine-mm, avellaneda-mm, regime-mm, grid-mm, liquidation-mm, momentum-breakout, mean-reversion, aggressive-taker, hedge-agent, rfq-agent, claude-agent, apex
@@ -136,7 +146,6 @@ perp --json -e <EX> trade cancel <SYM>                  # cancel all orders for
 ## Agent Tools
 
 ```bash
-perp --json agent schema                          # discover all commands (don't guess)
 perp --json -e <EX> trade check <SYM> <SIDE> <SIZE>  # pre-validate trade
 perp --json portfolio                              # balances + positions + risk level
 perp --json --fields totalEquity,positions portfolio  # filtered output
@@ -172,7 +181,7 @@ Response format: `{ "ok": true, "data": {...} }` or `{ "ok": false, "error": { "
 | `SYMBOL_NOT_FOUND` | `market list` to verify symbol |
 | `SIZE_TOO_SMALL` | `market info <SYM>` for min size |
 | `DUPLICATE_ORDER` | already submitted — check positions |
-| Lighter `invalid signature` | `manage setup-api-key` to regenerate |
+| Lighter `invalid signature` | `perp wallet agent approve lighter` to regenerate |
 
 ## Examples
 

package/skills/perp-cli/references/agent-operations.md

@@ -81,12 +81,14 @@ perp --json arb scan --min 5
 ```
 
 ### Lighter API Key Setup
-Lighter uses a separate API key for trading, but **this is handled automatically**.
-When `LIGHTER_PRIVATE_KEY` is set (env var or `wallet set`), the CLI auto-generates and saves the API key on first use.
+Lighter uses a separate API key for trading. There are two paths:
 
-If auto-setup fails (e.g. no ETH for gas on Lighter chain), retry manually:
+1. **Auto-setup (default)**: When `LIGHTER_PRIVATE_KEY` is set (env var or `wallet set`), the CLI auto-generates and saves the API key (slot 4) on first use.
+2. **Managed agent (recommended for long-running agents)**: `perp wallet agent approve lighter --master <wallet> --api-key-index <slot>` registers a per-agent slot (4-254) with explicit expiry tracking + 3-tier signer routing.
+
+If auto-setup fails (e.g. transient network error), retry manually:
 ```bash
-perp --json -e lighter manage setup-api-key
+perp --json wallet agent approve lighter --master <wallet>
 ```
 
 ### Using the Same EVM Key for Multiple Exchanges

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

@@ -69,7 +69,11 @@ perp --json trade market <SYM> buy <SIZE> --split   # split via market command f
 perp --json trade market <SYM> buy <SIZE> --split --max-slippage 0.5
 ```
 
-## Funds (Deposit, Withdraw, Transfer, Bridge)
+## Funds (Deposit, Withdraw, Transfer, Bridge, Rebalance)
+
+All fund movement lives under `perp funds`.
+
+### Exchange in/out
 ```bash
 perp --json funds deposit pacifica <AMOUNT>
 perp --json funds deposit hyperliquid <AMOUNT>
@@ -79,19 +83,26 @@ perp --json funds deposit lighter info                      # all Lighter deposi
 perp --json funds withdraw pacifica <AMOUNT>
 perp --json funds withdraw hyperliquid <AMOUNT>
 perp --json funds withdraw lighter <AMOUNT>
-perp --json funds transfer <AMOUNT> <ADDRESS>     # HL internal transfer (instant)
-perp --json funds bridge --from <CHAIN> --to <CHAIN> --amount <AMT> --recipient <ADDR>  # CCTP bridge
-perp --json funds bridge-status --hash <HASH>     # check CCTP bridge status
-perp --json funds info                            # combined deposit & withdrawal info
+perp --json funds transfer <AMOUNT> <ADDRESS>               # HL internal transfer (instant)
+perp --json funds info                                      # combined routes & limits
+```
+
+### Cross-chain bridge (multi-provider router: cctp / relay / debridge — auto-cheapest)
+```bash
+perp --json funds bridge chains                   # supported chains
+perp --json funds bridge quote --from <CHAIN> --to <CHAIN> --amount <AMT>
+perp --json funds bridge send --from <CHAIN> --to <CHAIN> --amount <AMT>           # auto-cheapest
+perp --json funds bridge send --from <CHAIN> --to <CHAIN> --amount <AMT> --provider cctp
+perp --json funds bridge exchange --from <EX> --to <EX> --amount <AMT>             # between exchanges
+perp --json funds bridge status <ORDER_ID>
 ```
 
-## Bridge (Cross-chain USDC)
+### Inter-exchange rebalance (orchestrated withdraw → bridge → deposit)
 ```bash
-perp --json bridge chains                   # supported chains
-perp --json bridge quote --from <CHAIN> --to <CHAIN> --amount <AMT>
-perp --json bridge send --from <CHAIN> --to <CHAIN> --amount <AMT>
-perp --json bridge exchange --from <EX> --to <EX> --amount <AMT>
-perp --json bridge status <ORDER_ID>
+perp --json funds rebalance check                            # balances across exchanges
+perp --json funds rebalance plan                             # compute optimal moves
+perp --json funds rebalance execute --auto-bridge            # withdraw → bridge → deposit
+perp --json funds rebalance execute --withdraw-only          # only withdraw, manual rest
 ```
 
 ## Arbitrage
@@ -137,7 +148,6 @@ perp --json risk liquidation-distance       # % distance from liquidation for AL
 perp --json risk limits                     # view current risk limits
 perp --json risk limits --min-liq-distance 30 --max-leverage 5  # set risk limits
 perp --json risk check --notional 1000 --leverage 3  # pre-trade risk check
-perp --json agent ping                      # exchange connectivity & latency
 perp --json history summary                 # trading performance
 perp --json history pnl                     # P&L breakdown by exchange
 perp --json history funding                 # funding payment aggregation
@@ -148,24 +158,34 @@ perp --json history perf --period summary   # performance summary stats
 perp --json history list                    # execution audit trail
 ```
 
-## Automated Strategies (bot — 19 strategies)
+## Automated Strategies (strategy — 19 algorithms + nested scripted plans)
 ```bash
-perp --json bot list-strategies                              # list all 19 strategies
-perp --json bot run <STRATEGY> [SYMBOL]                      # run any registered strategy
-perp --json bot run funding-auto                             # multi-exchange funding arb (no symbol needed)
-perp --json bot apex [SYMBOL]                                # APEX autonomous orchestrator (Radar+Pulse+Guard)
-perp --json bot reflect                                      # trading performance analysis (win rate, fees, PnL)
-perp --json bot preset-list                                  # list strategy presets
-perp --json bot preset <NAME> [SYMBOL]                       # run from preset
-perp --json bot twap <SYMBOL> <SIDE> <SIZE> <DURATION>       # TWAP execution
-perp --json bot grid <SYMBOL> --range <PCT> --grids <N> --size <USD>
-perp --json bot dca <SYMBOL> <SIDE> <AMOUNT> <INTERVAL>
-perp --json bot trailing-stop <SYMBOL>                       # trailing stop with callback %
-perp --json bot funding-arb                                  # auto funding arb
-perp --json bot quick-grid <SYMBOL>                          # quick grid bot
-perp --json bot quick-arb                                    # quick arb bot
-perp --json jobs list                                        # list running jobs
-perp --json jobs stop <ID>                                   # stop a job
+perp --json strategy list-strategies                         # list all 19 strategies
+perp --json strategy run <STRATEGY> [SYMBOL]                 # run any registered strategy
+perp --json strategy run funding-auto                        # multi-exchange funding arb (no symbol needed)
+perp --json strategy apex [SYMBOL]                           # APEX autonomous orchestrator (Radar+Pulse+Guard)
+perp --json strategy reflect                                 # trading performance analysis (win rate, fees, PnL)
+perp --json strategy preset-list                             # list strategy presets
+perp --json strategy preset <NAME> [SYMBOL]                  # run from preset
+perp --json strategy twap <SYMBOL> <SIDE> <SIZE> <DURATION>  # TWAP execution
+perp --json strategy grid <SYMBOL> --range <PCT> --grids <N> --size <USD>
+perp --json strategy dca <SYMBOL> <SIDE> <AMOUNT> <INTERVAL>
+perp --json strategy trailing-stop <SYMBOL>                  # trailing stop with callback %
+perp --json strategy funding-arb                             # auto funding arb
+perp --json strategy quick-grid <SYMBOL>                     # quick grid bot
+perp --json strategy quick-arb                               # quick arb bot
+
+# Scripted execution plans (one-shot multi-step)
+perp --json strategy plan example                            # show plan format
+perp --json strategy plan validate <FILE>                    # validate plan
+perp --json strategy plan execute <FILE> --dry-run           # dry-run plan
+
+# Background process supervisor (tmux)
+perp --json background list                                  # list running jobs
+perp --json background stop <ID>                             # stop a job
+perp --json background logs <ID>                             # view job logs
+perp --json background remove <ID>                           # remove a job entry
+perp --json background clean                                 # remove all stopped/done jobs
 ```
 
 ### Available Strategies
@@ -175,10 +195,11 @@ Arbitrage: `funding-arb`, `funding-auto`, `basis-arb`
 Infrastructure: `hedge-agent`, `rfq-agent`, `claude-agent`
 Classic: `grid`, `dca`, `twap`, `apex`
 
-## Command Discovery
+## Agent Wallet Management
 ```bash
-perp schema                       # Full CLI schema as JSON
-perp agent capabilities           # High-level capability list
-perp agent plan "<goal>"          # Suggest command sequence for a goal
-perp agent ping                   # Health check all exchanges
+perp wallet agent approve <exchange> [--master <name>]   # Register an agent wallet
+perp wallet agent list [exchange]                        # List registered agents
+perp wallet agent revoke <exchange> <agentName>          # Revoke an agent
+perp wallet agent rotate <exchange> [agentName]          # Revoke + re-approve same name
+perp wallet agent verify [exchange] [agentName]          # Verify via DEX query API
 ```

package/skills/perp-cli/scripts/preflight.sh

@@ -41,12 +41,12 @@ else
   add_check "wallet" "fail" "No wallet configured — run: perp wallet set <exchange> <key>"
 fi
 
-# 3. Exchange connectivity
-HEALTH_OUT=$($PERP --json agent ping 2>/dev/null || echo '{"ok":false}')
+# 3. Exchange connectivity (proxy via unauthenticated market prices fetch)
+HEALTH_OUT=$($PERP --json market prices 2>/dev/null || echo '{"ok":false}')
 if echo "$HEALTH_OUT" | grep -q '"ok":true'; then
-  add_check "connectivity" "pass" "Exchanges reachable"
+  add_check "connectivity" "pass" "Exchange reachable"
 else
-  add_check "connectivity" "warn" "Some exchanges unreachable"
+  add_check "connectivity" "warn" "Exchange unreachable"
 fi
 
 # 4. Portfolio & balances

package/skills/perp-cli/scripts/spot-perp-scan.sh

@@ -38,8 +38,8 @@ fi
 # 2. Run appropriate scan
 SCAN_RESULT=$($PERP --json arb scan --mode "$MODE" --min "$MIN_SPREAD" 2>/dev/null || echo '{"ok":false}')
 
-# 3. Get exchange health for context
-HEALTH=$($PERP --json agent ping 2>/dev/null || echo '{"ok":false}')
+# 3. Get exchange health for context (proxy via market prices fetch)
+HEALTH=$($PERP --json market prices 2>/dev/null || echo '{"ok":false}')
 
 if $JSON_MODE; then
   cat <<EOF

package/dist/__tests__/alert-logic.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/alert-logic.test.js

@@ -1,107 +0,0 @@
-import { describe, it, expect } from "vitest";
-/**
- * Tests for the alert price merging logic (extracted from alert.ts).
- * Validates the fix for the price map key inconsistency bug.
- */
-function mergePrices(pacData, hlData) {
-    const map = new Map();
-    if (pacData) {
-        for (const p of pacData) {
-            map.set(`pac:${p.symbol}`, Number(p.mark));
-        }
-    }
-    if (hlData) {
-        for (const [symbol, price] of Object.entries(hlData)) {
-            map.set(`hl:${symbol}`, Number(price));
-        }
-    }
-    // Merge into bare symbol keys: prefer pac price, fallback to hl
-    const allSymbols = new Set();
-    for (const k of map.keys()) {
-        if (k.includes(":"))
-            allSymbols.add(k.split(":")[1]);
-    }
-    for (const sym of allSymbols) {
-        const pacPrice = map.get(`pac:${sym}`);
-        const hlPrice = map.get(`hl:${sym}`);
-        map.set(sym, pacPrice ?? hlPrice ?? 0);
-    }
-    return map;
-}
-describe("Alert price merging", () => {
-    it("prefers Pacifica price when both available", () => {
-        const map = mergePrices([{ symbol: "BTC", mark: "100000" }], { BTC: "99900" });
-        expect(map.get("BTC")).toBe(100000);
-        expect(map.get("pac:BTC")).toBe(100000);
-        expect(map.get("hl:BTC")).toBe(99900);
-    });
-    it("falls back to HL price when pac unavailable", () => {
-        const map = mergePrices(null, { ETH: "3500" });
-        expect(map.get("ETH")).toBe(3500);
-        expect(map.has("pac:ETH")).toBe(false);
-        expect(map.get("hl:ETH")).toBe(3500);
-    });
-    it("handles Pacifica-only symbols", () => {
-        const map = mergePrices([{ symbol: "SOL", mark: "150" }], {});
-        expect(map.get("SOL")).toBe(150);
-    });
-    it("handles empty data", () => {
-        const map = mergePrices(null, null);
-        expect(map.size).toBe(0);
-    });
-    it("handles multiple symbols from both sources", () => {
-        const map = mergePrices([
-            { symbol: "BTC", mark: "100000" },
-            { symbol: "ETH", mark: "3500" },
-        ], {
-            BTC: "99900",
-            ETH: "3490",
-            SOL: "150",
-        });
-        // Pac preferred for BTC and ETH
-        expect(map.get("BTC")).toBe(100000);
-        expect(map.get("ETH")).toBe(3500);
-        // HL-only for SOL
-        expect(map.get("SOL")).toBe(150);
-    });
-    it("bare symbol key is always set (no orphaned prefixed keys)", () => {
-        const map = mergePrices([{ symbol: "DOGE", mark: "0.15" }], { DOGE: "0.14", ARB: "1.20" });
-        // Every symbol with a prefixed key should have a bare key
-        for (const k of map.keys()) {
-            if (k.includes(":")) {
-                const bare = k.split(":")[1];
-                expect(map.has(bare)).toBe(true);
-            }
-        }
-    });
-});
-describe("Alert trigger conditions", () => {
-    it("fires price above alert", () => {
-        const currentPrice = 105000;
-        const threshold = 100000;
-        const condition = "above";
-        expect(condition === "above" && currentPrice >= threshold).toBe(true);
-    });
-    it("does NOT fire price above when below", () => {
-        const currentPrice = 95000;
-        const threshold = 100000;
-        const condition = "above";
-        expect(condition === "above" && currentPrice >= threshold).toBe(false);
-    });
-    it("fires price below alert", () => {
-        const currentPrice = 95000;
-        const threshold = 100000;
-        const condition = "below";
-        expect(condition === "below" && currentPrice <= threshold).toBe(true);
-    });
-    it("fires funding spread alert", () => {
-        const spread = 35; // annual %
-        const alertThreshold = 30;
-        expect(spread >= alertThreshold).toBe(true);
-    });
-    it("does NOT fire funding spread below threshold", () => {
-        const spread = 25;
-        const alertThreshold = 30;
-        expect(spread >= alertThreshold).toBe(false);
-    });
-});

package/dist/__tests__/arb-auto-3dex.test.d.ts

@@ -1 +0,0 @@
-export {};