@nexstone/rift-cli 0.1.1

package/dist/commands/portfolio/create.js

@@ -0,0 +1,195 @@
+import { GatedCommand } from '../../lib/base-command.js';
+import { createInterface } from 'node:readline';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { getDataDir } from '../../lib/python-bridge.js';
+import { green, cyan, bold, dim, } from '../../lib/tui.js';
+function ask(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise(resolve => {
+        rl.question(question, answer => { rl.close(); resolve(answer.trim()); });
+    });
+}
+export default class PortfolioCreate extends GatedCommand {
+    static description = 'Interactive wizard to build a portfolio configuration';
+    static examples = [
+        '$ rift portfolio create',
+    ];
+    // Strategies discovered dynamically — users create their own. Default
+    // shows only OSS-shipped strategies; user's workbench customs are added
+    // at runtime by the picker.
+    availableStrategies = [
+        { name: 'trend_follow', grade: 'C', desc: 'Bidirectional EMA-crossover trend follower (OSS demo strategy)' },
+    ];
+    async run() {
+        this.log('');
+        this.log(`  ${bold('Portfolio Builder')}`);
+        this.log(`  ${dim('─'.repeat(50))}`);
+        this.log('');
+        const portfolioName = await ask(`  ${cyan('Portfolio name')} ${dim('(e.g. nexstone_alpha)')}: `) || 'my_portfolio';
+        const strategies = [];
+        let totalAlloc = 0;
+        // Add strategies
+        let addMore = true;
+        while (addMore) {
+            this.log('');
+            this.log(`  ${bold('Add a strategy')} ${dim(`(${(100 - totalAlloc * 100).toFixed(0)}% remaining)`)}`);
+            this.log('');
+            for (let i = 0; i < this.availableStrategies.length; i++) {
+                const s = this.availableStrategies[i];
+                const gc = s.grade === 'A' ? green : cyan;
+                this.log(`    ${cyan(String(i + 1))}  ${s.name.padEnd(22)} ${gc(s.grade)}  ${dim(s.desc)}`);
+            }
+            this.log(`    ${cyan(String(this.availableStrategies.length + 1))}  ${dim('Enter custom name')}`);
+            this.log('');
+            const choice = await ask(`  ${cyan('>')} `);
+            const idx = parseInt(choice) - 1;
+            let stratName;
+            if (idx >= 0 && idx < this.availableStrategies.length) {
+                stratName = this.availableStrategies[idx].name;
+            }
+            else {
+                stratName = await ask(`  ${cyan('Strategy name')}: `);
+                if (!stratName)
+                    continue;
+            }
+            const pair = (await ask(`  ${cyan('Pair')} ${dim('(BTC)')}: `)) || 'BTC';
+            const remainPct = Math.round((1 - totalAlloc) * 100);
+            const allocStr = await ask(`  ${cyan('Max allocation %')} ${dim(`(${Math.min(40, remainPct)}%)`)}: `);
+            const allocPct = parseInt(allocStr) || Math.min(40, remainPct);
+            const alloc = allocPct / 100;
+            const schedStr = await ask(`  ${cyan('Schedule')} ${dim('(always / HH:MM-HH:MM UTC)')}: `) || 'always';
+            let schedule = 'always';
+            if (schedStr !== 'always' && schedStr.includes('-')) {
+                const [start, stop] = schedStr.split('-').map(s => s.trim());
+                schedule = { start: start + ' UTC', stop: stop + ' UTC' };
+            }
+            strategies.push({
+                name: stratName,
+                pair: pair.toUpperCase(),
+                max_allocation: alloc,
+                schedule,
+                enabled: true,
+            });
+            totalAlloc += alloc;
+            this.log(`  ${green('✔')} Added ${bold(stratName)} on ${pair} (${allocPct}%${schedStr !== 'always' ? ', ' + schedStr : ''})`);
+            if (totalAlloc >= 1.0) {
+                this.log(`  ${dim('100% allocated.')}`);
+                addMore = false;
+            }
+            else {
+                const more = await ask(`  ${cyan('Add another?')} ${dim('(yes/no)')}: `);
+                addMore = more.toLowerCase() === 'yes' || more.toLowerCase() === 'y';
+            }
+        }
+        if (strategies.length === 0) {
+            this.log(`\n  ${dim('No strategies added. Cancelled.')}\n`);
+            return;
+        }
+        // Risk limits
+        this.log('');
+        this.log(`  ${bold('Risk Limits')}`);
+        this.log('');
+        const maxDDStr = await ask(`  ${cyan('Max portfolio drawdown %')} ${dim('(15%)')}: `);
+        const maxDD = (parseInt(maxDDStr) || 15) / 100;
+        const maxNetStr = await ask(`  ${cyan('Max net exposure %')} ${dim('(100%)')}: `);
+        const maxNet = (parseInt(maxNetStr) || 100) / 100;
+        // Alerts
+        this.log('');
+        this.log(`  ${bold('Alerts')}`);
+        this.log('');
+        const webhookUrl = await ask(`  ${cyan('Slack webhook URL')} ${dim('(blank to skip)')}: `);
+        // Build YAML
+        const alertConfigs = [{ type: 'log', events: ['all'] }];
+        if (webhookUrl) {
+            alertConfigs.push({
+                type: 'webhook',
+                url: webhookUrl,
+                events: ['trade', 'stop_loss', 'health_drop', 'health_rotation', 'drawdown_warning', 'drawdown_kill', 'session_died'],
+            });
+        }
+        const config = {
+            name: portfolioName,
+            strategies: strategies.map(s => ({
+                name: s.name,
+                pair: s.pair,
+                enabled: s.enabled,
+                schedule: s.schedule,
+                max_allocation: s.max_allocation,
+            })),
+            risk: {
+                max_net_exposure: maxNet,
+                max_gross_exposure: 1.5,
+                max_per_asset: 0.8,
+                max_drawdown: maxDD,
+            },
+            rotation: {
+                enabled: true,
+                pause_grade: 'D',
+                stop_grade: 'F',
+                check_interval: 5,
+            },
+            alerts: alertConfigs,
+        };
+        // Write YAML
+        const yamlLines = [];
+        yamlLines.push(`# Portfolio: ${portfolioName}`);
+        yamlLines.push(`name: ${portfolioName}`);
+        yamlLines.push('');
+        yamlLines.push('strategies:');
+        for (const s of config.strategies) {
+            yamlLines.push(`  - name: ${s.name}`);
+            yamlLines.push(`    pair: ${s.pair}`);
+            yamlLines.push(`    enabled: ${s.enabled}`);
+            if (typeof s.schedule === 'object') {
+                yamlLines.push(`    schedule:`);
+                yamlLines.push(`      start: "${s.schedule.start}"`);
+                yamlLines.push(`      stop: "${s.schedule.stop}"`);
+            }
+            else {
+                yamlLines.push(`    schedule: ${s.schedule}`);
+            }
+            yamlLines.push(`    max_allocation: ${s.max_allocation}`);
+        }
+        yamlLines.push('');
+        yamlLines.push('risk:');
+        yamlLines.push(`  max_net_exposure: ${config.risk.max_net_exposure}`);
+        yamlLines.push(`  max_gross_exposure: ${config.risk.max_gross_exposure}`);
+        yamlLines.push(`  max_per_asset: ${config.risk.max_per_asset}`);
+        yamlLines.push(`  max_drawdown: ${config.risk.max_drawdown}`);
+        yamlLines.push('');
+        yamlLines.push('rotation:');
+        yamlLines.push(`  enabled: ${config.rotation.enabled}`);
+        yamlLines.push(`  pause_grade: ${config.rotation.pause_grade}`);
+        yamlLines.push(`  stop_grade: ${config.rotation.stop_grade}`);
+        yamlLines.push(`  check_interval: ${config.rotation.check_interval}`);
+        yamlLines.push('');
+        yamlLines.push('alerts:');
+        for (const a of config.alerts) {
+            yamlLines.push(`  - type: ${a.type}`);
+            if (a.url)
+                yamlLines.push(`    url: ${a.url}`);
+            yamlLines.push(`    events: [${a.events.join(', ')}]`);
+        }
+        const configDir = path.join(getDataDir(), 'algo');
+        fs.mkdirSync(configDir, { recursive: true });
+        const configPath = path.join(configDir, 'portfolio.yaml');
+        fs.writeFileSync(configPath, yamlLines.join('\n') + '\n');
+        this.log('');
+        this.log(`  ${green('✔')} Portfolio config saved: ${dim(configPath)}`);
+        this.log('');
+        this.log(`  ${bold('Summary')}`);
+        for (const s of strategies) {
+            const schedDesc = typeof s.schedule === 'object'
+                ? `${s.schedule.start.replace(' UTC', '')}-${s.schedule.stop.replace(' UTC', '')} UTC`
+                : s.schedule;
+            this.log(`    ${s.name.padEnd(20)} ${s.pair.padEnd(5)} ${(s.max_allocation * 100).toFixed(0)}%  ${dim(schedDesc)}`);
+        }
+        this.log(`    Max drawdown: ${(maxDD * 100).toFixed(0)}%  Net limit: ${(maxNet * 100).toFixed(0)}%`);
+        if (webhookUrl)
+            this.log(`    Alerts: Slack webhook configured`);
+        this.log('');
+        this.log(`  ${dim(`Run ${cyan('rift portfolio start')} to begin trading.`)}`);
+        this.log('');
+    }
+}

