@nexstone/rift-cli 0.1.1

package/dist/commands/deposit.js

@@ -0,0 +1,222 @@
+import { Args } from '@oclif/core';
+import { GatedCommand } from '../lib/base-command.js';
+import { getExistingSession } from '../lib/walletconnect.js';
+import { loadCredentials } from '../lib/credentials.js';
+import { green, red, cyan, dim } from '../lib/tui.js';
+// Bridge contract address (mainnet)
+const BRIDGE_MAINNET = '0x2Df1c51E09aECF9cacB7bc98cB1742757f163dF7';
+// USDC contract address (mainnet)
+const USDC_MAINNET = '0xaf88d065e77c8cC2239327C5EDb3A432268e5831';
+// Arbitrum mainnet chain ID
+const ARB_MAINNET_CHAIN_ID = 42161;
+// Minimal ABI for batchedDepositWithPermit
+const BRIDGE_ABI_FRAGMENT = [
+    {
+        inputs: [{
+                components: [
+                    { name: 'user', type: 'address' },
+                    { name: 'usd', type: 'uint64' },
+                    { name: 'deadline', type: 'uint64' },
+                    {
+                        components: [
+                            { name: 'v', type: 'uint8' },
+                            { name: 'r', type: 'uint256' },
+                            { name: 's', type: 'uint256' },
+                        ],
+                        name: 'signature',
+                        type: 'tuple',
+                    },
+                ],
+                name: 'deposits',
+                type: 'tuple[]',
+            }],
+        name: 'batchedDepositWithPermit',
+        outputs: [],
+        stateMutability: 'nonpayable',
+        type: 'function',
+    },
+];
+// Minimal ABI for USDC nonces query
+const USDC_NONCES_ABI = [
+    {
+        inputs: [{ name: 'owner', type: 'address' }],
+        name: 'nonces',
+        outputs: [{ name: '', type: 'uint256' }],
+        stateMutability: 'view',
+        type: 'function',
+    },
+];
+export default class Deposit extends GatedCommand {
+    static description = 'Deposit USDC from Arbitrum to Hyperliquid';
+    static examples = [
+        '$ rift deposit 100',
+    ];
+    static args = {
+        amount: Args.string({ description: 'USDC amount to deposit (minimum 5)', required: true }),
+    };
+    static flags = {};
+    async run() {
+        const { args } = await this.parse(Deposit);
+        const amount = parseFloat(args.amount);
+        if (amount < 5) {
+            this.log(`  ${red('✘')} Minimum deposit is 5 USDC. Amounts below 5 are lost permanently.`);
+            return;
+        }
+        const creds = loadCredentials();
+        if (!creds) {
+            this.log(`  ${red('✘')} No wallet configured. Run: ${cyan('rift auth setup')}`);
+            return;
+        }
+        const session = await getExistingSession();
+        if (!session) {
+            this.log(`  ${red('✘')} No wallet session. Run: ${cyan('rift auth setup')} to reconnect.`);
+            return;
+        }
+        const walletAddress = session.account;
+        const bridgeAddress = BRIDGE_MAINNET;
+        const usdcAddress = USDC_MAINNET;
+        const chainId = ARB_MAINNET_CHAIN_ID;
+        const chainRef = `eip155:${chainId}`;
+        // Convert to raw USDC units (6 decimals)
+        const rawAmount = BigInt(Math.round(amount * 1_000_000));
+        const deadline = Math.floor(Date.now() / 1000) + 3600; // 1 hour from now
+        this.log('');
+        this.log(`  Depositing $${amount} USDC to Hyperliquid...`);
+        this.log('');
+        // Step 1: Get USDC nonce for the permit
+        this.log(`  ${dim('Step 1/3: Querying USDC permit nonce...')}`);
+        let nonce;
+        try {
+            // Query USDC nonces via eth_call
+            const nonceCallData = '0x7ecebe00' + walletAddress.slice(2).padStart(64, '0');
+            const nonceResult = await session.client.request({
+                topic: session.topic,
+                chainId: chainRef,
+                request: {
+                    method: 'eth_call',
+                    params: [{ to: usdcAddress, data: nonceCallData }, 'latest'],
+                },
+            });
+            nonce = parseInt(nonceResult, 16);
+        }
+        catch {
+            // Fallback: assume nonce 0 (first permit)
+            nonce = 0;
+        }
+        // Step 2: Sign USDC permit via WalletConnect
+        this.log(`  ${dim('Step 2/3: Sign USDC permit...')}`);
+        this.log(`  ${dim('→ Approve in your wallet (check your phone)')}`);
+        const permitDomain = {
+            name: 'USD Coin',
+            version: '2',
+            chainId,
+            verifyingContract: usdcAddress,
+        };
+        const permitTypes = {
+            EIP712Domain: [
+                { name: 'name', type: 'string' },
+                { name: 'version', type: 'string' },
+                { name: 'chainId', type: 'uint256' },
+                { name: 'verifyingContract', type: 'address' },
+            ],
+            Permit: [
+                { name: 'owner', type: 'address' },
+                { name: 'spender', type: 'address' },
+                { name: 'value', type: 'uint256' },
+                { name: 'nonce', type: 'uint256' },
+                { name: 'deadline', type: 'uint256' },
+            ],
+        };
+        const permitMessage = {
+            owner: walletAddress,
+            spender: bridgeAddress,
+            value: rawAmount.toString(),
+            nonce,
+            deadline,
+        };
+        const permitTypedData = {
+            domain: permitDomain,
+            types: permitTypes,
+            primaryType: 'Permit',
+            message: permitMessage,
+        };
+        let permitSig;
+        try {
+            permitSig = await session.client.request({
+                topic: session.topic,
+                chainId: chainRef,
+                request: {
+                    method: 'eth_signTypedData_v4',
+                    params: [walletAddress, JSON.stringify(permitTypedData)],
+                },
+            });
+        }
+        catch (error) {
+            this.log(`  ${red('✘')} Permit signing failed: ${error?.message || 'User rejected'}`);
+            return;
+        }
+        this.log(`  ${green('✔')} Permit signed`);
+        // Parse permit signature
+        const sigHex = permitSig.startsWith('0x') ? permitSig.slice(2) : permitSig;
+        const permitR = '0x' + sigHex.slice(0, 64);
+        const permitS = '0x' + sigHex.slice(64, 128);
+        const permitV = parseInt(sigHex.slice(128, 130), 16);
+        // Step 3: Send batchedDepositWithPermit transaction via WalletConnect
+        this.log(`  ${dim('Step 3/3: Submit bridge deposit...')}`);
+        this.log(`  ${dim('→ Approve transaction in your wallet')}`);
+        // Encode batchedDepositWithPermit call data manually
+        // Function selector: keccak256("batchedDepositWithPermit((address,uint64,uint64,(uint8,uint256,uint256))[])")
+        // We'll use a simplified encoding approach
+        // ABI encode the deposit struct array
+        const encodedData = encodeBatchedDeposit(walletAddress, rawAmount, BigInt(deadline), permitV, permitR, permitS);
+        try {
+            const txHash = await session.client.request({
+                topic: session.topic,
+                chainId: chainRef,
+                request: {
+                    method: 'eth_sendTransaction',
+                    params: [{
+                            from: walletAddress,
+                            to: bridgeAddress,
+                            data: encodedData,
+                            // Gas will be estimated by the wallet
+                        }],
+                },
+            });
+            this.log(`  ${green('✔')} Deposit submitted!`);
+            this.log(`  ${dim(`$${amount} USDC will arrive on Hyperliquid in ~1 minute`)}`);
+            this.log(`  ${dim(`Tx: ${txHash}`)}`);
+            this.log('');
+            this.log(`  ${dim('Run:')} ${cyan('rift balance')} ${dim('to check when it arrives')}`);
+            this.log('');
+        }
+        catch (error) {
+            this.log(`  ${red('✘')} Deposit transaction failed: ${error?.message || 'User rejected'}`);
+        }
+    }
+}
+/**
+ * ABI-encode the batchedDepositWithPermit call data.
+ *
+ * This encodes: batchedDepositWithPermit([(user, usd, deadline, (v, r, s))])
+ */
+function encodeBatchedDeposit(user, usd, deadline, v, r, s) {
+    // Function selector for batchedDepositWithPermit((address,uint64,uint64,(uint8,uint256,uint256))[])
+    // Computed from keccak256 of the signature
+    const selector = '0xea7fb094';
+    // ABI encoding for dynamic array of structs
+    const pad = (hex, bytes = 32) => hex.replace('0x', '').padStart(bytes * 2, '0');
+    const toUint = (n) => pad(BigInt(n).toString(16));
+    // Offset to array data (32 bytes)
+    const arrayOffset = toUint(32n);
+    // Array length (1 deposit)
+    const arrayLength = toUint(1n);
+    // Struct fields (packed, no dynamic types within struct)
+    const userPadded = pad(user.toLowerCase());
+    const usdPadded = toUint(usd);
+    const deadlinePadded = toUint(deadline);
+    const vPadded = toUint(BigInt(v));
+    const rPadded = pad(r);
+    const sPadded = pad(s);
+    return selector + arrayOffset + arrayLength + userPadded + usdPadded + deadlinePadded + vPadded + rPadded + sPadded;
+}

