@trading-boy/cli 1.2.20 → 1.4.0

package/dist/cli.js

@@ -40,6 +40,8 @@ import { registerStrategyCommand } from './commands/strategy-cmd.js';
 import { registerReplayCommand } from './commands/replay-cmd.js';
 import { registerBenchmarkCommand } from './commands/benchmark-cmd.js';
 import { registerSuggestionsCommand } from './commands/suggestions-cmd.js';
+import { registerCronCommand } from './commands/cron-cmd.js';
+import { registerAgentCommand } from './commands/agent-cmd.js';
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { dirname, resolve } from 'node:path';
@@ -90,6 +92,10 @@ export function createCli() {
     registerReplayCommand(program);
     registerBenchmarkCommand(program);
     registerSuggestionsCommand(program);
+    // Scheduling
+    registerCronCommand(program);
+    // Agents
+    registerAgentCommand(program);
     // System management
     registerConfigCommand(program);
     registerInfraCommand(program);
@@ -100,6 +106,8 @@ export function createCli() {
         'Trading Journal': ['journal', 'decisions', 'stats', 'trader', 'behavioral', 'audit'],
         'Edge & Safety': ['edge', 'edge-guard', 'coaching', 'thesis'],
         'Strategy & Benchmarking': ['strategy', 'replay', 'benchmark', 'suggestions'],
+        'Scheduling': ['cron'],
+        'Agents': ['agent'],
         'Account': ['login', 'logout', 'whoami', 'billing', 'subscribe'],
         'System': ['config', 'infra'],
     };

package/dist/commands/agent-cmd.d.ts

@@ -0,0 +1,9 @@
+import { Command } from 'commander';
+/**
+ * Parse a human-readable interval string (e.g. "1m", "5m", "15m", "1h") to milliseconds.
+ * Supported units: s (seconds), m (minutes), h (hours).
+ * Returns null if the format is invalid.
+ */
+export declare function parseHumanInterval(value: string): number | null;
+export declare function registerAgentCommand(program: Command): void;
+//# sourceMappingURL=agent-cmd.d.ts.map

package/dist/commands/agent-cmd.js

@@ -0,0 +1,560 @@
+// ─── Agent CLI Commands ───
+//
+// tb agent create  — Create a new agent
+// tb agent list    — List agents
+// tb agent show    — Show agent details + live state
+// tb agent pause   — Pause an agent
+// tb agent resume  — Resume a paused agent
+// tb agent delete  — Delete an agent
+// tb agent update  — Update agent config
+import { readFileSync, existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { Option } from 'commander';
+import chalk from 'chalk';
+import { createLogger } from '@trading-boy/core';
+import { isRemoteMode, apiRequest, ApiError } from '../api-client.js';
+import { padRight } from '../utils.js';
+const logger = createLogger('cli-agent');
+// ─── Error Handler ───
+function handleApiError(error, context) {
+    if (error instanceof ApiError) {
+        switch (error.status) {
+            case 401:
+                console.error(chalk.red('Error: API key invalid or expired. Run `trading-boy login` to re-authenticate.'));
+                break;
+            case 403:
+                console.error(chalk.red(`Error: ${error.message}`));
+                break;
+            case 404:
+                console.error(chalk.red(`Error: Not found — ${error.message}`));
+                break;
+            case 429:
+                console.error(chalk.red(`Error: Limit reached — ${error.message}`));
+                break;
+            default:
+                console.error(chalk.red(`Error: ${error.message}`));
+        }
+    }
+    else {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.error({ error: message }, context);
+        console.error(chalk.red(`Error: ${message}`));
+    }
+    process.exitCode = error instanceof ApiError ? 2 : 1;
+}
+async function ensureRemote() {
+    if (!(await isRemoteMode())) {
+        console.error(chalk.yellow('Agent commands require a remote API connection.'));
+        console.error(chalk.dim('  Run: trading-boy login'));
+        process.exitCode = 1;
+        return false;
+    }
+    return true;
+}
+// ─── Formatters ───
+function formatShortDate(isoString) {
+    if (!isoString)
+        return chalk.dim('—');
+    try {
+        return new Date(isoString).toISOString().slice(0, 19).replace('T', ' ');
+    }
+    catch {
+        return isoString;
+    }
+}
+function formatStatus(status) {
+    switch (status) {
+        case 'active': return chalk.green('active');
+        case 'paused': return chalk.yellow('paused');
+        case 'deleted': return chalk.red('deleted');
+        default: return status;
+    }
+}
+function formatAutonomy(level) {
+    switch (level) {
+        case 'OBSERVE_ONLY': return chalk.dim('observe');
+        case 'SUGGEST': return chalk.blue('suggest');
+        case 'AUTO_WITH_APPROVAL': return chalk.yellow('auto+approve');
+        case 'FULLY_AUTONOMOUS': return chalk.red('autonomous');
+        default: return level;
+    }
+}
+function formatInterval(ms) {
+    if (ms < 60000)
+        return `${(ms / 1000).toFixed(0)}s`;
+    if (ms < 3600000)
+        return `${(ms / 60000).toFixed(0)}m`;
+    return `${(ms / 3600000).toFixed(1)}h`;
+}
+/**
+ * Parse a human-readable interval string (e.g. "1m", "5m", "15m", "1h") to milliseconds.
+ * Supported units: s (seconds), m (minutes), h (hours).
+ * Returns null if the format is invalid.
+ */
+export function parseHumanInterval(value) {
+    const match = value.trim().match(/^(\d+(?:\.\d+)?)\s*(s|m|h)$/i);
+    if (!match)
+        return null;
+    const num = parseFloat(match[1]);
+    const unit = match[2].toLowerCase();
+    switch (unit) {
+        case 's': return num * 1000;
+        case 'm': return num * 60_000;
+        case 'h': return num * 3_600_000;
+        default: return null;
+    }
+}
+const MIN_SCAN_INTERVAL_MS = 60_000;
+// ─── Command Registration ───
+export function registerAgentCommand(program) {
+    const agent = program
+        .command('agent')
+        .description('Manage autonomous trading agents');
+    // ── create ──────────────────────────────────────────────────────────────────
+    agent
+        .command('create')
+        .description('Create a new agent')
+        .requiredOption('--trader-id <traderId>', 'Trader ID')
+        .requiredOption('--strategy-id <strategyId>', 'Strategy ID')
+        .option('--name <name>', 'Agent name')
+        .option('--autonomy <level>', 'Autonomy level: OBSERVE_ONLY, SUGGEST, AUTO_WITH_APPROVAL, FULLY_AUTONOMOUS', 'OBSERVE_ONLY')
+        .option('--scan-interval <ms>', 'Scan interval in ms (min 60000)', '300000')
+        .option('--scan-interval-human <duration>', 'Scan interval in human-readable format (e.g. 1m, 5m, 15m, 30m, 1h)')
+        .option('--watchlist <symbols>', 'Comma-separated token symbols')
+        .option('--max-daily-trades <n>', 'Max daily trades', '10')
+        .option('--max-daily-loss <usd>', 'Max daily loss in USD', '500')
+        .option('--max-position-size <pct>', 'Max position size as decimal (0.10 = 10%)', '0.10')
+        .option('--min-confidence <n>', 'Min confidence threshold (0-1)', '0.60')
+        .option('--scan-model <model>', 'LLM model for market scanning')
+        .option('--analyze-model <model>', 'LLM model for deep analysis')
+        .option('--decide-model <model>', 'LLM model for trade decisions')
+        .addOption(new Option('--asset-class <class>', 'Asset class for this agent').choices(['crypto', 'commodities', 'mixed']).default('crypto'))
+        .option('--soul-override <text>', 'Custom soul/personality for this agent')
+        .option('--purpose-override <text>', 'Custom purpose/mission for this agent')
+        .option('--soul-file <path>', 'Load soul from a file')
+        .option('--purpose-file <path>', 'Load purpose from a file')
+        .addOption(new Option('--format <format>', 'Output format').choices(['text', 'json']).default('text'))
+        .action(async (options) => {
+        if (!(await ensureRemote()))
+            return;
+        const body = {
+            traderId: options.traderId,
+            strategyId: options.strategyId,
+        };
+        if (options.name)
+            body.name = options.name;
+        if (options.autonomy)
+            body.autonomyLevel = options.autonomy;
+        // Resolve scan interval: --scan-interval-human takes precedence
+        if (options.scanIntervalHuman) {
+            const ms = parseHumanInterval(options.scanIntervalHuman);
+            if (ms === null) {
+                console.error(chalk.red(`Error: Invalid duration "${options.scanIntervalHuman}". Use format like 1m, 5m, 15m, 30m, 1h.`));
+                process.exitCode = 1;
+                return;
+            }
+            if (ms < MIN_SCAN_INTERVAL_MS) {
+                console.error(chalk.red(`Error: Scan interval must be at least 1m (60000ms). Got ${formatInterval(ms)}.`));
+                process.exitCode = 1;
+                return;
+            }
+            body.scanIntervalMs = ms;
+        }
+        else if (options.scanInterval) {
+            body.scanIntervalMs = parseInt(options.scanInterval, 10);
+        }
+        if (options.watchlist)
+            body.watchlist = options.watchlist.split(',').map((s) => s.trim().toUpperCase());
+        if (options.maxDailyTrades)
+            body.maxDailyTrades = parseInt(options.maxDailyTrades, 10);
+        if (options.maxDailyLoss)
+            body.maxDailyLossUsd = parseFloat(options.maxDailyLoss);
+        if (options.maxPositionSize)
+            body.maxPositionSizePct = parseFloat(options.maxPositionSize);
+        if (options.minConfidence)
+            body.minConfidence = parseFloat(options.minConfidence);
+        if (options.scanModel)
+            body.scanModel = options.scanModel;
+        if (options.analyzeModel)
+            body.analyzeModel = options.analyzeModel;
+        if (options.decideModel)
+            body.decideModel = options.decideModel;
+        if (options.assetClass)
+            body.assetClass = options.assetClass;
+        // Soul override — file takes precedence over inline text
+        if (options.soulFile) {
+            const path = resolve(options.soulFile);
+            if (!existsSync(path)) {
+                console.error(chalk.red(`Error: Soul file not found: ${path}`));
+                process.exitCode = 1;
+                return;
+            }
+            body.soulOverride = readFileSync(path, 'utf-8');
+        }
+        else if (options.soulOverride) {
+            body.soulOverride = options.soulOverride;
+        }
+        // Purpose override — file takes precedence over inline text
+        if (options.purposeFile) {
+            const path = resolve(options.purposeFile);
+            if (!existsSync(path)) {
+                console.error(chalk.red(`Error: Purpose file not found: ${path}`));
+                process.exitCode = 1;
+                return;
+            }
+            body.purposeOverride = readFileSync(path, 'utf-8');
+        }
+        else if (options.purposeOverride) {
+            body.purposeOverride = options.purposeOverride;
+        }
+        try {
+            const result = await apiRequest('/api/v1/agents', {
+                method: 'POST',
+                body,
+            });
+            if (options.format === 'json') {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else {
+                console.log('');
+                console.log(chalk.green('  Agent created'));
+                console.log(`  ${chalk.gray('ID:')}        ${result.id}`);
+                console.log(`  ${chalk.gray('Name:')}      ${result.name}`);
+                console.log(`  ${chalk.gray('Trader:')}    ${result.traderId}`);
+                console.log(`  ${chalk.gray('Strategy:')}  ${result.strategyId}`);
+                console.log(`  ${chalk.gray('Autonomy:')}  ${formatAutonomy(result.autonomyLevel)}`);
+                console.log(`  ${chalk.gray('Interval:')}  ${formatInterval(result.scanIntervalMs)}`);
+                console.log(`  ${chalk.gray('Next scan:')} ${formatShortDate(result.nextScanAt)}`);
+                console.log('');
+            }
+        }
+        catch (error) {
+            handleApiError(error, 'Agent create failed');
+        }
+    });
+    // ── list ────────────────────────────────────────────────────────────────────
+    agent
+        .command('list')
+        .description('List agents')
+        .option('--status <status>', 'Filter by status: active, paused')
+        .addOption(new Option('--format <format>', 'Output format').choices(['text', 'json']).default('text'))
+        .action(async (options) => {
+        if (!(await ensureRemote()))
+            return;
+        try {
+            const query = options.status ? `?status=${options.status}` : '';
+            const result = await apiRequest(`/api/v1/agents${query}`);
+            if (options.format === 'json') {
+                console.log(JSON.stringify(result, null, 2));
+                return;
+            }
+            if (result.agents.length === 0) {
+                console.log(chalk.dim('  No agents found'));
+                return;
+            }
+            console.log('');
+            console.log('  ' +
+                padRight('Name', 24) +
+                padRight('Autonomy', 14) +
+                padRight('Interval', 10) +
+                padRight('Status', 10) +
+                padRight('Ticks', 7) +
+                padRight('Errors', 8) +
+                'Next Scan');
+            console.log(chalk.gray('  ' + '─'.repeat(100)));
+            for (const a of result.agents) {
+                console.log('  ' +
+                    padRight(a.name.slice(0, 22), 24) +
+                    padRight(formatAutonomy(a.autonomyLevel), 14) +
+                    padRight(formatInterval(a.scanIntervalMs), 10) +
+                    padRight(formatStatus(a.status), 10) +
+                    padRight(String(a.tickCount), 7) +
+                    padRight(String(a.errorCount), 8) +
+                    formatShortDate(a.nextScanAt));
+            }
+            console.log('');
+            console.log(chalk.dim(`  ${result.count} agent(s)`));
+            console.log('');
+        }
+        catch (error) {
+            handleApiError(error, 'Agent list failed');
+        }
+    });
+    // ── show ────────────────────────────────────────────────────────────────────
+    agent
+        .command('show <agentId>')
+        .description('Show agent details and live state')
+        .addOption(new Option('--format <format>', 'Output format').choices(['text', 'json']).default('text'))
+        .action(async (agentId, options) => {
+        if (!(await ensureRemote()))
+            return;
+        try {
+            const result = await apiRequest(`/api/v1/agents/${encodeURIComponent(agentId)}`);
+            if (options.format === 'json') {
+                console.log(JSON.stringify(result, null, 2));
+                return;
+            }
+            const a = result.agent;
+            const live = result.live;
+            console.log('');
+            console.log(chalk.bold.cyan(`  Agent — ${a.name}`));
+            console.log(chalk.gray('  ' + '─'.repeat(50)));
+            console.log(`  ${chalk.gray('ID:')}              ${a.id}`);
+            console.log(`  ${chalk.gray('Status:')}          ${formatStatus(a.status)}`);
+            console.log(`  ${chalk.gray('Trader:')}          ${a.traderId}`);
+            console.log(`  ${chalk.gray('Strategy:')}        ${a.strategyId}`);
+            console.log(`  ${chalk.gray('Autonomy:')}        ${formatAutonomy(a.autonomyLevel)}`);
+            if (a.assetClass)
+                console.log(`  ${chalk.gray('Asset class:')}     ${a.assetClass}`);
+            if (a.scanModel)
+                console.log(`  ${chalk.gray('Scan model:')}      ${a.scanModel}`);
+            if (a.analyzeModel)
+                console.log(`  ${chalk.gray('Analyze model:')}   ${a.analyzeModel}`);
+            if (a.decideModel)
+                console.log(`  ${chalk.gray('Decide model:')}    ${a.decideModel}`);
+            console.log(`  ${chalk.gray('Scan interval:')}   ${formatInterval(a.scanIntervalMs)}`);
+            console.log(`  ${chalk.gray('Max daily trades:')} ${a.maxDailyTrades}`);
+            console.log(`  ${chalk.gray('Max daily loss:')}  $${a.maxDailyLossUsd}`);
+            console.log(`  ${chalk.gray('Max position:')}    ${(a.maxPositionSizePct * 100).toFixed(0)}%`);
+            console.log(`  ${chalk.gray('Min confidence:')}  ${(a.minConfidence * 100).toFixed(0)}%`);
+            console.log(`  ${chalk.gray('Watchlist:')}       ${a.watchlist.length > 0 ? a.watchlist.join(', ') : chalk.dim('(from strategy)')}`);
+            if (a.soulOverride) {
+                const soulPreview = a.soulOverride.length > 60 ? a.soulOverride.slice(0, 60) + '...' : a.soulOverride;
+                console.log(`  ${chalk.gray('Soul override:')}   ${chalk.white(soulPreview)}`);
+            }
+            if (a.purposeOverride) {
+                const purposePreview = a.purposeOverride.length > 60 ? a.purposeOverride.slice(0, 60) + '...' : a.purposeOverride;
+                console.log(`  ${chalk.gray('Purpose override:')} ${chalk.white(purposePreview)}`);
+            }
+            console.log(`  ${chalk.gray('Tick count:')}      ${a.tickCount}`);
+            console.log(`  ${chalk.gray('Error count:')}     ${a.errorCount}`);
+            if (a.lastError) {
+                console.log(`  ${chalk.gray('Last error:')}      ${chalk.red(a.lastError.slice(0, 60))}`);
+            }
+            console.log(`  ${chalk.gray('Last tick:')}       ${formatShortDate(a.lastTickAt)}`);
+            console.log(`  ${chalk.gray('Next scan:')}       ${formatShortDate(a.nextScanAt)}`);
+            console.log(`  ${chalk.gray('Created:')}         ${formatShortDate(a.createdAt)}`);
+            // Live state
+            if (live.state || live.admin) {
+                console.log('');
+                console.log(chalk.bold('  Live State'));
+                console.log(chalk.gray('  ' + '─'.repeat(50)));
+                if (live.admin) {
+                    console.log(`  ${chalk.gray('Paused:')}          ${live.admin.paused ? chalk.yellow('yes') : chalk.dim('no')}`);
+                    console.log(`  ${chalk.gray('Killed:')}          ${live.admin.killed ? chalk.red('yes') : chalk.dim('no')}`);
+                    console.log(`  ${chalk.gray('Override:')}        ${live.admin.override ?? chalk.dim('none')}`);
+                    if (live.admin.autonomyOverride) {
+                        console.log(`  ${chalk.gray('Autonomy override:')} ${formatAutonomy(live.admin.autonomyOverride)}`);
+                    }
+                }
+                if (live.state) {
+                    const currentState = live.state.state;
+                    if (currentState) {
+                        console.log(`  ${chalk.gray('Agent state:')}     ${chalk.cyan(String(currentState))}`);
+                    }
+                }
+            }
+            console.log('');
+        }
+        catch (error) {
+            handleApiError(error, 'Agent show failed');
+        }
+    });
+    // ── pause ───────────────────────────────────────────────────────────────────
+    agent
+        .command('pause <agentId>')
+        .description('Pause an agent')
+        .action(async (agentId) => {
+        if (!(await ensureRemote()))
+            return;
+        try {
+            await apiRequest(`/api/v1/agents/${encodeURIComponent(agentId)}/pause`, {
+                method: 'POST',
+            });
+            console.log(chalk.green(`  Agent ${agentId} paused`));
+        }
+        catch (error) {
+            handleApiError(error, 'Agent pause failed');
+        }
+    });
+    // ── resume ──────────────────────────────────────────────────────────────────
+    agent
+        .command('resume <agentId>')
+        .description('Resume a paused agent')
+        .action(async (agentId) => {
+        if (!(await ensureRemote()))
+            return;
+        try {
+            await apiRequest(`/api/v1/agents/${encodeURIComponent(agentId)}/resume`, {
+                method: 'POST',
+            });
+            console.log(chalk.green(`  Agent ${agentId} resumed`));
+        }
+        catch (error) {
+            handleApiError(error, 'Agent resume failed');
+        }
+    });
+    // ── delete ──────────────────────────────────────────────────────────────────
+    agent
+        .command('delete <agentId>')
+        .description('Delete an agent')
+        .action(async (agentId) => {
+        if (!(await ensureRemote()))
+            return;
+        try {
+            await apiRequest(`/api/v1/agents/${encodeURIComponent(agentId)}`, {
+                method: 'DELETE',
+            });
+            console.log(chalk.green(`  Agent ${agentId} deleted`));
+        }
+        catch (error) {
+            handleApiError(error, 'Agent delete failed');
+        }
+    });
+    // ── exit ───────────────────────────────────────────────────────────────────
+    agent
+        .command('exit <agentId>')
+        .description('Exit/close an open position for an agent')
+        .requiredOption('--symbol <symbol>', 'Token symbol to exit (e.g. xyz:NATGAS)')
+        .option('--reason <text>', 'Reason for exit')
+        .addOption(new Option('--format <format>', 'Output format').choices(['text', 'json']).default('text'))
+        .action(async (agentId, options) => {
+        if (!(await ensureRemote()))
+            return;
+        try {
+            const body = {};
+            if (options.reason)
+                body.reason = options.reason;
+            const result = await apiRequest(`/api/v1/agents/${encodeURIComponent(agentId)}/positions/${encodeURIComponent(options.symbol)}/exit`, { method: 'POST', body });
+            if (options.format === 'json') {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else {
+                const pnlColor = result.pnl >= 0 ? chalk.green : chalk.red;
+                const pnlSign = result.pnl >= 0 ? '+' : '';
+                console.log('');
+                console.log(chalk.green('  Position closed'));
+                console.log(`  ${chalk.gray('Symbol:')}     ${result.symbol}`);
+                console.log(`  ${chalk.gray('Side:')}       ${result.side}`);
+                console.log(`  ${chalk.gray('Exit price:')} $${result.exitPrice.toLocaleString()}`);
+                console.log(`  ${chalk.gray('PnL:')}        ${pnlColor(`${pnlSign}$${result.pnl.toFixed(2)} (${pnlSign}${result.pnlPct.toFixed(2)}%)`)}`);
+                console.log(`  ${chalk.gray('Closed at:')}  ${formatShortDate(result.closedAt)}`);
+                if (options.reason) {
+                    console.log(`  ${chalk.gray('Reason:')}     ${options.reason}`);
+                }
+                console.log('');
+            }
+        }
+        catch (error) {
+            handleApiError(error, 'Position exit failed');
+        }
+    });
+    // ── update ──────────────────────────────────────────────────────────────────
+    agent
+        .command('update <agentId>')
+        .description('Update agent config')
+        .option('--name <name>', 'Agent name')
+        .option('--autonomy <level>', 'Autonomy level')
+        .option('--scan-interval <ms>', 'Scan interval in ms')
+        .option('--scan-interval-human <duration>', 'Scan interval in human-readable format (e.g. 1m, 5m, 15m, 30m, 1h)')
+        .option('--watchlist <symbols>', 'Comma-separated token symbols')
+        .option('--max-daily-trades <n>', 'Max daily trades')
+        .option('--max-daily-loss <usd>', 'Max daily loss in USD')
+        .option('--max-position-size <pct>', 'Max position size as decimal')
+        .option('--min-confidence <n>', 'Min confidence threshold')
+        .option('--scan-model <model>', 'LLM model for market scanning')
+        .option('--analyze-model <model>', 'LLM model for deep analysis')
+        .option('--decide-model <model>', 'LLM model for trade decisions')
+        .addOption(new Option('--asset-class <class>', 'Asset class for this agent').choices(['crypto', 'commodities', 'mixed']))
+        .option('--soul-override <text>', 'Custom soul/personality for this agent')
+        .option('--purpose-override <text>', 'Custom purpose/mission for this agent')
+        .option('--soul-file <path>', 'Load soul from a file')
+        .option('--purpose-file <path>', 'Load purpose from a file')
+        .action(async (agentId, options) => {
+        if (!(await ensureRemote()))
+            return;
+        const body = {};
+        if (options.name)
+            body.name = options.name;
+        if (options.autonomy)
+            body.autonomyLevel = options.autonomy;
+        // Resolve scan interval: --scan-interval-human takes precedence
+        if (options.scanIntervalHuman) {
+            const ms = parseHumanInterval(options.scanIntervalHuman);
+            if (ms === null) {
+                console.error(chalk.red(`Error: Invalid duration "${options.scanIntervalHuman}". Use format like 1m, 5m, 15m, 30m, 1h.`));
+                process.exitCode = 1;
+                return;
+            }
+            if (ms < MIN_SCAN_INTERVAL_MS) {
+                console.error(chalk.red(`Error: Scan interval must be at least 1m (60000ms). Got ${formatInterval(ms)}.`));
+                process.exitCode = 1;
+                return;
+            }
+            body.scanIntervalMs = ms;
+        }
+        else if (options.scanInterval) {
+            body.scanIntervalMs = parseInt(options.scanInterval, 10);
+        }
+        if (options.watchlist)
+            body.watchlist = options.watchlist.split(',').map((s) => s.trim().toUpperCase());
+        if (options.maxDailyTrades)
+            body.maxDailyTrades = parseInt(options.maxDailyTrades, 10);
+        if (options.maxDailyLoss)
+            body.maxDailyLossUsd = parseFloat(options.maxDailyLoss);
+        if (options.maxPositionSize)
+            body.maxPositionSizePct = parseFloat(options.maxPositionSize);
+        if (options.minConfidence)
+            body.minConfidence = parseFloat(options.minConfidence);
+        if (options.scanModel)
+            body.scanModel = options.scanModel;
+        if (options.analyzeModel)
+            body.analyzeModel = options.analyzeModel;
+        if (options.decideModel)
+            body.decideModel = options.decideModel;
+        if (options.assetClass)
+            body.assetClass = options.assetClass;
+        // Soul override — file takes precedence over inline text
+        if (options.soulFile) {
+            const path = resolve(options.soulFile);
+            if (!existsSync(path)) {
+                console.error(chalk.red(`Error: Soul file not found: ${path}`));
+                process.exitCode = 1;
+                return;
+            }
+            body.soulOverride = readFileSync(path, 'utf-8');
+        }
+        else if (options.soulOverride) {
+            body.soulOverride = options.soulOverride;
+        }
+        // Purpose override — file takes precedence over inline text
+        if (options.purposeFile) {
+            const path = resolve(options.purposeFile);
+            if (!existsSync(path)) {
+                console.error(chalk.red(`Error: Purpose file not found: ${path}`));
+                process.exitCode = 1;
+                return;
+            }
+            body.purposeOverride = readFileSync(path, 'utf-8');
+        }
+        else if (options.purposeOverride) {
+            body.purposeOverride = options.purposeOverride;
+        }
+        if (Object.keys(body).length === 0) {
+            console.error(chalk.yellow('  No updates specified. Use --name, --autonomy, --watchlist, etc.'));
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            await apiRequest(`/api/v1/agents/${encodeURIComponent(agentId)}`, {
+                method: 'PATCH',
+                body,
+            });
+            console.log(chalk.green(`  Agent ${agentId} updated`));
+        }
+        catch (error) {
+            handleApiError(error, 'Agent update failed');
+        }
+    });
+}
+//# sourceMappingURL=agent-cmd.js.map

package/dist/commands/config-cmd.js

@@ -323,8 +323,11 @@ export function registerConfigCommand(program) {
         .command('set-llm-key <apiKey>')
         .description('Store your LLM API key for thesis extraction + coaching (BYOK)')
         .addOption(new Option('-p, --provider <provider>', 'LLM provider (auto-detected from key prefix if omitted)').choices(['anthropic', 'openai', 'openrouter', 'ollama', 'gemini', 'custom']))
-        .option('-m, --model <model>', 'Model name')
+        .option('-m, --model <model>', 'Model name (default for all phases)')
         .option('--base-url <url>', 'Custom base URL (for openrouter/ollama/custom providers)')
+        .option('--scan-model <model>', 'Model for market scanning (e.g. claude-haiku-4-5)')
+        .option('--analyze-model <model>', 'Model for deep analysis (e.g. claude-sonnet-4-6)')
+        .option('--decide-model <model>', 'Model for trade decisions (e.g. claude-opus-4-6)')
         .action(async (apiKey, opts) => {
         try {
             const result = await apiRequest('/api/v1/llm-config', {
@@ -334,13 +337,25 @@ export function registerConfigCommand(program) {
                     ...(opts.provider ? { provider: opts.provider } : {}),
                     ...(opts.model ? { model: opts.model } : {}),
                     ...(opts.baseUrl ? { baseUrl: opts.baseUrl } : {}),
+                    ...(opts.scanModel ? { scanModel: opts.scanModel } : {}),
+                    ...(opts.analyzeModel ? { analyzeModel: opts.analyzeModel } : {}),
+                    ...(opts.decideModel ? { decideModel: opts.decideModel } : {}),
                 },
             });
             console.log('');
             console.log(chalk.green('  LLM API key saved successfully'));
-            console.log(`  ${chalk.gray('Provider:')} ${result.provider}`);
-            console.log(`  ${chalk.gray('Model:')}    ${result.model}`);
-            console.log(`  ${chalk.gray('Key:')}      ${apiKey.slice(0, 8)}${'*'.repeat(Math.max(0, apiKey.length - 8))}`);
+            console.log(`  ${chalk.gray('Provider:')}      ${result.provider}`);
+            console.log(`  ${chalk.gray('Model:')}         ${result.model}`);
+            if (result.scanModel) {
+                console.log(`  ${chalk.gray('Scan model:')}    ${result.scanModel}`);
+            }
+            if (result.analyzeModel) {
+                console.log(`  ${chalk.gray('Analyze model:')} ${result.analyzeModel}`);
+            }
+            if (result.decideModel) {
+                console.log(`  ${chalk.gray('Decide model:')}  ${result.decideModel}`);
+            }
+            console.log(`  ${chalk.gray('Key:')}           ${apiKey.slice(0, 8)}${'*'.repeat(Math.max(0, apiKey.length - 8))}`);
             console.log('');
             console.log(chalk.dim('  Your key is encrypted at rest. Thesis extraction and coaching are now enabled.'));
             console.log('');
@@ -367,12 +382,21 @@ export function registerConfigCommand(program) {
                 console.log('');
                 console.log(chalk.bold.cyan('  LLM Configuration'));
                 console.log(chalk.gray('  ' + '\u2500'.repeat(40)));
-                console.log(`  ${chalk.gray('Provider:')}   ${result.provider}`);
-                console.log(`  ${chalk.gray('Model:')}      ${result.model}`);
+                console.log(`  ${chalk.gray('Provider:')}      ${result.provider}`);
+                console.log(`  ${chalk.gray('Model:')}         ${result.model}`);
+                if (result.scanModel) {
+                    console.log(`  ${chalk.gray('Scan model:')}    ${result.scanModel}`);
+                }
+                if (result.analyzeModel) {
+                    console.log(`  ${chalk.gray('Analyze model:')} ${result.analyzeModel}`);
+                }
+                if (result.decideModel) {
+                    console.log(`  ${chalk.gray('Decide model:')}  ${result.decideModel}`);
+                }
                 if (result.baseUrl) {
-                    console.log(`  ${chalk.gray('Base URL:')}   ${result.baseUrl}`);
+                    console.log(`  ${chalk.gray('Base URL:')}      ${result.baseUrl}`);
                 }
-                console.log(`  ${chalk.gray('Updated:')}    ${new Date(result.updatedAt).toLocaleString()}`);
+                console.log(`  ${chalk.gray('Updated:')}       ${new Date(result.updatedAt).toLocaleString()}`);
                 console.log('');
             }
         }