package/dist/commands/portfolio/start.d.ts

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

package/dist/commands/portfolio/start.js

@@ -0,0 +1,64 @@
+import { Flags } from '@oclif/core';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { GatedCommand } from '../../lib/base-command.js';
+import { spawnDaemon, getDataDir } from '../../lib/python-bridge.js';
+import { loadCredentials, hasFullSetup, getAccountAddress } from '../../lib/credentials.js';
+import { red, cyan, dim, greenBg, } from '../../lib/tui.js';
+export default class PortfolioStart extends GatedCommand {
+    static description = 'Start the portfolio supervisor to manage multiple live strategies';
+    static examples = [
+        '$ rift portfolio start',
+        '$ rift portfolio start --config ~/my-portfolio.yaml',
+    ];
+    static flags = {
+        config: Flags.string({ description: 'Path to portfolio.yaml', default: '' }),
+    };
+    async run() {
+        const { flags } = await this.parse(PortfolioStart);
+        if (!hasFullSetup()) {
+            this.log(`\n  ${red('✘')} Portfolio requires account setup. Run: ${cyan('rift auth setup')}\n`);
+            return;
+        }
+        const creds = loadCredentials();
+        if (!creds) {
+            this.log(`\n  ${red('✘')} No credentials found.\n`);
+            return;
+        }
+        // Check if supervisor already running
+        const pidFile = path.join(getDataDir(), 'algo', 'supervisor.pid');
+        if (fs.existsSync(pidFile)) {
+            try {
+                const pid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim());
+                process.kill(pid, 0);
+                this.log(`\n  ${greenBg(' ● PORTFOLIO ')} Supervisor already running ${dim(`(PID ${pid})`)}\n`);
+                this.log(`  ${dim(`Run ${cyan('rift portfolio status')} to view or ${cyan('rift portfolio stop')} to end.`)}\n`);
+                return;
+            }
+            catch {
+                fs.unlinkSync(pidFile);
+            }
+        }
+        // Check portfolio config exists
+        const configPath = flags.config || path.join(getDataDir(), 'algo', 'portfolio.yaml');
+        if (!fs.existsSync(configPath)) {
+            this.log('');
+            this.log(`  ${red('✘')} No portfolio config found at: ${dim(configPath)}`);
+            this.log(`  ${dim(`Run ${cyan('rift portfolio create')} to build one.`)}`);
+            this.log('');
+            return;
+        }
+        // Spawn supervisor daemon
+        const { pid } = spawnDaemon('portfolio-start', [
+            '--config', configPath,
+            '--account', getAccountAddress(creds),
+        ], {
+            HYPERLIQUID_PRIVATE_KEY: creds.private_key,
+        });
+        this.log('');
+        this.log(`  ${greenBg(' ● PORTFOLIO ')} Supervisor started ${dim(`(PID ${pid})`)}`);
+        this.log(`  ${dim('Managing strategies in background.')}`);
+        this.log(`  ${dim(`Run ${cyan('rift portfolio status')} to monitor.`)}`);
+        this.log('');
+    }
+}