package/dist/commands/doctor.d.ts

@@ -0,0 +1,6 @@
+import { GatedCommand } from '../lib/base-command.js';
+export default class Doctor extends GatedCommand {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/doctor.js

@@ -0,0 +1,87 @@
+import { GatedCommand } from '../lib/base-command.js';
+import { runEngine } from '../lib/python-bridge.js';
+import { hasCredentials, loadCredentials } from '../lib/credentials.js';
+import { hasApprovedFees, hasOnChainApproval, getFeeStatus } from '../lib/fees.js';
+const ok = (s) => `\x1b[32m✔\x1b[0m ${s}`;
+const fail = (s) => `\x1b[31m✘\x1b[0m ${s}`;
+const warn = (s) => `\x1b[33m!\x1b[0m ${s}`;
+const info = (s) => `\x1b[36m◦\x1b[0m ${s}`;
+const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+export default class Doctor extends GatedCommand {
+    static description = 'Check system health and diagnose issues';
+    static examples = [
+        '$ rift doctor',
+    ];
+    async run() {
+        this.log('');
+        this.log(`  ${bold('RIFT Doctor')}`);
+        this.log(`  ${dim('─'.repeat(40))}`);
+        this.log('');
+        // Node.js check
+        this.log(`  ${ok(`Node.js ${process.version}`)}`);
+        // Builder fee check (two layers)
+        if (hasApprovedFees()) {
+            const status = getFeeStatus();
+            this.log(`  ${ok(`Builder fee consent ${dim(status?.approvedAt ? `(${status.approvedAt.slice(0, 10)})` : '')}`)}`);
+            // The "on-chain approved" status lives in two places:
+            //   - ~/.rift/config.json.fees.onChainApproved (legacy TS-flow flag)
+            //   - ~/.rift/credentials.builder_fee_approved (canonical, set by
+            //     agent-pair + standalone approve-builder-fee)
+            // Treat either as evidence the approval went through.
+            const creds = loadCredentials();
+            const onChainOk = hasOnChainApproval() || (creds?.builder_fee_approved === true);
+            if (onChainOk) {
+                this.log(`  ${ok(`On-chain approval ${dim('(ready for live trading)')}`)}`);
+            }
+            else {
+                this.log(`  ${info(`On-chain approval pending ${dim('(needed for live trading only)')}`)}`);
+            }
+        }
+        else {
+            this.log(`  ${fail(`Builder fee not approved ${dim('— run: rift auth setup')}`)}`);
+        }
+        // Credentials check
+        if (hasCredentials()) {
+            const creds = loadCredentials();
+            if (creds) {
+                // `type` is optional — Python's agent-pair flow doesn't set it.
+                // Omit the parenthetical when unknown rather than printing "undefined".
+                const detail = creds.type
+                    ? `(${creds.network}, ${creds.type})`
+                    : `(${creds.network})`;
+                this.log(`  ${ok(`Wallet configured ${dim(detail)}`)}`);
+            }
+        }
+        else {
+            this.log(`  ${warn(`No wallet configured ${dim('— run: rift auth setup')}`)}`);
+        }
+        // Engine checks (Python side)
+        try {
+            await runEngine('doctor', [], (msg) => {
+                if (msg.type === 'result') {
+                    const checks = msg.checks;
+                    for (const check of checks) {
+                        const detail = dim(check.detail);
+                        if (check.status === 'ok') {
+                            this.log(`  ${ok(`${check.name} ${detail}`)}`);
+                        }
+                        else if (check.status === 'warn') {
+                            this.log(`  ${warn(`${check.name} ${detail}`)}`);
+                        }
+                        else if (check.status === 'info') {
+                            this.log(`  ${info(`${check.name} ${detail}`)}`);
+                        }
+                        else {
+                            this.log(`  ${fail(`${check.name} ${detail}`)}`);
+                        }
+                    }
+                }
+            });
+        }
+        catch (error) {
+            this.log(`  ${fail(`Python engine — ${error.message.split('\n')[0]}`)}`);
+        }
+        this.log('');
+    }
+}

package/dist/commands/funding-browser.d.ts

@@ -0,0 +1,12 @@
+import { GatedCommand } from '../lib/base-command.js';
+export default class FundingBrowser extends GatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        coins: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        top: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        days: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/funding-browser.js

@@ -0,0 +1,33 @@
+import { Flags } from '@oclif/core';
+import { GatedCommand } from '../lib/base-command.js';
+import { passthroughToEngine } from '../lib/engine-passthrough.js';
+export default class FundingBrowser extends GatedCommand {
+    static description = 'Browse funding rates across coins — current + window stats + extremes';
+    static examples = [
+        '$ rift funding-browser',
+        '$ rift funding-browser --top 50',
+        '$ rift funding-browser --coins BTC,ETH,SOL --days 30',
+    ];
+    static flags = {
+        coins: Flags.string({ description: 'Comma-separated coin list (default: all cached)', default: '' }),
+        top: Flags.string({ description: 'Number of coins to show, ranked by current funding', default: '20' }),
+        days: Flags.string({ description: 'History window in days', default: '7' }),
+        json: Flags.boolean({ description: 'Emit raw JSON only', default: false }),
+    };
+    async run() {
+        const { flags } = await this.parse(FundingBrowser);
+        const args = [];
+        if (flags.coins)
+            args.push('--coins', flags.coins);
+        args.push('--top', flags.top);
+        args.push('--days', flags.days);
+        await passthroughToEngine({
+            command: 'funding-browser',
+            args,
+            log: (m) => this.log(m),
+            error: (m) => this.error(m),
+            exit: (c) => this.exit(c),
+            jsonOnly: flags.json,
+        });
+    }
+}

package/dist/commands/guide.d.ts

@@ -0,0 +1,6 @@
+import { GatedCommand } from '../lib/base-command.js';
+export default class Guide extends GatedCommand {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/guide.js

@@ -0,0 +1,15 @@
+import { GatedCommand } from '../lib/base-command.js';
+import { passthroughToEngine } from '../lib/engine-passthrough.js';
+export default class Guide extends GatedCommand {
+    static description = 'Print the RIFT research-to-trade journey as a quick reference';
+    static examples = ['$ rift guide'];
+    async run() {
+        await passthroughToEngine({
+            command: 'guide',
+            args: [],
+            log: (m) => this.log(m),
+            error: (m) => this.error(m),
+            exit: (c) => this.exit(c),
+        });
+    }
+}

package/dist/commands/home.d.ts

@@ -0,0 +1,23 @@
+import { GatedCommand } from '../lib/base-command.js';
+export default class Home extends GatedCommand {
+    static description: string;
+    static args: {};
+    static flags: {};
+    static skipFooter: boolean;
+    run(): Promise<void>;
+    /**
+     * Run a subcommand and prevent its output from being clobbered by the
+     * next menu redraw.
+     *
+     * If the command exits in < 1500ms (almost always a precondition failure
+     * like "wallet not configured" that prints an error and bails), pause for
+     * keypress so the user can actually read what happened before the menu
+     * redraws over it.
+     *
+     * If the command ran for longer, the user was interacting with it and
+     * doesn't need a pause — redraw immediately for a clean menu transition.
+     */
+    private dispatch;
+    private aiIntegrationMenu;
+    private settingsMenu;
+}

package/dist/commands/home.js

@@ -0,0 +1,210 @@
+import { GatedCommand } from '../lib/base-command.js';
+import { green, cyan, bold, dim, ask, } from '../lib/tui.js';
+// Gradient colors — bright cyan at top, fading to dark blue at bottom
+const LOGO_GRADIENT = [
+    '\x1b[1m\x1b[96m', // bright cyan (line 1)
+    '\x1b[1m\x1b[36m', // cyan (line 2)
+    '\x1b[36m', // cyan normal (line 3)
+    '\x1b[34m', // blue (line 4)
+    '\x1b[2m\x1b[34m', // dim blue (line 5)
+    '\x1b[2m\x1b[34m', // dim blue (line 6)
+];
+const LOGO = [
+    '██████╗ ██╗███████╗████████╗',
+    '██╔══██╗██║██╔════╝╚══██╔══╝',
+    '██████╔╝██║█████╗     ██║   ',
+    '██╔══██╗██║██╔══╝     ██║   ',
+    '██║  ██║██║██║        ██║   ',
+    '╚═╝  ╚═╝╚═╝╚═╝        ╚═╝   ',
+];
+export default class Home extends GatedCommand {
+    static description = 'RIFT — Research · Iteration · Forecast · Trade';
+    static args = {};
+    static flags = {};
+    // Home renders its own bottom-of-screen status via renderStatusFooter()
+    // inline — skip the auto-footer that GatedCommand.finally() adds.
+    static skipFooter = true;
+    async run() {
+        // Main loop — after each action the user returns to the menu.
+        // Exit via `0`, `q`, `quit`, `exit`, or Ctrl-C.
+        while (true) {
+            // Logo with vertical gradient
+            this.log('');
+            for (let i = 0; i < LOGO.length; i++) {
+                this.log(`  ${LOGO_GRADIENT[i]}${LOGO[i]}\x1b[0m`);
+            }
+            this.log('');
+            this.log(`  ${dim('Research · Iteration · Forecast · Trade')}`);
+            this.log(`  ${dim('─'.repeat(42))}`);
+            this.log('');
+            // Menu
+            this.log(`    ${cyan('1')}  ${bold('Scout')}               ${dim('scan the market for opportunities')}`);
+            this.log(`    ${cyan('2')}  ${bold('Trade')}               ${dim('manual trade with live monitoring')}`);
+            this.log(`    ${cyan('3')}  ${bold('Research Lab')}        ${dim('discover, build, test, optimize')}`);
+            this.log(`    ${cyan('4')}  ${bold('Algo Trading')}        ${dim('automated strategy trading')}`);
+            this.log(`    ${cyan('5')}  ${bold('Portfolio Manager')}   ${dim('multi-strategy algo trading')}`);
+            this.log('');
+            this.log(`    ${cyan('6')}  ${dim('Doctor')}              ${dim('system health check')}`);
+            this.log(`    ${cyan('7')}  ${dim('Settings')}            ${dim('wallet, config, proxy')}`);
+            this.log(`    ${cyan('8')}  ${dim('AI Integration')}      ${dim('connect Claude, Cursor, or any AI')}`);
+            this.log('');
+            this.log(`    ${cyan('0')}  ${dim('Exit')}`);
+            this.log('');
+            this.log(`    ${dim('Tip:')} ${cyan('rift more')} ${dim('shows every engine command')}`);
+            this.log('');
+            // Phase 0 status footer — reflects real on-disk state
+            const { renderStatusFooter } = await import('../lib/status-footer.js');
+            this.log(renderStatusFooter());
+            this.log('');
+            // Input
+            const choice = await ask(`  ${cyan('>')} `);
+            switch (choice) {
+                case '0':
+                case 'q':
+                case 'quit':
+                case 'exit':
+                    this.log('');
+                    return;
+                case '1':
+                    await this.dispatch('scout');
+                    break;
+                case '2':
+                    await this.dispatch('trade');
+                    break;
+                case '3':
+                    await this.dispatch('research');
+                    break;
+                case '4':
+                    await this.dispatch('algo');
+                    break;
+                case '5':
+                    await this.dispatch('portfolio:status');
+                    break;
+                case '6':
+                    await this.dispatch('doctor');
+                    break;
+                case '7':
+                    await this.settingsMenu();
+                    break;
+                case '8':
+                    await this.aiIntegrationMenu();
+                    break;
+                default:
+                    if (choice) {
+                        this.log(`\n  ${dim('Unknown option. Try 0-8.')}\n`);
+                    }
+            }
+        }
+    }
+    /**
+     * Run a subcommand and prevent its output from being clobbered by the
+     * next menu redraw.
+     *
+     * If the command exits in < 1500ms (almost always a precondition failure
+     * like "wallet not configured" that prints an error and bails), pause for
+     * keypress so the user can actually read what happened before the menu
+     * redraws over it.
+     *
+     * If the command ran for longer, the user was interacting with it and
+     * doesn't need a pause — redraw immediately for a clean menu transition.
+     */
+    async dispatch(cmd, args = []) {
+        const start = Date.now();
+        try {
+            await this.config.runCommand(cmd, args);
+        }
+        catch (err) {
+            // Surface unexpected throws so the user can see them.
+            this.log(`\n  ${dim('Command threw:')} ${err?.message ?? err}\n`);
+        }
+        const elapsed = Date.now() - start;
+        if (elapsed < 1500) {
+            await ask(`  ${dim('Press Enter to return to menu...')} `);
+        }
+    }
+    async aiIntegrationMenu() {
+        this.log('');
+        this.log(`  ${bold('AI Integration')} ${dim('— connect AI agents to RIFT')}`);
+        this.log(`  ${dim('─'.repeat(50))}`);
+        this.log('');
+        this.log(`  RIFT exposes ${bold('59 tools')} via MCP (Model Context Protocol).`);
+        this.log(`  Any AI agent can research, backtest, optimize, and`);
+        this.log(`  build strategies through RIFT autonomously.`);
+        this.log('');
+        this.log(`  ${bold('Claude Desktop / Claude Code:')}`);
+        this.log('');
+        this.log(`  Add to your config file:`);
+        this.log('');
+        this.log(`  ${dim('{')}`);
+        this.log(`    ${dim('"mcpServers":')} ${dim('{')}`);
+        this.log(`      ${dim('"rift":')} ${dim('{')}`);
+        this.log(`        ${cyan('"command"')}: ${green('"rift"')},`);
+        this.log(`        ${cyan('"args"')}: [${green('"serve"')}]`);
+        this.log(`      ${dim('}')}`);
+        this.log(`    ${dim('}')}`);
+        this.log(`  ${dim('}')}`);
+        this.log('');
+        this.log(`  ${dim('Config location:')}`);
+        this.log(`    ${dim('macOS:')} ~/Library/Application Support/Claude/claude_desktop_config.json`);
+        this.log(`    ${dim('Windows:')} %APPDATA%/Claude/claude_desktop_config.json`);
+        this.log('');
+        this.log(`  ${bold('Tool categories:')}`);
+        this.log(`    ${dim('Research      backtest, research, compare, sweep, smart_sweep,')}`);
+        this.log(`    ${dim('              walk_forward, montecarlo, quick_test, verify,')}`);
+        this.log(`    ${dim('              indicator_stats, feature_importance, tearsheet')}`);
+        this.log(`    ${dim('Trade         scout, scan, manual_trade, buy, sell,')}`);
+        this.log(`    ${dim('              close_position, reduce_position, tighten_stop')}`);
+        this.log(`    ${dim('Algo          algo_start, algo_status, algo_stop')}`);
+        this.log(`    ${dim('Portfolio     portfolio_start, portfolio_status,')}`);
+        this.log(`    ${dim('              portfolio_stop, portfolio_alerts')}`);
+        this.log(`    ${dim('Account       balance, holdings, state, transfer,')}`);
+        this.log(`    ${dim('              deposit, withdraw, auth_setup, auth_status')}`);
+        this.log(`    ${dim('Reports       tca_report, pnl_attribution, var_report,')}`);
+        this.log(`    ${dim('              generate_report, audit_export, history')}`);
+        this.log(`    ${dim('Data          fetch_data, list_data, data_inventory')}`);
+        this.log(`    ${dim('Workbench     workbench_create, workbench_update,')}`);
+        this.log(`    ${dim('              workbench_show, save_optimized, strategy_versions')}`);
+        this.log(`    ${dim('System        doctor, health, cost, lessons, add_lesson,')}`);
+        this.log(`    ${dim('              guide, list_strategies, experiments,')}`);
+        this.log(`    ${dim('              api_start, watchdog_events')}`);
+        this.log('');
+        this.log(`  ${dim('After adding the config, restart Claude Desktop.')}`);
+        this.log(`  ${dim('Claude will automatically start RIFT when it needs trading tools.')}`);
+        this.log('');
+        await ask(`  ${dim('Press Enter to go back')} `);
+        // Parent run() loop redraws the main menu.
+    }
+    async settingsMenu() {
+        while (true) {
+            this.log('');
+            this.log(`  ${bold('Settings')}`);
+            this.log(`  ${dim('─'.repeat(30))}`);
+            this.log('');
+            this.log(`    ${cyan('1')}  ${bold('Auth')}     ${dim('wallet setup for live trading')}`);
+            this.log(`    ${cyan('2')}  ${bold('Config')}   ${dim('view/edit configuration')}`);
+            this.log(`    ${cyan('3')}  ${bold('Proxy')}    ${dim('network proxy setup')}`);
+            this.log(`    ${cyan('4')}  ${dim('Back')}`);
+            this.log('');
+            const choice = await ask(`  ${cyan('>')} `);
+            switch (choice) {
+                case '1':
+                    await this.dispatch('auth', ['setup']);
+                    break;
+                case '2':
+                    await this.dispatch('config', ['list']);
+                    break;
+                case '3':
+                    this.log(`\n  ${dim('Run:')} ${cyan('rift setup proxy')}\n`);
+                    break;
+                case '4':
+                case '0':
+                case 'q':
+                    return;
+                default:
+                    if (choice) {
+                        this.log(`\n  ${dim('Unknown option. Try 1-4.')}\n`);
+                    }
+            }
+        }
+    }
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,7 @@
+import { GatedCommand } from '../lib/base-command.js';
+export default class Init extends GatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {};
+    run(): Promise<void>;
+}