minara 0.3.1 → 0.4.0

package/dist/commands/perps.js

@@ -6,13 +6,297 @@ import { requireAuth } from '../config.js';
 import { success, info, warn, spinner, assertApiOk, formatOrderSide, wrapAction, requireTransactionConfirmation, validateAddress } from '../utils.js';
 import { requireTouchId } from '../touchid.js';
 import { printTxResult, printTable, printKV, POSITION_COLUMNS, FILL_COLUMNS } from '../formatters.js';
+// ─── shared helpers ──────────────────────────────────────────────────────
+const WALLET_OPT = ['-w, --wallet <name>', 'Wallet name or ID'];
+const fmt = (n) => `$${n.toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+const pnlFmt = (n) => {
+    const color = n >= 0 ? chalk.green : chalk.red;
+    return color(`${n >= 0 ? '+' : ''}${fmt(n)}`);
+};
+function getSubAccountId(w) {
+    return String(w._id ?? w.id ?? w.subAccountId ?? '');
+}
+function getSubAccountLabel(w) {
+    const name = w.name ?? 'Unnamed';
+    const def = w.isDefault ? chalk.dim(' (default)') : '';
+    return `${name}${def}`;
+}
+/**
+ * Normalize the Hyperliquid sub-account summary into a consistent shape.
+ * The API returns: { marginSummary: { accountValue, totalNtlPos, totalMarginUsed },
+ *   withdrawable, assetPositions, ... }
+ * But we also handle the flattened shape used in our PerpSubAccount type as fallback.
+ */
+function normalizeWalletSummary(raw) {
+    const margin = raw.marginSummary;
+    if (margin) {
+        const rawPositions = Array.isArray(raw.assetPositions)
+            ? raw.assetPositions
+            : [];
+        const positions = rawPositions.map((ap) => {
+            const pos = (ap.position && typeof ap.position === 'object'
+                ? ap.position : ap);
+            return normalizePosition(pos);
+        });
+        return {
+            equity: parseFloat(String(margin.accountValue ?? 0)),
+            available: parseFloat(String(raw.withdrawable ?? 0)),
+            margin: parseFloat(String(margin.totalMarginUsed ?? 0)),
+            unrealizedPnl: parseFloat(String(margin.totalNtlPos ?? 0)),
+            positions,
+        };
+    }
+    // Fallback: flattened shape from PerpSubAccount or other responses
+    return {
+        equity: Number(raw.equityValue ?? raw.accountValue ?? 0),
+        available: Number(raw.dispatchableValue ?? raw.withdrawable ?? 0),
+        margin: Number(raw.totalMarginUsed ?? 0),
+        unrealizedPnl: Number(raw.totalUnrealizedPnl ?? raw.totalNtlPos ?? 0),
+        positions: Array.isArray(raw.positions) ? raw.positions : [],
+    };
+}
+/**
+ * Normalize a Hyperliquid position object to match our POSITION_COLUMNS keys.
+ * HL uses: coin, szi (signed size), entryPx, positionValue, unrealizedPnl,
+ *   leverage: { type, value }, liquidationPx, marginUsed, ...
+ */
+function normalizePosition(pos) {
+    const szi = parseFloat(String(pos.szi ?? pos.size ?? 0));
+    const lev = pos.leverage;
+    let leverageVal;
+    if (lev && typeof lev === 'object') {
+        const lo = lev;
+        leverageVal = String(lo.value ?? lo.rawUsd ?? '');
+    }
+    else if (lev !== undefined && lev !== null) {
+        leverageVal = String(lev);
+    }
+    return {
+        symbol: pos.coin ?? pos.symbol ?? '—',
+        side: szi > 0 ? 'Long' : szi < 0 ? 'Short' : (pos.side ?? '—'),
+        size: Math.abs(szi) || pos.size || '—',
+        entryPrice: pos.entryPx ?? pos.entryPrice,
+        positionValue: pos.positionValue,
+        unrealizedPnl: pos.unrealizedPnl,
+        leverage: leverageVal,
+        marginUsed: pos.marginUsed,
+        liquidationPx: pos.liquidationPx,
+    };
+}
+async function fetchSubAccounts(token) {
+    const res = await perpsApi.listSubAccounts(token);
+    if (!res.success || !res.data)
+        return [];
+    const raw = res.data;
+    if (Array.isArray(raw))
+        return raw;
+    if (raw && typeof raw === 'object') {
+        const inner = raw.data
+            ?? raw.subAccounts
+            ?? raw.wallets;
+        if (Array.isArray(inner))
+            return inner;
+    }
+    return [];
+}
+async function pickSubAccount(token, message = 'Select wallet:') {
+    const wallets = await fetchSubAccounts(token);
+    if (wallets.length === 0) {
+        warn('No perps wallets found.');
+        return null;
+    }
+    if (wallets.length === 1)
+        return wallets[0];
+    const summaries = await Promise.all(wallets.map((w) => perpsApi.getSubAccountSummary(token, getSubAccountId(w))));
+    return select({
+        message,
+        choices: wallets.map((w, i) => {
+            const raw = summaries[i].success && summaries[i].data
+                ? summaries[i].data : w;
+            const s = normalizeWalletSummary(raw);
+            const eq = fmt(s.available);
+            const addr = w.address ? chalk.yellow(w.address) : '';
+            return {
+                name: `${getSubAccountLabel(w)}  ${chalk.dim(eq)}  ${addr ? chalk.dim(addr.slice(0, 10) + '…') : ''}`,
+                value: w,
+            };
+        }),
+    });
+}
+/**
+ * Resolve a wallet by name (from --wallet flag) or interactive selection.
+ * Returns `{ wallet, walletId }` — walletId is undefined for the default account.
+ */
+async function resolveWallet(token, walletName, message = 'Select wallet:') {
+    const wallets = await fetchSubAccounts(token);
+    if (wallets.length === 0)
+        return null;
+    let wallet;
+    if (walletName) {
+        const nameUpper = walletName.toUpperCase();
+        const match = wallets.find((w) => (w.name ?? '').toUpperCase() === nameUpper
+            || getSubAccountId(w) === walletName);
+        if (!match) {
+            warn(`Wallet "${walletName}" not found. Available: ${wallets.map((w) => w.name ?? getSubAccountId(w)).join(', ')}`);
+            return null;
+        }
+        wallet = match;
+    }
+    else if (wallets.length === 1) {
+        wallet = wallets[0];
+    }
+    else {
+        const summaries = await Promise.all(wallets.map((w) => perpsApi.getSubAccountSummary(token, getSubAccountId(w))));
+        wallet = await select({
+            message,
+            choices: wallets.map((w, i) => {
+                const raw = summaries[i].success && summaries[i].data
+                    ? summaries[i].data : w;
+                const s = normalizeWalletSummary(raw);
+                const eq = fmt(s.available);
+                return {
+                    name: `${getSubAccountLabel(w)}  ${chalk.dim(eq)}`,
+                    value: w,
+                };
+            }),
+        });
+    }
+    const wId = getSubAccountId(wallet);
+    return { wallet, walletId: wallet.isDefault ? undefined : (wId || undefined) };
+}
+function parseStrategies(raw) {
+    if (Array.isArray(raw))
+        return raw;
+    if (raw && typeof raw === 'object') {
+        const inner = raw.strategies
+            ?? raw.data
+            ?? raw;
+        if (Array.isArray(inner))
+            return inner;
+        for (const v of Object.values(raw)) {
+            if (Array.isArray(v))
+                return v;
+        }
+    }
+    return [];
+}
+function extractStrategyName(s) {
+    for (const field of ['name', 'strategyName', 'title', 'label', 'displayName']) {
+        if (s[field] && typeof s[field] === 'string')
+            return String(s[field]);
+    }
+    // Try config-level name
+    if (s.strategyConfig && typeof s.strategyConfig === 'object') {
+        const cfg = s.strategyConfig;
+        if (cfg.name && typeof cfg.name === 'string')
+            return String(cfg.name);
+    }
+    // Build a descriptive name from symbols + pattern if available
+    const symbols = Array.isArray(s.symbols) ? s.symbols : [];
+    const symStr = symbols.length > 0
+        ? extractSymbolNames(symbols).join('/')
+        : undefined;
+    if (symStr && s.pattern !== undefined)
+        return `${symStr} P${s.pattern}`;
+    if (symStr)
+        return symStr;
+    return undefined;
+}
+function strategyToState(s) {
+    const status = String(s.status ?? s.state ?? s.isActive ?? s.enabled ?? '').toLowerCase();
+    const isActive = status === 'active' || status === 'enabled' || status === 'running'
+        || status === 'true' || s.isActive === true || s.enabled === true;
+    const symbols = Array.isArray(s.symbols)
+        ? s.symbols.map((sym) => {
+            if (typeof sym === 'string')
+                return sym;
+            if (sym && typeof sym === 'object') {
+                const o = sym;
+                return String(o.symbol ?? o.name ?? o.coin ?? sym);
+            }
+            return String(sym);
+        })
+        : [];
+    return {
+        active: isActive,
+        strategyId: String(s._id ?? s.id ?? s.strategyId ?? ''),
+        name: extractStrategyName(s),
+        symbols,
+        subAccountId: s.subAccountId ? String(s.subAccountId) : undefined,
+        strategyConfig: s.strategyConfig && typeof s.strategyConfig === 'object'
+            ? s.strategyConfig : undefined,
+        language: s.language ? String(s.language) : undefined,
+        createdAt: s.createdAt ? String(s.createdAt) : undefined,
+        updatedAt: s.updatedAt ? String(s.updatedAt) : undefined,
+        raw: s,
+    };
+}
+async function getAutopilotState(token) {
+    const res = await perpsApi.getStrategies(token);
+    if (!res.success || !res.data)
+        return { active: false };
+    const strategies = parseStrategies(res.data);
+    if (strategies.length === 0)
+        return { active: false };
+    return strategyToState(strategies[0]);
+}
+async function getAllAutopilotStates(token) {
+    const res = await perpsApi.getStrategies(token);
+    if (!res.success || !res.data)
+        return [];
+    return parseStrategies(res.data).map(strategyToState);
+}
+function getAutopilotForSubAccount(states, subAccountId) {
+    return states.find((s) => s.subAccountId === subAccountId);
+}
+function getAllStrategiesForWallet(states, walletId, isDefault) {
+    return states.filter((s) => {
+        if (s.subAccountId === walletId)
+            return true;
+        if (isDefault && !s.subAccountId)
+            return true;
+        return false;
+    });
+}
+function strategyDisplayName(s) {
+    if (s.name)
+        return s.name;
+    if (s.strategyId)
+        return s.strategyId.length > 12 ? s.strategyId.slice(0, 12) + '…' : s.strategyId;
+    return 'Unnamed';
+}
+/** Normalize supported-symbols response: handles string[], object[] with symbol/name key, or nested structures. */
+function extractSymbolNames(data) {
+    const fallback = ['BTC', 'ETH', 'SOL'];
+    if (!data)
+        return fallback;
+    const arr = Array.isArray(data) ? data : [];
+    if (arr.length === 0)
+        return fallback;
+    return arr.map((item) => {
+        if (typeof item === 'string')
+            return item;
+        if (item && typeof item === 'object') {
+            const obj = item;
+            const name = obj.symbol ?? obj.name ?? obj.coin ?? obj.asset ?? obj.ticker;
+            if (typeof name === 'string')
+                return name;
+        }
+        return String(item);
+    });
+}
 // ─── deposit ─────────────────────────────────────────────────────────────
 const depositCmd = new Command('deposit')
     .description('Deposit USDC into Hyperliquid perps (min 5 USDC)')
     .option('-a, --amount <amount>', 'USDC amount')
+    .option(WALLET_OPT[0], WALLET_OPT[1])
     .option('-y, --yes', 'Skip confirmation')
     .action(wrapAction(async (opts) => {
     const creds = requireAuth();
+    const resolved = await resolveWallet(creds.accessToken, opts.wallet, 'Deposit to which wallet?');
+    if (!resolved)
+        return;
+    const { wallet, walletId } = resolved;
     const amount = opts.amount
         ? parseFloat(opts.amount)
         : await numberPrompt({ message: 'USDC amount to deposit (min 5):', min: 5, required: true });
@@ -20,19 +304,19 @@ const depositCmd = new Command('deposit')
         console.error(chalk.red('✖'), 'Minimum deposit is 5 USDC');
         process.exit(1);
     }
-    console.log(`\n  Deposit : ${chalk.bold(amount)} USDC → Perps\n`);
+    console.log(`\n  Deposit : ${chalk.bold(amount)} USDC → ${getSubAccountLabel(wallet)}\n`);
     if (!opts.yes) {
         const ok = await confirm({ message: 'Confirm deposit?', default: true });
         if (!ok)
             return;
     }
-    await requireTransactionConfirmation(`Deposit ${amount} USDC → Perps`);
+    await requireTransactionConfirmation(`Deposit ${amount} USDC → ${wallet.name ?? 'Perps'}`);
     await requireTouchId();
     const spin = spinner('Depositing…');
-    const res = await perpsApi.deposit(creds.accessToken, { usdcAmount: amount });
+    const res = await perpsApi.deposit(creds.accessToken, { usdcAmount: amount, subAccountId: walletId });
     spin.stop();
     assertApiOk(res, 'Deposit failed');
-    success(`Deposited ${amount} USDC`);
+    success(`Deposited ${amount} USDC to ${getSubAccountLabel(wallet)}`);
     printTxResult(res.data);
 }));
 // ─── withdraw ────────────────────────────────────────────────────────────
@@ -40,9 +324,14 @@ const withdrawCmd = new Command('withdraw')
     .description('Withdraw USDC from Hyperliquid perps')
     .option('-a, --amount <amount>', 'USDC amount')
     .option('--to <address>', 'Destination address')
+    .option(WALLET_OPT[0], WALLET_OPT[1])
     .option('-y, --yes', 'Skip confirmation')
     .action(wrapAction(async (opts) => {
     const creds = requireAuth();
+    const resolved = await resolveWallet(creds.accessToken, opts.wallet, 'Withdraw from which wallet?');
+    if (!resolved)
+        return;
+    const { wallet, walletId } = resolved;
     const amount = opts.amount
         ? parseFloat(opts.amount)
         : await numberPrompt({ message: 'USDC amount to withdraw:', min: 0.01, required: true });
@@ -50,7 +339,7 @@ const withdrawCmd = new Command('withdraw')
         message: 'Destination address:',
         validate: (v) => validateAddress(v, 'arbitrum'),
     });
-    console.log(`\n  Withdraw : ${chalk.bold(amount)} USDC → ${chalk.yellow(toAddress)}\n`);
+    console.log(`\n  Withdraw : ${chalk.bold(amount)} USDC from ${getSubAccountLabel(wallet)} → ${chalk.yellow(toAddress)}\n`);
     warn('Withdrawals may take time to process.');
     if (!opts.yes) {
         const ok = await confirm({ message: 'Confirm withdrawal?', default: false });
@@ -60,7 +349,7 @@ const withdrawCmd = new Command('withdraw')
     await requireTransactionConfirmation(`Withdraw ${amount} USDC → ${toAddress}`);
     await requireTouchId();
     const spin = spinner('Withdrawing…');
-    const res = await perpsApi.withdraw(creds.accessToken, { usdcAmount: amount, toAddress });
+    const res = await perpsApi.withdraw(creds.accessToken, { usdcAmount: amount, toAddress, subAccountId: walletId });
     spin.stop();
     assertApiOk(res, 'Withdrawal failed');
     success('Withdrawal submitted');
@@ -69,53 +358,125 @@ const withdrawCmd = new Command('withdraw')
 // ─── positions ───────────────────────────────────────────────────────────
 const positionsCmd = new Command('positions')
     .alias('pos')
-    .description('View all open perps positions')
-    .action(wrapAction(async () => {
+    .description('View open perps positions')
+    .option(WALLET_OPT[0], WALLET_OPT[1])
+    .action(wrapAction(async (opts) => {
     const creds = requireAuth();
-    const spin = spinner('Fetching positions…');
-    const res = await perpsApi.getAccountSummary(creds.accessToken);
+    // If --wallet specified, show only that wallet
+    if (opts.wallet) {
+        const resolved = await resolveWallet(creds.accessToken, opts.wallet, 'View positions for which wallet?');
+        if (!resolved)
+            return;
+        const { wallet, walletId } = resolved;
+        const wId = walletId ?? getSubAccountId(wallet);
+        const spin = spinner(`Fetching ${wallet.name ?? 'wallet'}…`);
+        const sumRes = await perpsApi.getSubAccountSummary(creds.accessToken, wId);
+        spin.stop();
+        const raw = sumRes.success && sumRes.data ? sumRes.data : wallet;
+        const s = normalizeWalletSummary(raw);
+        console.log('');
+        console.log(chalk.bold(`${getSubAccountLabel(wallet)}:`));
+        console.log(`  Equity        : ${fmt(s.equity)}`);
+        console.log(`  Unrealized PnL: ${pnlFmt(s.unrealizedPnl)}`);
+        console.log(`  Margin Used   : ${fmt(s.margin)}`);
+        console.log('');
+        console.log(chalk.bold(`Open Positions (${s.positions.length}):`));
+        if (s.positions.length === 0) {
+            console.log(chalk.dim('  No open positions.'));
+        }
+        else {
+            printTable(s.positions, POSITION_COLUMNS);
+        }
+        console.log('');
+        return;
+    }
+    // No --wallet: show all wallets
+    const spin = spinner('Fetching wallets…');
+    const wallets = await fetchSubAccounts(creds.accessToken);
     spin.stop();
-    if (!res.success || !res.data) {
-        console.log(chalk.dim('Could not fetch positions.'));
-        if (res.error?.message)
-            console.log(chalk.dim(`  ${res.error.message}`));
+    if (wallets.length === 0) {
+        // Fallback to legacy single-wallet API
+        const legSpin = spinner('Fetching positions…');
+        const res = await perpsApi.getAccountSummary(creds.accessToken);
+        legSpin.stop();
+        if (!res.success || !res.data) {
+            console.log(chalk.dim('Could not fetch positions.'));
+            return;
+        }
+        const s = normalizeWalletSummary(res.data);
+        console.log('');
+        console.log(`  Equity        : ${fmt(s.equity)}`);
+        console.log(`  Unrealized PnL: ${pnlFmt(s.unrealizedPnl)}`);
+        console.log(`  Margin Used   : ${fmt(s.margin)}`);
+        console.log('');
+        console.log(chalk.bold(`Open Positions (${s.positions.length}):`));
+        if (s.positions.length === 0) {
+            console.log(chalk.dim('  No open positions.'));
+        }
+        else {
+            printTable(s.positions, POSITION_COLUMNS);
+        }
+        console.log('');
         return;
     }
-    const d = res.data;
-    const fmt = (n) => `$${n.toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
-    const pnlFmt = (n) => {
-        const color = n >= 0 ? chalk.green : chalk.red;
-        return color(`${n >= 0 ? '+' : ''}${fmt(n)}`);
-    };
-    console.log('');
-    console.log(`  Equity        : ${fmt(Number(d.equityValue ?? 0))}`);
-    console.log(`  Unrealized PnL: ${pnlFmt(Number(d.totalUnrealizedPnl ?? 0))}`);
-    console.log(`  Margin Used   : ${fmt(Number(d.totalMarginUsed ?? 0))}`);
-    const positions = Array.isArray(d.positions) ? d.positions : [];
-    console.log('');
-    console.log(chalk.bold(`Open Positions (${positions.length}):`));
-    if (positions.length === 0) {
-        console.log(chalk.dim('  No open positions.'));
+    // Multi-wallet: fetch all summaries in parallel
+    const sumSpin = spinner('Fetching wallet summaries…');
+    const summaryResults = await Promise.all(wallets.map((w) => perpsApi.getSubAccountSummary(creds.accessToken, getSubAccountId(w))));
+    const aggRes = await perpsApi.getAggregatedSummary(creds.accessToken);
+    sumSpin.stop();
+    let totalPositions = 0;
+    for (let i = 0; i < wallets.length; i++) {
+        const w = wallets[i];
+        const sumRes = summaryResults[i];
+        const raw = sumRes.success && sumRes.data ? sumRes.data : w;
+        const s = normalizeWalletSummary(raw);
+        totalPositions += s.positions.length;
+        console.log('');
+        console.log(chalk.bold(`${getSubAccountLabel(w)}:`));
+        console.log(`  Equity        : ${fmt(s.equity)}`);
+        console.log(`  Unrealized PnL: ${pnlFmt(s.unrealizedPnl)}`);
+        console.log(`  Margin Used   : ${fmt(s.margin)}`);
+        if (s.positions.length === 0) {
+            console.log(chalk.dim('  No open positions.'));
+        }
+        else {
+            printTable(s.positions, POSITION_COLUMNS);
+        }
     }
-    else {
-        printTable(positions, POSITION_COLUMNS);
+    console.log('');
+    if (aggRes.success && aggRes.data) {
+        const agg = aggRes.data;
+        const aggS = normalizeWalletSummary(agg);
+        console.log(chalk.bold('Aggregated:'));
+        console.log(`  Total Equity     : ${fmt(aggS.equity || Number(agg.totalEquity ?? 0))}`);
+        console.log(`  Total Unrl. PnL  : ${pnlFmt(aggS.unrealizedPnl || Number(agg.totalUnrealizedPnl ?? 0))}`);
+        console.log(`  Total Margin     : ${fmt(aggS.margin || Number(agg.totalMarginUsed ?? 0))}`);
     }
+    console.log(chalk.dim(`  Total positions: ${totalPositions}`));
     console.log('');
 }));
 // ─── order ───────────────────────────────────────────────────────────────
 const orderCmd = new Command('order')
     .description('Place a perps order')