package/dist/commands/portfolio/status.d.ts

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

package/dist/commands/portfolio/status.js

@@ -0,0 +1,128 @@
+import { GatedCommand } from '../../lib/base-command.js';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { getDataDir } from '../../lib/python-bridge.js';
+import { green, red, yellow, cyan, bold, dim, greenBg, padEndVis, colorPnl, bar, gradeColor, boldBoxTop, boldBoxBottom, boldBoxDivider, boldBoxRow, } from '../../lib/tui.js';
+export default class PortfolioStatus extends GatedCommand {
+    static description = 'Show portfolio supervisor status and all managed strategies';
+    static examples = [
+        '$ rift portfolio status',
+    ];
+    async run() {
+        const stateFile = path.join(getDataDir(), 'algo', 'supervisor.json');
+        if (!fs.existsSync(stateFile)) {
+            this.log(`\n  ${dim('No portfolio supervisor running.')}`);
+            this.log(`  ${dim(`Run ${cyan('rift portfolio start')} to begin.`)}\n`);
+            return;
+        }
+        let state;
+        try {
+            state = JSON.parse(fs.readFileSync(stateFile, 'utf-8'));
+        }
+        catch {
+            this.log(`\n  ${red('✘')} Could not read supervisor state.\n`);
+            return;
+        }
+        // Verify supervisor is alive
+        const pidFile = path.join(getDataDir(), 'algo', 'supervisor.pid');
+        let alive = false;
+        if (fs.existsSync(pidFile)) {
+            try {
+                const pid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim());
+                process.kill(pid, 0);
+                alive = true;
+            }
+            catch { }
+        }
+        const portfolio = state.portfolio || {};
+        const strategies = state.strategies || [];
+        const iw = 60;
+        const row = boldBoxRow(iw);
+        this.log('');
+        this.log(boldBoxTop(iw));
+        const statusBadge = alive ? greenBg(' ● PORTFOLIO ') : dim(' ○ STOPPED ');
+        const name = state.name || 'portfolio';
+        const started = state.started_at || '';
+        this.log(row(`  ${statusBadge}  ${bold(name)}  ${dim(started)}`));
+        this.log(boldBoxDivider(iw));
+        // Portfolio-level metrics
+        const equity = portfolio.total_equity || 0;
+        const dd = (portfolio.drawdown_from_peak || 0) * 100;
+        const netExp = (portfolio.net_exposure || 0) * 100;
+        const grossExp = (portfolio.gross_exposure || 0) * 100;
+        this.log(row(''));
+        this.log(row(`  ${dim('EQUITY')}  ${bold('$' + equity.toLocaleString())}  ${dim('DD')} ${dd > 5 ? red(dd.toFixed(1) + '%') : dim(dd.toFixed(1) + '%')}`));
+        this.log(row(''));
+        // Risk gauges
+        this.log(row(`  ${dim('RISK')}`));
+        this.log(row(`  Net exposure    ${bar(Math.abs(netExp), 100, 20)}  ${padEndVis(netExp.toFixed(0) + '%', 6)} / 100%`));
+        this.log(row(`  Gross exposure  ${bar(grossExp, 150, 20)}  ${padEndVis(grossExp.toFixed(0) + '%', 6)} / 150%`));
+        // Per-asset
+        const perAsset = portfolio.per_asset || {};
+        for (const [asset, exp] of Object.entries(perAsset)) {
+            const expPct = (exp * 100);
+            this.log(row(`  ${asset.padEnd(16)} ${bar(Math.abs(expPct), 80, 20)}  ${padEndVis(expPct.toFixed(0) + '%', 6)} / 80%`));
+        }
+        this.log(row(''));
+        this.log(boldBoxDivider(iw));
+        // Strategies
+        this.log(row(`  ${dim('STRATEGIES')}`));
+        this.log(row(''));
+        for (const strat of strategies) {
+            const statusIcon = strat.status === 'running' ? green('●')
+                : strat.status === 'paused' ? yellow('●')
+                    : strat.status === 'scheduled_off' ? dim('○')
+                        : red('●');
+            const name = (strat.name || '').padEnd(18);
+            const pair = (strat.pair || '').padEnd(4);
+            const grade = strat.health_grade ? gradeColor(strat.health_grade) : dim('-');
+            const alloc = ((strat.allocation || 0) * 100).toFixed(0) + '%';
+            if (strat.status === 'running' && strat.position) {
+                const pos = strat.position;
+                const sideStr = pos.side === 'long' ? green('LONG') : red('SHORT');
+                this.log(row(`  ${statusIcon} ${dim(name)} ${pair} ${sideStr}  ${colorPnl(strat.pnl_pct || 0, '%')}  ${grade}  ${dim(alloc)}`));
+            }
+            else if (strat.status === 'running') {
+                this.log(row(`  ${statusIcon} ${dim(name)} ${pair} ${dim('FLAT')}  ${colorPnl(strat.pnl_pct || 0, '%')}  ${grade}  ${dim(alloc)}`));
+            }
+            else if (strat.status === 'scheduled_off') {
+                const sched = typeof strat.schedule === 'object'
+                    ? `${strat.schedule.start}-${strat.schedule.stop}`
+                    : String(strat.schedule || '');
+                this.log(row(`  ${statusIcon} ${dim(name)} ${pair} ${dim('OFF')}  ${dim(sched)}`));
+            }
+            else {
+                this.log(row(`  ${statusIcon} ${dim(name)} ${pair} ${dim(strat.status || 'stopped')}`));
+            }
+        }
+        this.log(row(''));
+        // Recent alerts
+        const alertsFile = path.join(getDataDir(), 'algo', 'alerts.log');
+        if (fs.existsSync(alertsFile)) {
+            try {
+                const lines = fs.readFileSync(alertsFile, 'utf-8').trim().split('\n').filter(l => l.trim());
+                const recent = lines.slice(-5);
+                if (recent.length > 0) {
+                    this.log(boldBoxDivider(iw));
+                    this.log(row(`  ${dim('RECENT ALERTS')}`));
+                    this.log(row(''));
+                    for (const line of recent) {
+                        try {
+                            const alert = JSON.parse(line);
+                            const eventColor = alert.event === 'trade' ? cyan
+                                : alert.event.includes('health') ? yellow
+                                    : alert.event.includes('drawdown') ? red
+                                        : dim;
+                            this.log(row(`  ${dim(alert.time)}  ${eventColor(alert.event.padEnd(16))} ${dim(alert.message?.slice(0, 30) || '')}`));
+                        }
+                        catch { }
+                    }
+                    this.log(row(''));
+                }
+            }
+            catch { }
+        }
+        this.log(boldBoxBottom(iw));
+        this.log('');
+    }
+}

package/dist/commands/portfolio/stop.d.ts

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

package/dist/commands/portfolio/stop.js

@@ -0,0 +1,81 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { GatedCommand } from '../../lib/base-command.js';
+import { getDataDir } from '../../lib/python-bridge.js';
+import { green, red, bold, dim, } from '../../lib/tui.js';
+export default class PortfolioStop extends GatedCommand {
+    static description = 'Stop the portfolio supervisor and all managed strategies';
+    static examples = [
+        '$ rift portfolio stop',
+    ];
+    async run() {
+        const pidFile = path.join(getDataDir(), 'algo', 'supervisor.pid');
+        if (!fs.existsSync(pidFile)) {
+            this.log(`\n  ${dim('No portfolio supervisor running.')}\n`);
+            return;
+        }
+        let pid;
+        try {
+            pid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim());
+            process.kill(pid, 0);
+        }
+        catch {
+            this.log(`\n  ${dim('Supervisor not running (stale PID).')}\n`);
+            try {
+                fs.unlinkSync(pidFile);
+            }
+            catch { }
+            return;
+        }
+        this.log(`\n  ${dim('Stopping portfolio supervisor')} ${dim(`(PID ${pid})...`)}`);
+        this.log(`  ${dim('Closing all positions and saving session logs...')}`);
+        // Send SIGTERM
+        try {
+            process.kill(pid, 'SIGTERM');
+        }
+        catch {
+            this.log(`  ${dim('Process already exited.')}`);
+            return;
+        }
+        // Wait for shutdown (up to 45s — needs time to close all positions)
+        for (let i = 0; i < 90; i++) {
+            try {
+                process.kill(pid, 0);
+                await new Promise(r => setTimeout(r, 500));
+            }
+            catch {
+                break;
+            }
+        }
+        // Show final state
+        const stateFile = path.join(getDataDir(), 'algo', 'supervisor.json');
+        if (fs.existsSync(stateFile)) {
+            try {
+                const state = JSON.parse(fs.readFileSync(stateFile, 'utf-8'));
+                const portfolio = state.portfolio || {};
+                const strategies = state.strategies || [];
+                this.log('');
+                this.log(`  ${green('✔')} Portfolio supervisor stopped.`);
+                this.log('');
+                this.log(`  ${bold('Final State')}`);
+                this.log(`  Equity: ${bold('$' + (portfolio.total_equity || 0).toLocaleString())}`);
+                this.log(`  Strategies managed: ${strategies.length}`);
+                for (const s of strategies) {
+                    const pnl = s.pnl_pct || 0;
+                    const pnlStr = pnl >= 0 ? green(`+${pnl.toFixed(2)}%`) : red(`${pnl.toFixed(2)}%`);
+                    this.log(`    ${dim(s.name)} ${dim(s.pair)} — ${pnlStr} (${s.num_trades || 0} trades)`);
+                }
+            }
+            catch { }
+        }
+        else {
+            this.log(`\n  ${green('✔')} Portfolio supervisor stopped.\n`);
+        }
+        // Clean up
+        try {
+            fs.unlinkSync(pidFile);
+        }
+        catch { }
+        this.log('');
+    }
+}