+    .option(WALLET_OPT[0], WALLET_OPT[1])
     .option('-y, --yes', 'Skip confirmation')
     .action(wrapAction(async (opts) => {
     const creds = requireAuth();
-    // Check autopilot — block manual orders while AI is trading
+    const resolved = await resolveWallet(creds.accessToken, opts.wallet, 'Place order on which wallet?');
+    if (!resolved)
+        return;
+    const { wallet, walletId } = resolved;
+    // Check autopilot for this wallet
     const apSpin = spinner('Checking autopilot…');
-    const apState = await getAutopilotState(creds.accessToken);
+    const allStates = await getAllAutopilotStates(creds.accessToken);
     apSpin.stop();
-    if (apState.active) {
+    const wId = getSubAccountId(wallet);
+    const walletStrategies = getAllStrategiesForWallet(allStates, wId, !!wallet.isDefault);
+    const activeStrategy = walletStrategies.find((s) => s.active);
+    if (activeStrategy) {
         console.log('');
-        warn('Autopilot is currently ON. Manual order placement is disabled while AI is trading.');
-        info(`Trading symbols: ${apState.symbols?.join(', ') ?? 'unknown'}`);
+        warn(`Autopilot "${strategyDisplayName(activeStrategy)}" is ON for "${wallet.name ?? 'this wallet'}". Manual order placement is disabled while AI is trading.`);
+        info(`Trading symbols: ${activeStrategy.symbols?.join(', ') ?? 'unknown'}`);
         info('Turn off autopilot first: minara perps autopilot');
         console.log('');
         return;
@@ -228,38 +589,51 @@ const orderCmd = new Command('order')
     }
     await requireTouchId();
     const spin = spinner('Placing order…');
-    const res = await perpsApi.placeOrders(creds.accessToken, { orders: [order], grouping });
+    const res = await perpsApi.placeOrders(creds.accessToken, { orders: [order], grouping, subAccountId: walletId });
     spin.stop();
     assertApiOk(res, 'Order placement failed');
-    success('Order submitted!');
+    success(`Order submitted on ${getSubAccountLabel(wallet)}!`);
     printTxResult(res.data);
 }));
 // ─── cancel ──────────────────────────────────────────────────────────────
 const cancelCmd = new Command('cancel')
     .description('Cancel perps orders')
+    .option(WALLET_OPT[0], WALLET_OPT[1])
     .option('-y, --yes', 'Skip confirmation')
     .action(wrapAction(async (opts) => {
     const creds = requireAuth();
-    const spin = spinner('Fetching open orders…');
-    const address = await perpsApi.getPerpsAddress(creds.accessToken);
-    if (!address) {
-        spin.stop();
-        warn('Could not find your perps wallet address. Make sure your perps account is initialized.');
+    const resolved = await resolveWallet(creds.accessToken, opts.wallet, 'Cancel orders on which wallet?');
+    if (!resolved)
         return;
+    const { wallet, walletId } = resolved;
+    const spin = spinner('Fetching open orders…');
+    const wId = getSubAccountId(wallet);
+    let openOrders;
+    if (walletId) {
+        const ordRes = await perpsApi.getSubAccountOpenOrders(creds.accessToken, wId);
+        openOrders = ordRes.success && Array.isArray(ordRes.data) ? ordRes.data : [];
+    }
+    else {
+        const address = await perpsApi.getPerpsAddress(creds.accessToken);
+        if (!address) {
+            spin.stop();
+            warn('Could not find your perps wallet address.');
+            return;
+        }
+        openOrders = await perpsApi.getOpenOrders(address);
     }
-    const openOrders = await perpsApi.getOpenOrders(address);
     spin.stop();
     if (openOrders.length === 0) {
-        info('No open orders to cancel.');
+        info(`No open orders on ${getSubAccountLabel(wallet)}.`);
         return;
     }
     const selected = await select({
         message: 'Select order to cancel:',
         choices: openOrders.map((o) => {
             const side = o.side === 'B' ? chalk.green('BUY') : chalk.red('SELL');
-            const px = `$${Number(o.limitPx).toLocaleString()}`;
+            const px = `$${Number(o.limitPx ?? 0).toLocaleString()}`;
             return {
-                name: `${chalk.bold(o.coin.padEnd(6))} ${side}  ${o.sz} @ ${chalk.yellow(px)}  ${chalk.dim(`oid:${o.oid}`)}`,
+                name: `${chalk.bold(String(o.coin ?? '').padEnd(6))} ${side}  ${o.sz} @ ${chalk.yellow(px)}  ${chalk.dim(`oid:${o.oid}`)}`,
                 value: o,
             };
         }),
@@ -267,7 +641,7 @@ const cancelCmd = new Command('cancel')
     if (!opts.yes) {
         const sideLabel = selected.side === 'B' ? 'BUY' : 'SELL';
         const ok = await confirm({
-            message: `Cancel ${sideLabel} ${selected.coin} ${selected.sz} @ $${Number(selected.limitPx).toLocaleString()}?`,
+            message: `Cancel ${sideLabel} ${selected.coin} ${selected.sz} @ $${Number(selected.limitPx ?? 0).toLocaleString()}?`,
             default: false,
         });
         if (!ok)
@@ -275,7 +649,8 @@ const cancelCmd = new Command('cancel')
     }
     const cancelSpin = spinner('Cancelling…');
     const res = await perpsApi.cancelOrders(creds.accessToken, {
-        cancels: [{ a: selected.coin, o: selected.oid }],
+        cancels: [{ a: String(selected.coin), o: Number(selected.oid) }],
+        subAccountId: walletId,
     });
     cancelSpin.stop();
     assertApiOk(res, 'Order cancellation failed');
@@ -285,23 +660,32 @@ const cancelCmd = new Command('cancel')
 // ─── close position ─────────────────────────────────────────────────────
 const closeCmd = new Command('close')
     .description('Close an open perps position at market price')
+    .option(WALLET_OPT[0], WALLET_OPT[1])
     .option('-y, --yes', 'Skip confirmation')
     .option('-a, --all', 'Close all open positions (non-interactive)')
     .option('-s, --symbol <symbol>', 'Close position by symbol (non-interactive, e.g. BTC, ETH)')
     .action(wrapAction(async (opts) => {
     const creds = requireAuth();
+    const resolved = await resolveWallet(creds.accessToken, opts.wallet, 'Close position on which wallet?');
+    if (!resolved)
+        return;
+    const { wallet, walletId } = resolved;
     const spin = spinner('Fetching positions…');
-    const res = await perpsApi.getAccountSummary(creds.accessToken);
+    let d;
+    const wId = getSubAccountId(wallet);
+    if (walletId) {
+        const sumRes = await perpsApi.getSubAccountSummary(creds.accessToken, wId);
+        d = sumRes.success && sumRes.data ? sumRes.data : {};
+    }
+    else {
+        const res = await perpsApi.getAccountSummary(creds.accessToken);
+        d = res.success && res.data ? res.data : {};
+    }
     const assets = await perpsApi.getAssetMeta();
     spin.stop();
-    if (!res.success || !res.data) {
-        warn('Could not fetch positions.');
-        return;
-    }
-    const d = res.data;
     const positions = Array.isArray(d.positions) ? d.positions : [];
     if (positions.length === 0) {
-        info('No open positions to close.');
+        info(`No open positions on ${getSubAccountLabel(wallet)}.`);
         return;
     }
     const fmt = (n) => `$${n.toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
@@ -351,7 +735,7 @@ const closeCmd = new Command('close')
                 t: { trigger: { triggerPx: String(marketPx), tpsl: 'tp', isMarket: true } },
             };
             try {
-                const orderRes = await perpsApi.placeOrders(creds.accessToken, { orders: [order], grouping: 'na' });
+                const orderRes = await perpsApi.placeOrders(creds.accessToken, { orders: [order], grouping: 'na', subAccountId: walletId });
                 if (orderRes.success) {
                     results.push({ symbol, side, success: true });
                 }
@@ -455,7 +839,7 @@ const closeCmd = new Command('close')
     }
     await requireTouchId();
     const orderSpin = spinner('Closing position…');
-    const orderRes = await perpsApi.placeOrders(creds.accessToken, { orders: [order], grouping: 'na' });
+    const orderRes = await perpsApi.placeOrders(creds.accessToken, { orders: [order], grouping: 'na', subAccountId: walletId });
     orderSpin.stop();
     assertApiOk(orderRes, 'Close position failed');
     success(`Position closed — ${sideLabel} ${symbol} ${sz}`);
@@ -464,8 +848,13 @@ const closeCmd = new Command('close')
 // ─── leverage ────────────────────────────────────────────────────────────
 const leverageCmd = new Command('leverage')
     .description('Update leverage for a symbol')
-    .action(wrapAction(async () => {
+    .option(WALLET_OPT[0], WALLET_OPT[1])
+    .action(wrapAction(async (opts) => {
     const creds = requireAuth();
+    const resolved = await resolveWallet(creds.accessToken, opts.wallet, 'Update leverage on which wallet?');
+    if (!resolved)
+        return;
+    const { wallet, walletId } = resolved;
     const metaSpin = spinner('Fetching available assets…');
     const assets = await perpsApi.getAssetMeta();
     metaSpin.stop();
@@ -501,27 +890,40 @@ const leverageCmd = new Command('leverage')
         ],
     });
     const spin = spinner('Updating leverage…');
-    const res = await perpsApi.updateLeverage(creds.accessToken, { symbol, isCross, leverage: leverage });
+    const res = await perpsApi.updateLeverage(creds.accessToken, { symbol, isCross, leverage: leverage, subAccountId: walletId });
     spin.stop();
     assertApiOk(res, 'Failed to update leverage');
-    success(`Leverage set to ${leverage}x (${isCross ? 'cross' : 'isolated'}) for ${symbol}`);
+    success(`Leverage set to ${leverage}x (${isCross ? 'cross' : 'isolated'}) for ${symbol} on ${getSubAccountLabel(wallet)}`);
 }));
 // ─── trades ──────────────────────────────────────────────────────────────
 const tradesCmd = new Command('trades')
     .description('View your perps trade fills')
     .option('-n, --count <n>', 'Number of recent fills to show', '20')
     .option('-d, --days <n>', 'Look back N days', '7')
+    .option(WALLET_OPT[0], WALLET_OPT[1])
     .action(wrapAction(async (opts) => {
     const creds = requireAuth();
-    const spin = spinner('Fetching trade history…');
-    const address = await perpsApi.getPerpsAddress(creds.accessToken);
-    if (!address) {
-        spin.stop();
-        warn('Could not find your perps wallet address. Make sure your perps account is initialized.');
+    const resolved = await resolveWallet(creds.accessToken, opts.wallet, 'View trades for which wallet?');
+    if (!resolved)
         return;
-    }
+    const { wallet, walletId } = resolved;
     const days = Math.max(1, parseInt(opts.days, 10) || 7);
-    const fills = await perpsApi.getUserFills(address, days);
+    const startTime = Date.now() - days * 24 * 60 * 60 * 1000;
+    const spin = spinner('Fetching trade history…');
+    let fills;
+    if (walletId) {
+        const fillRes = await perpsApi.getSubAccountFills(creds.accessToken, walletId, startTime);
+        fills = fillRes.success && Array.isArray(fillRes.data) ? fillRes.data : [];
+    }
+    else {
+        const address = await perpsApi.getPerpsAddress(creds.accessToken);
+        if (!address) {
+            spin.stop();
+            warn('Could not find your perps wallet address.');
+            return;
+        }
+        fills = await perpsApi.getUserFills(address, days);
+    }
     spin.stop();
     const limit = Math.max(1, parseInt(opts.count, 10) || 20);
     const recent = fills.slice(0, limit);
@@ -530,11 +932,11 @@ const tradesCmd = new Command('trades')
     const closingFills = fills.filter((f) => Number(f.closedPnl ?? 0) !== 0);
     const wins = closingFills.filter((f) => Number(f.closedPnl) > 0).length;
     const pnlColor = totalPnl >= 0 ? chalk.green : chalk.red;
-    const fmt = (n) => `$${n.toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+    const fmtLocal = (n) => `$${n.toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
     console.log('');
-    console.log(chalk.bold(`Trade Fills (last ${days}d — ${fills.length} fills):`));
-    console.log(`  Realized PnL : ${pnlColor(`${totalPnl >= 0 ? '+' : ''}${fmt(totalPnl)}`)}`);
-    console.log(`  Total Fees   : ${chalk.dim(fmt(totalFees))}`);
+    console.log(chalk.bold(`Trade Fills — ${getSubAccountLabel(wallet)} (last ${days}d — ${fills.length} fills):`));
+    console.log(`  Realized PnL : ${pnlColor(`${totalPnl >= 0 ? '+' : ''}${fmtLocal(totalPnl)}`)}`);
+    console.log(`  Total Fees   : ${chalk.dim(fmtLocal(totalFees))}`);
     if (closingFills.length > 0) {
         console.log(`  Win Rate     : ${wins}/${closingFills.length} (${((wins / closingFills.length) * 100).toFixed(1)}%)`);
     }
@@ -553,166 +955,788 @@ const fundRecordsCmd = new Command('fund-records')
     .description('View perps fund deposit/withdraw records')
     .option('-p, --page <n>', 'Page', '1')
     .option('-l, --limit <n>', 'Limit', '20')
+    .option(WALLET_OPT[0], WALLET_OPT[1])
     .action(wrapAction(async (opts) => {
     const creds = requireAuth();
+    const resolved = await resolveWallet(creds.accessToken, opts.wallet, 'View records for which wallet?');
+    if (!resolved)
+        return;
+    const { wallet, walletId } = resolved;
+    const page = parseInt(opts.page, 10);
+    const limit = parseInt(opts.limit, 10);
     const spin = spinner('Fetching records…');
-    const res = await perpsApi.getFundRecords(creds.accessToken, parseInt(opts.page, 10), parseInt(opts.limit, 10));
+    let data;
+    if (walletId) {
+        const wId = getSubAccountId(wallet);
+        const recRes = await perpsApi.getSubAccountRecords(creds.accessToken, wId, page, limit);
+        data = recRes.success && Array.isArray(recRes.data) ? recRes.data : [];
+    }
+    else {
+        const res = await perpsApi.getFundRecords(creds.accessToken, page, limit);
+        assertApiOk(res, 'Failed to fetch fund records');
+        data = Array.isArray(res.data) ? res.data : [];
+    }
     spin.stop();
-    assertApiOk(res, 'Failed to fetch fund records');
     console.log('');
-    console.log(chalk.bold('Fund Records:'));
-    if (Array.isArray(res.data) && res.data.length > 0) {
-        printTable(res.data);
+    console.log(chalk.bold(`Fund Records — ${getSubAccountLabel(wallet)}:`));
+    if (data && data.length > 0) {
+        printTable(data);
     }
     else {
         console.log(chalk.dim('  No fund records.'));
     }
     console.log('');
 }));
-async function getAutopilotState(token) {
-    const res = await perpsApi.getStrategies(token);
-    if (!res.success || !res.data)
-        return { active: false };
-    // Response may be an array or { data: [...] } or nested object
-    let strategies = [];
-    const raw = res.data;
-    if (Array.isArray(raw)) {
-        strategies = raw;
+// ─── autopilot ──────────────────────────────────────────────────────────
+const autopilotCmd = new Command('autopilot')
+    .alias('ap')
+    .description('Manage AI autopilot trading strategy (per wallet)')
+    .option(WALLET_OPT[0], WALLET_OPT[1])
+    .action(wrapAction(async (opts) => {
+    const creds = requireAuth();
+    const loadSpin = spinner('Loading wallets & strategies…');
+    const [wallets, allStates, supported] = await Promise.all([
+        fetchSubAccounts(creds.accessToken),
+        getAllAutopilotStates(creds.accessToken),
+        perpsApi.getSupportedSymbols(creds.accessToken).then((r) => extractSymbolNames(r.success ? r.data : null)),
+    ]);
+    loadSpin.stop();
+    // ── Pick wallet ──────────────────────────────────────────────────
+    let wallet;
+    if (wallets.length === 0) {
+        warn('No perps wallets found.');
+        return;
     }
-    else if (raw && typeof raw === 'object') {
-        // Might be wrapped in { strategies: [...] } or { data: [...] }
-        const inner = raw.strategies
-            ?? raw.data
-            ?? raw;
-        if (Array.isArray(inner)) {
-            strategies = inner;
+    else if (opts.wallet) {
+        const nameUpper = opts.wallet.toUpperCase();
+        const match = wallets.find((w) => (w.name ?? '').toUpperCase() === nameUpper || getSubAccountId(w) === opts.wallet);
+        if (!match) {
+            warn(`Wallet "${opts.wallet}" not found. Available: ${wallets.map((w) => w.name ?? getSubAccountId(w)).join(', ')}`);
+            return;
         }
-        else {
-            for (const v of Object.values(raw)) {
-                if (Array.isArray(v)) {
-                    strategies.push(...v);
+        wallet = match;
+    }
+    else if (wallets.length === 1) {
+        wallet = wallets[0];
+    }
+    else {
+        const summaries = await Promise.all(wallets.map((w) => perpsApi.getSubAccountSummary(creds.accessToken, getSubAccountId(w))));
+        wallet = await select({
+            message: 'Select wallet for autopilot:',
+            choices: wallets.map((w, i) => {
+                const wId = getSubAccountId(w);
+                const wStrategies = getAllStrategiesForWallet(allStates, wId, !!w.isDefault);
+                const activeCount = wStrategies.filter((st) => st.active).length;
+                let apLabel;
+                if (wStrategies.length === 0) {
+                    apLabel = chalk.dim(' [No Strategy]');
+                }
+                else if (activeCount > 0) {
+                    apLabel = chalk.green(` [${activeCount}/${wStrategies.length} ON]`);
+                }
+                else {
+                    apLabel = chalk.dim(` [${wStrategies.length} strategies, all OFF]`);
+                }
+                const raw = summaries[i].success && summaries[i].data
+                    ? summaries[i].data : w;
+                const s = normalizeWalletSummary(raw);
+                return {
+                    name: `${getSubAccountLabel(w)}  ${chalk.dim(fmt(s.available))}${apLabel}`,
+                    value: w,
+                };
+            }),
+        });
+    }
+    const walletId = getSubAccountId(wallet);
+    const walletStrategies = getAllStrategiesForWallet(allStates, walletId, !!wallet.isDefault);
+    // ── No strategies for this wallet — offer create or attach ───────
+    if (walletStrategies.length === 0) {
+        console.log('');
+        info(`No autopilot strategies on ${getSubAccountLabel(wallet)}.`);
+        const unbound = allStates.filter((s) => s.strategyId && !s.subAccountId);
+        const action = await select({
+            message: 'What would you like to do?',
+            choices: [
+                { name: chalk.green('Create new strategy'), value: 'create' },
+                ...(unbound.length > 0
+                    ? [{ name: `Attach unbound strategy (${unbound.length} available)`, value: 'attach' }]
+                    : []),
+                { name: 'Back', value: 'back' },
+            ],
+        });
+        if (action === 'back')
+            return;
+        if (action === 'create') {
+            await createNewStrategy(creds.accessToken, supported, walletId, wallet);
+            return;
+        }
+        if (action === 'attach' && unbound.length > 0) {
+            const picked = await select({
+                message: 'Select strategy to attach:',
+                choices: unbound.map((s) => ({
+                    name: `${strategyDisplayName(s)}  ${s.symbols?.join(', ') ?? '—'}  ${s.active ? chalk.green('ON') : chalk.dim('OFF')}`,
+                    value: s,
+                })),
+            });
+            info(`Strategy: ${picked.strategyId} — ${strategyDisplayName(picked)} (${picked.symbols?.join(', ')})`);
+            return;
+        }
+        return;
+    }
+    // ── Show all strategies overview ─────────────────────────────────
+    console.log('');
+    console.log(chalk.bold(`Autopilot Strategies — ${getSubAccountLabel(wallet)} (${walletStrategies.length}):`));
+    console.log('');
+    for (const s of walletStrategies) {
+        const statusIcon = s.active ? chalk.green('● ON') : chalk.dim('○ OFF');
+        const nameLabel = chalk.bold(strategyDisplayName(s));
+        const symLabel = s.symbols && s.symbols.length > 0 ? s.symbols.join(', ') : chalk.dim('no symbols');
+        console.log(`  ${statusIcon}  ${nameLabel}  —  ${symLabel}`);
+        if (s.strategyId) {
+            console.log(`       ID: ${chalk.dim(s.strategyId)}`);
+        }
+        if (s.createdAt) {
+            console.log(`       Created: ${chalk.dim(s.createdAt)}`);
+        }
+    }
+    console.log('');
+    // ── Pick which strategy to manage ────────────────────────────────
+    let state;
+    if (walletStrategies.length === 1) {
+        state = walletStrategies[0];
+    }
+    else {
+        state = await select({
+            message: 'Select strategy to manage:',
+            choices: [
+                ...walletStrategies.map((s) => ({
+                    name: `${s.active ? chalk.green('●') : chalk.dim('○')} ${strategyDisplayName(s)}  ${s.symbols?.join(', ') ?? '—'}`,
+                    value: s,
+                })),
+                { name: chalk.green('+ Create new strategy'), value: { active: false } },
+            ],
+        });
+        if (!state.strategyId) {
+            await createNewStrategy(creds.accessToken, supported, walletId, wallet);
+            return;
+        }
+    }
+    // ── Strategy dashboard ───────────────────────────────────────────
+    await showAutopilotDashboard(creds.accessToken, wallet, state);
+    // ── Action menu loop ─────────────────────────────────────────────
+    let keepGoing = true;
+    while (keepGoing) {
+        const statusLabel = state.active ? chalk.green('ON') : chalk.dim('OFF');
+        const action = await select({
+            message: `${strategyDisplayName(state)} [${statusLabel}] — What would you like to do?`,
+            choices: [
+                ...(state.active
+                    ? [{ name: chalk.red('Turn OFF autopilot'), value: 'off' }]
+                    : [{ name: chalk.green('Turn ON autopilot'), value: 'on' }]),
+                { name: 'Update symbols', value: 'update-symbols' },
+                { name: 'Update strategy config', value: 'update-config' },
+                { name: 'View performance', value: 'perf' },
+                { name: 'View trading records', value: 'records' },
+                { name: 'Back', value: 'back' },
+            ],
+        });
+        switch (action) {
+            case 'back':
+                keepGoing = false;
+                break;
+            case 'on':
+                if (state.strategyId) {
+                    const spin = spinner('Enabling autopilot…');
+                    const res = await perpsApi.enableStrategy(creds.accessToken, state.strategyId);
+                    spin.stop();
+                    assertApiOk(res, 'Failed to enable autopilot');
+                    state.active = true;
+                    success(`${strategyDisplayName(state)} is now ON`);
+                }
+                break;
+            case 'off':
+                if (state.strategyId) {
+                    const ok = await confirm({ message: `Turn off ${strategyDisplayName(state)}? AI will stop trading.`, default: false });
+                    if (!ok)
+                        break;
+                    const spin = spinner('Disabling autopilot…');
+                    const res = await perpsApi.disableStrategy(creds.accessToken, state.strategyId);
+                    spin.stop();
+                    assertApiOk(res, 'Failed to disable autopilot');
+                    state.active = false;
+                    success(`${strategyDisplayName(state)} is now OFF`);
+                }
+                break;
+            case 'update-symbols': {
+                info(`Supported: ${supported.join(', ')} | Current: ${state.symbols?.join(', ') ?? 'none'}`);
+                const symbolsInput = await input({
+                    message: 'New symbols (comma-separated):',
+                    default: state.symbols?.join(',') ?? '',
+                });
+                const symbols = symbolsInput.split(',').map((s) => s.trim().toUpperCase()).filter(Boolean);
+                const spin = spinner('Updating symbols…');
+                const res = await perpsApi.updateStrategy(creds.accessToken, {
+                    strategyId: state.strategyId,
+                    symbols,
+                    strategyConfig: state.strategyConfig,
+                    language: state.language,
+                });
+                spin.stop();
+                assertApiOk(res, 'Failed to update symbols');
+                state.symbols = symbols;
+                success(`Symbols updated: ${symbols.join(', ')}`);
+                break;
+            }
+            case 'update-config': {
+                console.log('');
+                console.log(chalk.bold('Current strategy config:'));
+                if (state.strategyConfig && Object.keys(state.strategyConfig).length > 0) {
+                    printKV(state.strategyConfig);
+                }
+                else {
+                    console.log(chalk.dim('  No custom config set.'));
+                }
+                console.log('');
+                const configJson = await input({
+                    message: 'New config (JSON, or press Enter to keep current):',
+                    default: state.strategyConfig ? JSON.stringify(state.strategyConfig) : '{}',
+                });
+                let newConfig;
+                try {
+                    newConfig = JSON.parse(configJson);
+                }
+                catch {
+                    warn('Invalid JSON. Config not updated.');
                     break;
                 }
+                const spin = spinner('Updating config…');
+                const res = await perpsApi.updateStrategy(creds.accessToken, {
+                    strategyId: state.strategyId,
+                    symbols: state.symbols ?? [],
+                    strategyConfig: newConfig,
+                    language: state.language,
+                });
+                spin.stop();
+                assertApiOk(res, 'Failed to update config');
+                state.strategyConfig = newConfig;
+                success('Strategy config updated.');
+                break;
+            }
+            case 'perf': {
+                const spin = spinner('Fetching performance…');
+                const res = await perpsApi.getPerformanceMetrics(creds.accessToken);
+                spin.stop();
+                if (res.success && res.data) {
+                    const ap = state.strategyConfig?.pattern !== undefined
+                        ? String(state.strategyConfig.pattern) : undefined;
+                    console.log('');
+                    console.log(chalk.bold(`Performance — ${strategyDisplayName(state)}:`));
+                    printPerformanceData(res.data, ap);
+                    console.log('');
+                }
+                else {
+                    console.log(chalk.dim('  No performance data available.'));
+                }
+                break;
+            }
+            case 'records': {
+                const spin = spinner('Fetching records…');
+                const res = await perpsApi.getRecords(creds.accessToken, 1, 20);
+                spin.stop();
+                if (res.success && Array.isArray(res.data) && res.data.length > 0) {
+                    console.log('');
+                    console.log(chalk.bold('Recent Autopilot Records:'));
+                    printTable(res.data);
+                    console.log('');
+                }
+                else {
+                    console.log(chalk.dim('  No autopilot records.'));
+                }
+                break;
             }
         }
     }
-    if (strategies.length === 0)
-        return { active: false };
-    const s = strategies[0];
-    // Check all possible status field names
-    const status = String(s.status ?? s.state ?? s.isActive ?? s.enabled ?? '').toLowerCase();
-    const isActive = status === 'active' || status === 'enabled' || status === 'running'
-        || status === 'true' || s.isActive === true || s.enabled === true;
-    return {
-        active: isActive,
-        strategyId: String(s._id ?? s.id ?? s.strategyId ?? ''),
-        symbols: Array.isArray(s.symbols) ? s.symbols : [],
-    };
+}));
+async function createNewStrategy(token, supported, walletId, wallet) {
+    info(`Supported symbols: ${supported.join(', ')}`);
+    const symbolsInput = await input({
+        message: 'Symbols to trade (comma-separated):',
+        default: supported.slice(0, 3).join(','),
+    });
+    const symbols = symbolsInput.split(',').map((s) => s.trim().toUpperCase()).filter(Boolean);
+    const configInput = await input({
+        message: 'Strategy config (JSON, or press Enter for default):',
+        default: '{}',
+    });
+    let strategyConfig;
+    try {
+        const parsed = JSON.parse(configInput);
+        if (Object.keys(parsed).length > 0)
+            strategyConfig = parsed;
+    }
+    catch {
+        warn('Invalid JSON — using default config.');
+    }
+    const spin = spinner('Creating autopilot strategy…');
+    const res = await perpsApi.createStrategy(token, {
+        symbols,
+        subAccountId: walletId || undefined,
+        strategyConfig,
+    });
+    spin.stop();
+    assertApiOk(res, 'Failed to create autopilot strategy');
+    success(`Autopilot created for ${symbols.join(', ')} on ${getSubAccountLabel(wallet)}!`);
 }
-// ─── autopilot ──────────────────────────────────────────────────────────
-const autopilotCmd = new Command('autopilot')
-    .alias('ap')
-    .description('Manage AI autopilot trading strategy')
-    .action(wrapAction(async () => {
-    const creds = requireAuth();
-    const statusSpin = spinner('Checking autopilot status…');
-    const state = await getAutopilotState(creds.accessToken);
-    statusSpin.stop();
+async function showAutopilotDashboard(token, wallet, state) {
     const statusLabel = state.active ? chalk.green.bold('ON') : chalk.dim('OFF');
+    const nameLabel = strategyDisplayName(state);
     console.log('');
-    console.log(chalk.bold('Autopilot Status:') + ` ${statusLabel}`);
-    if (state.symbols && state.symbols.length > 0) {
-        console.log(`  Symbols : ${state.symbols.join(', ')}`);
+    console.log(chalk.bold(`Strategy: ${nameLabel}`) + `  ${statusLabel}  (${getSubAccountLabel(wallet)})`);
+    console.log('');
+    // ── Basic info ──────────────────────────────────────────────────
+    const infoRows = [];
+    if (state.strategyId)
+        infoRows.push(['ID', chalk.dim(state.strategyId)]);
+    if (state.symbols && state.symbols.length > 0)
+        infoRows.push(['Symbols', state.symbols.join(', ')]);
+    if (state.language)
+        infoRows.push(['Language', state.language]);
+    if (state.createdAt)
+        infoRows.push(['Created', chalk.dim(formatDateStr(state.createdAt))]);
+    if (state.updatedAt)
+        infoRows.push(['Updated', chalk.dim(formatDateStr(state.updatedAt))]);
+    const activePattern = state.strategyConfig?.pattern !== undefined
+        ? String(state.strategyConfig.pattern) : undefined;
+    if (activePattern)
+        infoRows.push(['Using', chalk.cyan.bold(`Strategy ${activePattern}`)]);
+    if (infoRows.length > 0) {
+        const maxLabel = Math.max(...infoRows.map(([l]) => l.length));
+        for (const [label, val] of infoRows) {
+            console.log(`  ${label.padEnd(maxLabel)} : ${val}`);
+        }
+    }
+    // ── Strategy Config ─────────────────────────────────────────────
+    if (state.strategyConfig && Object.keys(state.strategyConfig).length > 0) {
+        console.log('');
+        console.log(chalk.bold('  Config:'));
+        for (const [k, v] of Object.entries(state.strategyConfig)) {
+            if (k === 'pattern')
+                continue;
+            if (v && typeof v === 'object') {
+                console.log(`    ${chalk.dim(k)}:`);
+                for (const [ik, iv] of Object.entries(v)) {
+                    console.log(`      ${ik.padEnd(20)} : ${chalk.cyan(String(iv))}`);
+                }
+            }
+            else {
+                console.log(`    ${chalk.dim(k).padEnd(24)} : ${chalk.cyan(String(v))}`);
+            }
+        }
+    }
+    // ── Performance ─────────────────────────────────────────────────
+    const perfSpin = spinner('Fetching performance…');
+    const perfRes = await perpsApi.getPerformanceMetrics(token);
+    perfSpin.stop();
+    if (perfRes.success && perfRes.data) {
+        console.log('');
+        console.log(chalk.bold('  Performance (all strategies):'));
+        printPerformanceData(perfRes.data, activePattern);
     }
     console.log('');
-    const action = await select({
-        message: 'What would you like to do?',
-        choices: [
-            ...(state.active
-                ? [{ name: chalk.red('Turn OFF autopilot'), value: 'off' }]
-                : [{ name: chalk.green('Turn ON autopilot'), value: 'on' }]),
-            ...(!state.strategyId ? [{ name: 'Create autopilot strategy', value: 'create' }] : []),
-            ...(state.strategyId ? [{ name: 'Update symbols', value: 'update' }] : []),
-            { name: 'View performance', value: 'perf' },
-            { name: 'Back', value: 'back' },
-        ],
-    });
-    if (action === 'back')
+}
+function formatDateStr(d) {
+    try {
+        const date = new Date(d);
+        if (isNaN(date.getTime()))
+            return d;
+        return date.toLocaleString('en-US', {
+            year: 'numeric', month: 'short', day: 'numeric',
+            hour: '2-digit', minute: '2-digit',
+        });
+    }
+    catch {
+        return d;
+    }
+}
+/**
+ * Render performance metrics. Handles two formats:
+ * 1. Pattern-based: { "1": { estAPR, tradesCount }, "2": { ... }, ... }
+ * 2. Flat: { totalPnl, winRate, ... }
+ *
+ * @param activePattern - If set, highlights the column for this pattern ID (e.g. "5")
+ */
+function printPerformanceData(data, activePattern) {
+    const entries = Object.entries(data);
+    if (entries.length === 0) {
+        console.log(chalk.dim('    No data.'));
         return;
-    if (action === 'on' && state.strategyId) {
-        const spin = spinner('Enabling autopilot…');
-        const res = await perpsApi.enableStrategy(creds.accessToken, state.strategyId);
-        spin.stop();
-        assertApiOk(res, 'Failed to enable autopilot');
-        success('Autopilot is now ON');
+    }
+    // Detect pattern-based format: keys are numeric, values are objects
+    const isPatternBased = entries.every(([k, v]) => /^\d+$/.test(k) && v && typeof v === 'object');
+    if (isPatternBased) {
+        // Collect all metric keys across all patterns
+        const allKeys = new Set();
+        for (const [, v] of entries) {
+            for (const mk of Object.keys(v))
+                allKeys.add(mk);
+        }
+        const metricKeys = Array.from(allKeys);
+        // Header
+        const patternIds = entries.map(([k]) => k);
+        const colWidth = 16;
+        const labelCol = 16;
+        const header = '    '
+            + chalk.dim('Metric'.padEnd(labelCol))
+            + patternIds.map((id) => {
+                const label = `Strategy ${id}`;
+                if (id === activePattern)
+                    return chalk.bold.cyan(`${label} ★`.padStart(colWidth));
+                return chalk.bold(label.padStart(colWidth));
+            }).join('');
+        console.log(header);
+        console.log('    ' + chalk.dim('─'.repeat(labelCol + colWidth * patternIds.length)));
+        // Rows
+        const metricLabels = {
+            estAPR: 'Est. APR',
+            tradesCount: 'Trades',
+            pnl: 'PnL',
+            winRate: 'Win Rate',
+            sharpeRatio: 'Sharpe',
+            maxDrawdown: 'Max DD',
+        };
+        for (const mk of metricKeys) {
+            const label = (metricLabels[mk] ?? mk).padEnd(labelCol);
+            const cells = entries.map(([id, v]) => {
+                const val = v[mk];
+                if (val === undefined || val === null)
+                    return chalk.dim('—'.padStart(colWidth));
+                const num = Number(val);
+                const isActive = id === activePattern;
+                if (mk === 'estAPR' || mk.toLowerCase().includes('apr')) {
+                    const color = isActive ? chalk.cyan.bold : (num >= 0 ? chalk.green : chalk.red);
+                    return color(`${num.toFixed(2)}%`.padStart(colWidth));
+                }
+                if (mk.toLowerCase().includes('trades') || mk.toLowerCase().includes('count')) {
+                    const color = isActive ? chalk.cyan.bold : chalk.white;
+                    return color(num.toLocaleString().padStart(colWidth));
+                }
+                if (mk.toLowerCase().includes('pnl')) {
+                    return pnlFmt(num).padStart(colWidth);
+                }
+                return String(val).padStart(colWidth);
+            });
+            console.log(`    ${chalk.dim(label)}${cells.join('')}`);
+        }
         return;
     }
-    if (action === 'off' && state.strategyId) {
-        const ok = await confirm({ message: 'Turn off autopilot? AI will stop trading.', default: false });
-        if (!ok)
-            return;
-        const spin = spinner('Disabling autopilot…');
-        const res = await perpsApi.disableStrategy(creds.accessToken, state.strategyId);
-        spin.stop();
-        assertApiOk(res, 'Failed to disable autopilot');
-        success('Autopilot is now OFF');
-        return;
-    }
-    if (action === 'create' || (action === 'on' && !state.strategyId)) {
-        const symSpin = spinner('Fetching supported symbols…');
-        const symRes = await perpsApi.getSupportedSymbols(creds.accessToken);
-        symSpin.stop();
-        const supported = symRes.success && Array.isArray(symRes.data) ? symRes.data : ['BTC', 'ETH', 'SOL'];
-        info(`Supported symbols: ${supported.join(', ')}`);
-        const symbolsInput = await input({
-            message: 'Symbols to trade (comma-separated):',
-            default: supported.slice(0, 3).join(','),
-        });
-        const symbols = symbolsInput.split(',').map((s) => s.trim().toUpperCase()).filter(Boolean);
-        const spin = spinner('Creating autopilot strategy…');
-        const res = await perpsApi.createStrategy(creds.accessToken, { symbols });
-        spin.stop();
-        assertApiOk(res, 'Failed to create autopilot strategy');
-        success(`Autopilot created for ${symbols.join(', ')} and enabled!`);
-        return;
-    }
-    if (action === 'update' && state.strategyId) {
-        const symSpin = spinner('Fetching supported symbols…');
-        const symRes = await perpsApi.getSupportedSymbols(creds.accessToken);
-        symSpin.stop();
-        const supported = symRes.success && Array.isArray(symRes.data) ? symRes.data : ['BTC', 'ETH', 'SOL'];
-        info(`Supported: ${supported.join(', ')} | Current: ${state.symbols?.join(', ') ?? 'none'}`);
-        const symbolsInput = await input({
-            message: 'New symbols (comma-separated):',
-            default: state.symbols?.join(',') ?? '',
-        });
-        const symbols = symbolsInput.split(',').map((s) => s.trim().toUpperCase()).filter(Boolean);
-        const spin = spinner('Updating strategy…');
-        const res = await perpsApi.updateStrategy(creds.accessToken, { strategyId: state.strategyId, symbols });
-        spin.stop();
-        assertApiOk(res, 'Failed to update strategy');
-        success(`Autopilot updated: ${symbols.join(', ')}`);
+    // Flat format: render as key-value pairs with smart formatting
+    const flatFields = [
+        ['totalPnl', 'Total PnL'],
+        ['totalPnlPercent', 'Total PnL %'],
+        ['unrealizedPnl', 'Unrl. PnL'],
+        ['realizedPnl', 'Realized PnL'],
+        ['winRate', 'Win Rate'],
+        ['totalTrades', 'Total Trades'],
+        ['sharpeRatio', 'Sharpe Ratio'],
+        ['maxDrawdown', 'Max Drawdown'],
+        ['estAPR', 'Est. APR'],
+        ['tradesCount', 'Trades'],
+    ];
+    const knownKeys = new Set(flatFields.map(([k]) => k));
+    const allFields = [
+        ...flatFields,
+        ...entries.filter(([k]) => !knownKeys.has(k)).map(([k]) => [k, k]),
+    ];
+    for (const [key, label] of allFields) {
+        const v = data[key];
+        if (v === undefined || v === null)
+            continue;
+        if (typeof v === 'object') {
+            console.log(`    ${chalk.dim(label)}`);
+            for (const [ik, iv] of Object.entries(v)) {
+                console.log(`      ${ik.padEnd(18)} : ${chalk.cyan(String(iv))}`);
+            }
+            continue;
+        }
+        const num = Number(v);
+        let display;
+        if (key.includes('Pnl') && !key.includes('Percent')) {
+            display = pnlFmt(num);
+        }
+        else if (key.includes('Percent') || key === 'winRate' || key === 'maxDrawdown') {
+            const color = num >= 0 ? chalk.green : chalk.red;
+            display = color(`${num >= 0 ? '+' : ''}${num.toFixed(2)}%`);
+        }
+        else if (key.toLowerCase().includes('apr')) {
+            const color = num >= 0 ? chalk.green : chalk.red;
+            display = color(`${num.toFixed(2)}%`);
+        }
+        else if (key.toLowerCase().includes('trades') || key.toLowerCase().includes('count')) {
+            display = num.toLocaleString();
+        }
+        else {
+            display = String(v);
+        }
+        console.log(`    ${chalk.dim(label.padEnd(14))} : ${display}`);
+    }
+}
+// ─── wallets (list all sub-wallets) ─────────────────────────────────────
+const walletsCmd = new Command('wallets')
+    .alias('w')
+    .description('List all perps sub-wallets with balances, positions, and autopilot status')
+    .action(wrapAction(async () => {
+    const creds = requireAuth();
+    const spin = spinner('Fetching wallets…');
+    const [wallets, allStates] = await Promise.all([
+        fetchSubAccounts(creds.accessToken),
+        getAllAutopilotStates(creds.accessToken),
+    ]);
+    spin.stop();
+    if (wallets.length === 0) {
+        info('No perps wallets found. Create one with: minara perps create-wallet');
         return;
     }
-    if (action === 'perf') {
-        const spin = spinner('Fetching performance…');
-        const res = await perpsApi.getPerformanceMetrics(creds.accessToken);
-        spin.stop();
-        if (res.success && res.data) {
-            console.log('');
-            console.log(chalk.bold('Autopilot Performance:'));
-            printKV(res.data);
-            console.log('');
+    console.log('');
+    console.log(chalk.bold(`Perps Wallets (${wallets.length}):`));
+    console.log('');
+    // Fetch per-wallet summaries in parallel for accurate financial data
+    const summaryResults = await Promise.all(wallets.map((w) => perpsApi.getSubAccountSummary(creds.accessToken, getSubAccountId(w))));
+    for (let i = 0; i < wallets.length; i++) {
+        const w = wallets[i];
+        const sumRes = summaryResults[i];
+        const raw = sumRes.success && sumRes.data
+            ? sumRes.data
+            : w;
+        const s = normalizeWalletSummary(raw);
+        const wId = getSubAccountId(w);
+        const wStrategies = getAllStrategiesForWallet(allStates, wId, !!w.isDefault);
+        const activeCount = wStrategies.filter((st) => st.active).length;
+        let apLabel;
+        if (wStrategies.length === 0) {
+            apLabel = chalk.dim('[No AP]');
+        }
+        else if (activeCount > 0) {
+            apLabel = chalk.green(`[${activeCount}/${wStrategies.length} AP ON]`);
         }
         else {
-            console.log(chalk.dim('  No performance data available.'));
+            apLabel = chalk.dim(`[${wStrategies.length} AP OFF]`);
+        }
+        const defLabel = w.isDefault ? chalk.cyan(' (default)') : '';
+        console.log(`  ${chalk.bold(w.name ?? 'Unnamed')}${defLabel}  ${apLabel}`);
+        if (w.address) {
+            console.log(`    Address   : ${chalk.yellow(w.address)}`);
+        }
+        console.log(`    Equity    : ${fmt(s.equity)}`);
+        console.log(`    Available : ${fmt(s.available)}`);
+        console.log(`    Margin    : ${fmt(s.margin)}`);
+        console.log(`    Unrl. PnL : ${pnlFmt(s.unrealizedPnl)}`);
+        if (wStrategies.length > 0) {
+            const apNames = wStrategies.map((st) => `${strategyDisplayName(st)} (${st.symbols?.join(', ') ?? '—'})${st.active ? chalk.green(' ON') : ''}`);
+            console.log(`    Strategies: ${apNames.join(' | ')}`);
         }
+        if (s.positions.length > 0) {
+            console.log(`    Positions : ${s.positions.length} open`);
+        }
+        console.log('');
     }
+    // Aggregated summary
+    const aggSpin = spinner('Fetching aggregated summary…');
+    const aggRes = await perpsApi.getAggregatedSummary(creds.accessToken);
+    aggSpin.stop();
+    if (aggRes.success && aggRes.data) {
+        const agg = aggRes.data;
+        const aggS = normalizeWalletSummary(agg);
+        console.log(chalk.bold('Aggregated Summary:'));
+        console.log(`  Total Equity     : ${fmt(aggS.equity || Number(agg.totalEquity ?? 0))}`);
+        console.log(`  Total Unrl. PnL  : ${pnlFmt(aggS.unrealizedPnl || Number(agg.totalUnrealizedPnl ?? 0))}`);
+        console.log(`  Total Margin     : ${fmt(aggS.margin || Number(agg.totalMarginUsed ?? 0))}`);
+        console.log('');
+    }
+}));
+// ─── create-wallet ──────────────────────────────────────────────────────
+const createWalletCmd = new Command('create-wallet')
+    .description('Create a new perps sub-wallet')
+    .option('-n, --name <name>', 'Wallet name (max 20 chars)')
+    .action(wrapAction(async (opts) => {
+    const creds = requireAuth();
+    const name = opts.name ?? await input({
+        message: 'Wallet name (max 20 characters):',
+        validate: (v) => v.length > 0 && v.length <= 20 ? true : 'Name must be 1–20 characters',
+    });
+    const spin = spinner('Creating wallet…');
+    const res = await perpsApi.createSubAccount(creds.accessToken, { name });
+    spin.stop();
+    assertApiOk(res, 'Failed to create wallet');
+    success(`Wallet "${name}" created!`);
+    if (res.data?.address) {
+        console.log(`  Address: ${chalk.yellow(res.data.address)}`);
+    }
+}));
+// ─── rename-wallet ──────────────────────────────────────────────────────
+const renameWalletCmd = new Command('rename-wallet')
+    .description('Rename a perps sub-wallet')
+    .action(wrapAction(async () => {
+    const creds = requireAuth();
+    const spin = spinner('Loading wallets…');
+    const wallet = await pickSubAccount(creds.accessToken, 'Select wallet to rename:');
+    spin.stop();
+    if (!wallet)
+        return;
+    const newName = await input({
+        message: `New name for "${wallet.name ?? 'Unnamed'}" (max 10 chars):`,
+        validate: (v) => v.length > 0 && v.length <= 10 ? true : 'Name must be 1–10 characters',
+    });
+    const renameSpin = spinner('Renaming…');
+    const res = await perpsApi.renameSubAccount(creds.accessToken, {
+        subAccountId: getSubAccountId(wallet),
+        name: newName,
+    });
+    renameSpin.stop();
+    assertApiOk(res, 'Failed to rename wallet');
+    success(`Wallet renamed to "${newName}"`);
+}));
+// ─── sweep (consolidate sub-wallet funds to default) ────────────────────
+const sweepCmd = new Command('sweep')
+    .description('Consolidate funds from a sub-wallet to the default wallet')
+    .option('-y, --yes', 'Skip confirmation')
+    .action(wrapAction(async (opts) => {
+    const creds = requireAuth();
+    const loadSpin = spinner('Loading wallets & strategies…');
+    const [wallets, allStates] = await Promise.all([
+        fetchSubAccounts(creds.accessToken),
+        getAllAutopilotStates(creds.accessToken),
+    ]);
+    const nonDefault = wallets.filter((w) => !w.isDefault);
+    if (nonDefault.length === 0) {
+        loadSpin.stop();
+        info('No sub-wallets to sweep from. Only the default wallet exists.');
+        return;
+    }
+    const summaries = await Promise.all(nonDefault.map((w) => perpsApi.getSubAccountSummary(creds.accessToken, getSubAccountId(w))));
+    loadSpin.stop();
+    const wallet = await select({
+        message: 'Select sub-wallet to sweep funds FROM:',
+        choices: nonDefault.map((w, i) => {
+            const wId = getSubAccountId(w);
+            const wStrategies = getAllStrategiesForWallet(allStates, wId, !!w.isDefault);
+            const hasActive = wStrategies.some((s) => s.active);
+            const apLabel = hasActive ? chalk.red(' [AP ON — cannot sweep]') : '';
+            const raw = summaries[i].success && summaries[i].data
+                ? summaries[i].data : w;
+            const s = normalizeWalletSummary(raw);
+            const eq = fmt(s.available);
+            return {
+                name: `${getSubAccountLabel(w)}  ${chalk.dim(eq)}${apLabel}`,
+                value: w,
+            };
+        }),
+    });
+    const walletId = getSubAccountId(wallet);
+    const sweepStrategies = getAllStrategiesForWallet(allStates, walletId, !!wallet.isDefault);
+    const activeAp = sweepStrategies.find((s) => s.active);
+    if (activeAp) {
+        console.log('');
+        warn(`Autopilot "${strategyDisplayName(activeAp)}" is ON for "${wallet.name ?? 'Unnamed'}". You must turn it off before sweeping funds.`);
+        info('Run: minara perps autopilot → select this wallet → Turn OFF');
+        console.log('');
+        return;
+    }
+    const equity = Number(wallet.equityValue ?? 0);
+    if (equity <= 0) {
+        info('This wallet has no funds to sweep.');
+        return;
+    }
+    console.log('');
+    console.log(chalk.bold('Sweep Funds:'));
+    console.log(`  From   : ${getSubAccountLabel(wallet)}`);
+    console.log(`  To     : Default wallet`);
+    console.log(`  Amount : ${fmt(equity)} (all available)`);
+    console.log('');
+    if (!opts.yes) {
+        await requireTransactionConfirmation(`Sweep funds from "${wallet.name}" to default wallet`);
+    }
+    await requireTouchId();
+    const spin = spinner('Sweeping funds…');
+    const res = await perpsApi.sweepFunds(creds.accessToken, { subAccountId: walletId });
+    spin.stop();
+    assertApiOk(res, 'Sweep failed');
+    success(`Funds swept from "${wallet.name}" to default wallet`);
+    printTxResult(res.data);
+}));
+// ─── transfer (between sub-wallets) ─────────────────────────────────────
+const transferCmd = new Command('transfer')
+    .description('Transfer USDC between perps sub-wallets')
+    .option('-a, --amount <amount>', 'USDC amount')
+    .option('-y, --yes', 'Skip confirmation')
+    .action(wrapAction(async (opts) => {
+    const creds = requireAuth();
+    const spin = spinner('Loading wallets…');
+    const wallets = await fetchSubAccounts(creds.accessToken);
+    if (wallets.length < 2) {
+        spin.stop();
+        info('You need at least 2 wallets to transfer between them. Create one with: minara perps create-wallet');
+        return;
+    }
+    const summaries = await Promise.all(wallets.map((w) => perpsApi.getSubAccountSummary(creds.accessToken, getSubAccountId(w))));
+    spin.stop();
+    const walletLabel = (w, i) => {
+        const raw = summaries[i].success && summaries[i].data
+            ? summaries[i].data : w;
+        const s = normalizeWalletSummary(raw);
+        return `${getSubAccountLabel(w)}  ${chalk.dim(fmt(s.available))}`;
+    };
+    const from = await select({
+        message: 'Transfer FROM:',
+        choices: wallets.map((w, i) => ({
+            name: walletLabel(w, i),
+            value: w,
+        })),
+    });
+    const toChoices = wallets
+        .map((w, i) => ({ w, i }))
+        .filter(({ w }) => getSubAccountId(w) !== getSubAccountId(from));
+    const to = await select({
+        message: 'Transfer TO:',
+        choices: toChoices.map(({ w, i }) => ({
+            name: walletLabel(w, i),
+            value: w,
+        })),
+    });
+    const amount = opts.amount
+        ? parseFloat(opts.amount)
+        : await numberPrompt({ message: 'USDC amount to transfer:', min: 0.01, required: true });
+    if (!amount || amount <= 0) {
+        warn('Invalid amount.');
+        return;
+    }
+    console.log('');
+    console.log(chalk.bold('Transfer:'));
+    console.log(`  From   : ${getSubAccountLabel(from)}`);
+    console.log(`  To     : ${getSubAccountLabel(to)}`);
+    console.log(`  Amount : ${fmt(amount)}`);
+    console.log('');
+    if (!opts.yes) {
+        await requireTransactionConfirmation(`Transfer ${amount} USDC`);
+    }
+    await requireTouchId();
+    const transferSpin = spinner('Transferring…');
+    const fromId = from.isDefault ? undefined : getSubAccountId(from);
+    const toId = to.isDefault ? undefined : getSubAccountId(to);
+    const res = await perpsApi.transferFunds(creds.accessToken, {
+        fromSubAccountId: fromId,
+        toSubAccountId: toId,
+        amount,
+    });
+    transferSpin.stop();
+    assertApiOk(res, 'Transfer failed');
+    success(`Transferred ${amount} USDC from "${from.name}" to "${to.name}"`);
+    printTxResult(res.data);
 }));
 // ─── ask (long/short analysis) ──────────────────────────────────────────
 const askCmd = new Command('ask')
     .description('Get AI trading analysis for an asset (long/short recommendation)')
-    .action(wrapAction(async () => {
+    .option(WALLET_OPT[0], WALLET_OPT[1])
+    .action(wrapAction(async (opts) => {
     const creds = requireAuth();
     const dataSpin = spinner('Fetching assets…');
     const assets = await perpsApi.getAssetMeta();
@@ -786,10 +1810,17 @@ const askCmd = new Command('ask')
     const doQuick = await confirm({ message: 'Place this order now?', default: false });
     if (!doQuick)
         return;
-    // Check autopilot before placing
-    const apState = await getAutopilotState(creds.accessToken);
-    if (apState.active) {
-        warn('Autopilot is ON — manual orders are disabled while AI is trading.');
+    const resolved = await resolveWallet(creds.accessToken, opts.wallet, 'Place order on which wallet?');
+    if (!resolved)
+        return;
+    const { wallet: orderWallet, walletId: orderWalletId } = resolved;
+    // Check autopilot for this wallet before placing
+    const allStates = await getAllAutopilotStates(creds.accessToken);
+    const orderWId = getSubAccountId(orderWallet);
+    const orderWStrategies = getAllStrategiesForWallet(allStates, orderWId, !!orderWallet.isDefault);
+    const activeAsk = orderWStrategies.find((s) => s.active);
+    if (activeAsk) {
+        warn(`Autopilot "${strategyDisplayName(activeAsk)}" is ON for "${orderWallet.name ?? 'this wallet'}" — manual orders are disabled.`);
         info('Turn off autopilot first: minara perps autopilot');
         return;
     }
@@ -806,10 +1837,10 @@ const askCmd = new Command('ask')
     await requireTransactionConfirmation(`Perps ${isBuy ? 'LONG' : 'SHORT'} ${symbol} · size ${size} @ ~$${entryPrice.toLocaleString()}`);
     await requireTouchId();
     const orderSpin = spinner('Placing order…');
-    const orderRes = await perpsApi.placeOrders(creds.accessToken, { orders: [order], grouping: 'na' });
+    const orderRes = await perpsApi.placeOrders(creds.accessToken, { orders: [order], grouping: 'na', subAccountId: orderWalletId });
     orderSpin.stop();
     assertApiOk(orderRes, 'Order placement failed');
-    success('Order submitted!');
+    success(`Order submitted on ${getSubAccountLabel(orderWallet)}!`);
     printTxResult(orderRes.data);
 }));
 /** Try to extract a tradeable recommendation from the AI analysis response. */
@@ -886,7 +1917,8 @@ function flattenObj(obj, prefix = '') {
 //  Parent
 // ═════════════════════════════════════════════════════════════════════════
 export const perpsCommand = new Command('perps')
-    .description('Hyperliquid perpetual futures — order, positions, autopilot, analysis')
+    .description('Hyperliquid perpetual futures — wallets, order, positions, autopilot, analysis')
+    .addCommand(walletsCmd)
     .addCommand(positionsCmd)
     .addCommand(orderCmd)
     .addCommand(cancelCmd)
@@ -898,6 +1930,10 @@ export const perpsCommand = new Command('perps')
     .addCommand(fundRecordsCmd)
     .addCommand(autopilotCmd)
     .addCommand(askCmd)
+    .addCommand(createWalletCmd)
+    .addCommand(renameWalletCmd)
+    .addCommand(sweepCmd)
+    .addCommand(transferCmd)
     .action(wrapAction(async () => {
     const creds = requireAuth();
     // Show autopilot status inline
@@ -906,6 +1942,7 @@ export const perpsCommand = new Command('perps')
     const action = await select({
         message: 'Perps — what would you like to do?',
         choices: [
+            { name: 'View wallets', value: 'wallets' },
             { name: 'View positions', value: 'positions' },
             { name: 'Place order', value: 'order' },
             { name: 'Close position', value: 'close' },
@@ -917,6 +1954,11 @@ export const perpsCommand = new Command('perps')
             { name: 'Fund records', value: 'fund-records' },
             { name: `Autopilot${apLabel}`, value: 'autopilot' },
             { name: 'Ask AI (long/short analysis)', value: 'ask' },
+            { name: chalk.dim('─── Wallet Management ───'), value: '_sep', disabled: true },
+            { name: 'Create sub-wallet', value: 'create-wallet' },
+            { name: 'Rename sub-wallet', value: 'rename-wallet' },
+            { name: 'Sweep funds → default', value: 'sweep' },
+            { name: 'Transfer between wallets', value: 'transfer' },
         ],
     });
     const sub = perpsCommand.commands.find((c) => c.name() === action || c.aliases().includes(action));