package/dist/commands/portfolio-backtest.d.ts

@@ -0,0 +1,13 @@
+import { GatedCommand } from '../lib/base-command.js';
+export default class PortfolioBacktest extends GatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        config: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        'strategies-dir': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/portfolio-backtest.js

@@ -0,0 +1,37 @@
+import { Args, Flags } from '@oclif/core';
+import * as path from 'node:path';
+import { GatedCommand } from '../lib/base-command.js';
+import { passthroughToEngine } from '../lib/engine-passthrough.js';
+export default class PortfolioBacktest extends GatedCommand {
+    static description = 'Run a multi-strategy portfolio backtest from a portfolio.yaml';
+    static examples = [
+        '$ rift portfolio-backtest portfolio.yaml',
+        '$ rift portfolio-backtest config.yaml --strategies-dir ./strategies',
+    ];
+    static args = {
+        config: Args.string({ description: 'Path to portfolio.yaml', required: true }),
+    };
+    static flags = {
+        'strategies-dir': Flags.string({ description: 'Directory with strategy .py files', default: '' }),
+        json: Flags.boolean({ description: 'Emit raw JSON only', default: false }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PortfolioBacktest);
+        // The engine subprocess is spawned with cwd=engine/, so relative paths
+        // in args would resolve from there instead of the user's terminal.
+        // Anchor to the user's cwd before handing the path to Python.
+        const configPath = path.resolve(args.config);
+        const engineArgs = [configPath];
+        if (flags['strategies-dir']) {
+            engineArgs.push('--strategies-dir', path.resolve(flags['strategies-dir']));
+        }
+        await passthroughToEngine({
+            command: 'portfolio-backtest',
+            args: engineArgs,
+            log: (m) => this.log(m),
+            error: (m) => this.error(m),
+            exit: (c) => this.exit(c),
+            jsonOnly: flags.json,
+        });
+    }
+}

package/dist/commands/portfolio-matrix.d.ts

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

package/dist/commands/portfolio-matrix.js

@@ -0,0 +1,30 @@
+import { Flags } from '@oclif/core';
+import { GatedCommand } from '../lib/base-command.js';
+import { passthroughToEngine } from '../lib/engine-passthrough.js';
+export default class PortfolioMatrix extends GatedCommand {
+    static description = 'Strategy × pair P&L matrix, correlation matrix, and regime analysis';
+    static examples = [
+        '$ rift portfolio-matrix',
+        '$ rift portfolio-matrix --pairs BTC,ETH,SOL --strategies trend_follow,vol_breakout',
+    ];
+    static flags = {
+        pairs: Flags.string({ description: 'Comma-separated coins', default: 'BTC,ETH,SOL' }),
+        strategies: Flags.string({ description: 'Comma-separated strategies (auto-discovers if empty)', default: '' }),
+        equity: Flags.string({ description: 'Starting equity per strategy', default: '10000' }),
+        json: Flags.boolean({ description: 'Emit raw JSON only', default: false }),
+    };
+    async run() {
+        const { flags } = await this.parse(PortfolioMatrix);
+        const args = ['--pairs', flags.pairs, '--equity', flags.equity];
+        if (flags.strategies)
+            args.push('--strategies', flags.strategies);
+        await passthroughToEngine({
+            command: 'portfolio-matrix',
+            args,
+            log: (m) => this.log(m),
+            error: (m) => this.error(m),
+            exit: (c) => this.exit(c),
+            jsonOnly: flags.json,
+        });
+    }
+}

package/dist/commands/quick-test.d.ts

@@ -0,0 +1,17 @@
+import { GatedCommand } from '../lib/base-command.js';
+export default class QuickTest extends GatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        strategy: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        pair: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        tf: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        equity: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        leverage: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        change: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/quick-test.js

@@ -0,0 +1,45 @@
+import { Args, Flags } from '@oclif/core';
+import { GatedCommand } from '../lib/base-command.js';
+import { passthroughToEngine } from '../lib/engine-passthrough.js';
+export default class QuickTest extends GatedCommand {
+    static description = 'Fast backtest with delta comparison to the last run — the core iteration loop while tuning a strategy.';
+    static examples = [
+        '$ rift quick-test trend_follow --pair BTC',
+        '$ rift quick-test trend_follow --pair ETH --tf 4h --change "tightened stop to 1.5%"',
+    ];
+    static args = {
+        strategy: Args.string({ description: 'Strategy name', required: true }),
+    };
+    static flags = {
+        pair: Flags.string({ description: 'Trading pair', default: 'BTC' }),
+        tf: Flags.string({ description: 'Timeframe (auto from config if empty)', default: '' }),
+        equity: Flags.string({ description: 'Starting equity', default: '10000' }),
+        leverage: Flags.string({ description: 'Leverage multiplier', default: '1' }),
+        change: Flags.string({
+            description: 'Description of what changed (recorded in the delta history)',
+            default: '',
+        }),
+        json: Flags.boolean({ description: 'Emit raw JSON only', default: false }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(QuickTest);
+        const engineArgs = [
+            args.strategy,
+            '--pair', flags.pair,
+            '--equity', flags.equity,
+            '--leverage', flags.leverage,
+        ];
+        if (flags.tf)
+            engineArgs.push('--tf', flags.tf);
+        if (flags.change)
+            engineArgs.push('--change', flags.change);
+        await passthroughToEngine({
+            command: 'quick-test',
+            args: engineArgs,
+            log: (m) => this.log(m),
+            error: (m) => this.error(m),
+            exit: (c) => this.exit(c),
+            jsonOnly: flags.json,
+        });
+    }
+}