clodds 1.1.0

package/dist/cli/commands/index.js

@@ -0,0 +1,3743 @@
+"use strict";
+/**
+ * CLI Commands Module - Clawdbot-style comprehensive CLI commands
+ *
+ * Additional commands for full feature parity
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConfigCommands = createConfigCommands;
+exports.createModelCommands = createModelCommands;
+exports.createSessionCommands = createSessionCommands;
+exports.createCronCommands = createCronCommands;
+exports.createQmdCommands = createQmdCommands;
+exports.createUserCommands = createUserCommands;
+exports.createMemoryCommands = createMemoryCommands;
+exports.createHookCommands = createHookCommands;
+exports.createMcpCommands = createMcpCommands;
+exports.createMarketIndexCommands = createMarketIndexCommands;
+exports.createPermissionCommands = createPermissionCommands;
+exports.createUsageCommands = createUsageCommands;
+exports.createInitCommand = createInitCommand;
+exports.createUpgradeCommand = createUpgradeCommand;
+exports.createLoginCommand = createLoginCommand;
+exports.createLogoutCommand = createLogoutCommand;
+exports.createVersionCommand = createVersionCommand;
+exports.createWhatsAppCommands = createWhatsAppCommands;
+exports.createCredsCommands = createCredsCommands;
+exports.createLocaleCommands = createLocaleCommands;
+exports.createLedgerCommands = createLedgerCommands;
+exports.createBittensorCommands = createBittensorCommands;
+exports.createDoctorCommand = createDoctorCommand;
+exports.createOnboardCommand = createOnboardCommand;
+exports.addAllCommands = addAllCommands;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const hooks_1 = require("../../hooks");
+const db_1 = require("../../db");
+const migrations_1 = require("../../db/migrations");
+const permissions_1 = require("../../permissions");
+const config_1 = require("../../utils/config");
+const index_1 = require("../../channels/whatsapp/index");
+// =============================================================================
+// CONFIG COMMANDS
+// =============================================================================
+function createConfigCommands(program) {
+    const config = program
+        .command('config')
+        .description('Manage configuration');
+    config
+        .command('get [key]')
+        .description('Get config value or show all')
+        .action(async (key) => {
+        const configPath = (0, path_1.join)((0, os_1.homedir)(), '.clodds', 'config.json');
+        if (!(0, fs_1.existsSync)(configPath)) {
+            console.log('No configuration file found');
+            return;
+        }
+        const data = JSON.parse((0, fs_1.readFileSync)(configPath, 'utf-8'));
+        if (key) {
+            const value = key.split('.').reduce((obj, k) => obj?.[k], data);
+            console.log(value !== undefined ? JSON.stringify(value, null, 2) : 'Key not found');
+        }
+        else {
+            console.log(JSON.stringify(data, null, 2));
+        }
+    });
+    config
+        .command('set <key> <value>')
+        .description('Set a config value')
+        .action(async (key, value) => {
+        const configDir = (0, path_1.join)((0, os_1.homedir)(), '.clodds');
+        const configPath = (0, path_1.join)(configDir, 'config.json');
+        if (!(0, fs_1.existsSync)(configDir)) {
+            (0, fs_1.mkdirSync)(configDir, { recursive: true });
+        }
+        let data = {};
+        if ((0, fs_1.existsSync)(configPath)) {
+            data = JSON.parse((0, fs_1.readFileSync)(configPath, 'utf-8'));
+        }
+        // Handle nested keys
+        const keys = key.split('.');
+        let obj = data;
+        for (let i = 0; i < keys.length - 1; i++) {
+            if (!obj[keys[i]])
+                obj[keys[i]] = {};
+            obj = obj[keys[i]];
+        }
+        // Try to parse value as JSON, otherwise use as string
+        try {
+            obj[keys[keys.length - 1]] = JSON.parse(value);
+        }
+        catch {
+            obj[keys[keys.length - 1]] = value;
+        }
+        (0, fs_1.writeFileSync)(configPath, JSON.stringify(data, null, 2));
+        console.log(`Set ${key} = ${value}`);
+    });
+    config
+        .command('unset <key>')
+        .description('Remove a config value')
+        .action(async (key) => {
+        const configPath = (0, path_1.join)((0, os_1.homedir)(), '.clodds', 'config.json');
+        if (!(0, fs_1.existsSync)(configPath)) {
+            console.log('No configuration file found');
+            return;
+        }
+        const data = JSON.parse((0, fs_1.readFileSync)(configPath, 'utf-8'));
+        const keys = key.split('.');
+        let obj = data;
+        for (let i = 0; i < keys.length - 1; i++) {
+            if (!obj[keys[i]])
+                return;
+            obj = obj[keys[i]];
+        }
+        delete obj[keys[keys.length - 1]];
+        (0, fs_1.writeFileSync)(configPath, JSON.stringify(data, null, 2));
+        console.log(`Removed ${key}`);
+    });
+    config
+        .command('path')
+        .description('Show config file path')
+        .action(() => {
+        console.log((0, path_1.join)((0, os_1.homedir)(), '.clodds', 'config.json'));
+    });
+}
+// =============================================================================
+// MODEL COMMANDS
+// =============================================================================
+function createModelCommands(program) {
+    const model = program
+        .command('model')
+        .description('Manage AI models');
+    model
+        .command('list')
+        .description('List available models')
+        .option('-p, --provider <provider>', 'Filter by provider')
+        .action(async (options) => {
+        console.log('Available models:');
+        console.log('');
+        const models = [
+            { id: 'claude-3-5-sonnet-20241022', provider: 'anthropic', context: '200K' },
+            { id: 'claude-3-opus-20240229', provider: 'anthropic', context: '200K' },
+            { id: 'claude-3-5-haiku-20241022', provider: 'anthropic', context: '200K' },
+            { id: 'gpt-4o', provider: 'openai', context: '128K' },
+            { id: 'gpt-4-turbo', provider: 'openai', context: '128K' },
+            { id: 'gpt-3.5-turbo', provider: 'openai', context: '16K' },
+            { id: 'llama3', provider: 'ollama', context: '8K' },
+        ];
+        const filtered = options.provider
+            ? models.filter(m => m.provider === options.provider)
+            : models;
+        for (const m of filtered) {
+            console.log(`  ${m.id.padEnd(35)} ${m.provider.padEnd(12)} ${m.context}`);
+        }
+    });
+    model
+        .command('default [model]')
+        .description('Get or set default model')
+        .action(async (model) => {
+        const configPath = (0, path_1.join)((0, os_1.homedir)(), '.clodds', 'config.json');
+        let data = {};
+        if ((0, fs_1.existsSync)(configPath)) {
+            data = JSON.parse((0, fs_1.readFileSync)(configPath, 'utf-8'));
+        }
+        if (model) {
+            data.defaultModel = model;
+            (0, fs_1.writeFileSync)(configPath, JSON.stringify(data, null, 2));
+            console.log(`Default model set to: ${model}`);
+        }
+        else {
+            console.log(`Default model: ${data.defaultModel || 'claude-3-5-sonnet-20241022'}`);
+        }
+    });
+}
+// =============================================================================
+// SESSION COMMANDS
+// =============================================================================
+function createSessionCommands(program) {
+    const session = program
+        .command('session')
+        .description('Manage sessions');
+    session
+        .command('list')
+        .description('List active sessions')
+        .action(async () => {
+        const sessionsDir = (0, path_1.join)((0, os_1.homedir)(), '.clodds', 'sessions');
+        if (!(0, fs_1.existsSync)(sessionsDir)) {
+            console.log('No sessions found');
+            return;
+        }
+        const sessions = (0, fs_1.readdirSync)(sessionsDir).filter(f => f.endsWith('.json'));
+        console.log(`\nActive sessions (${sessions.length}):\n`);
+        for (const file of sessions.slice(0, 20)) {
+            const sessionPath = (0, path_1.join)(sessionsDir, file);
+            try {
+                const data = JSON.parse((0, fs_1.readFileSync)(sessionPath, 'utf-8'));
+                const id = file.replace('.json', '');
+                console.log(`  ${id.slice(0, 8)}  ${data.userId || '-'}  ${data.createdAt || '-'}`);
+            }
+            catch { }
+        }
+    });
+    session
+        .command('clear [sessionId]')
+        .description('Clear a session or all sessions')
+        .option('-a, --all', 'Clear all sessions')
+        .action(async (sessionId, options) => {
+        const sessionsDir = (0, path_1.join)((0, os_1.homedir)(), '.clodds', 'sessions');
+        if (options?.all) {
+            if ((0, fs_1.existsSync)(sessionsDir)) {
+                const { rmSync } = require('fs');
+                rmSync(sessionsDir, { recursive: true });
+                (0, fs_1.mkdirSync)(sessionsDir, { recursive: true });
+            }
+            console.log('Cleared all sessions');
+        }
+        else if (sessionId) {
+            const sessionPath = (0, path_1.join)(sessionsDir, `${sessionId}.json`);
+            if ((0, fs_1.existsSync)(sessionPath)) {
+                const { unlinkSync } = require('fs');
+                unlinkSync(sessionPath);
+                console.log(`Cleared session: ${sessionId}`);
+            }
+            else {
+                console.log('Session not found');
+            }
+        }
+        else {
+            console.log('Specify a session ID or use --all');
+        }
+    });
+}
+// =============================================================================
+// CRON COMMANDS
+// =============================================================================
+function createCronCommands(program) {
+    const cron = program
+        .command('cron')
+        .description('Manage scheduled cron jobs');
+    const withDb = async (fn) => {
+        const db = (0, db_1.createDatabase)();
+        (0, migrations_1.createMigrationRunner)(db).migrate();
+        try {
+            return await fn(db);
+        }
+        finally {
+            db.close();
+        }
+    };
+    const formatSchedule = (schedule) => {
+        if (!schedule)
+            return 'n/a';
+        if (schedule.kind === 'every') {
+            const ms = schedule.everyMs;
+            if (!ms || ms <= 0)
+                return 'every ?';
+            const mins = Math.round(ms / 60000);
+            return mins >= 60 ? `every ${Math.round(mins / 60)}h` : `every ${mins}m`;
+        }
+        if (schedule.kind === 'cron') {
+            return `cron ${String(schedule.expr ?? '')}`;
+        }
+        if (schedule.kind === 'at') {
+            const atMs = schedule.atMs;
+            return atMs ? `at ${new Date(atMs).toLocaleString()}` : 'at ?';
+        }
+        return String(schedule.kind);
+    };
+    const parseJob = (record) => {
+        try {
+            const job = JSON.parse(record.data);
+            return {
+                ...record,
+                job,
+            };
+        }
+        catch {
+            return { ...record, job: {} };
+        }
+    };
+    cron
+        .command('list')
+        .description('List cron jobs')
+        .option('-a, --all', 'Include disabled jobs')
+        .action(async (options) => {
+        await withDb(async (db) => {
+            const records = db.listCronJobs();
+            if (records.length === 0) {
+                console.log('No cron jobs found.');
+                return;
+            }
+            const entries = records.map(parseJob)
+                .filter((entry) => options.all || entry.enabled);
+            if (entries.length === 0) {
+                console.log('No enabled cron jobs found.');
+                return;
+            }
+            console.log('\nCron Jobs:\n');
+            console.log('ID			Enabled	Schedule		Next Run		Name');
+            console.log('─'.repeat(90));
+            for (const entry of entries) {
+                const schedule = formatSchedule(entry.job.schedule);
+                const nextRun = entry.job.state?.nextRunAtMs
+                    ? new Date(entry.job.state.nextRunAtMs).toLocaleString()
+                    : '-';
+                const name = entry.job.name || '-';
+                console.log(`${entry.id}	${entry.enabled ? 'yes' : 'no '}	${schedule}	${nextRun}	${name}`);
+            }
+        });
+    });
+    cron
+        .command('show <id>')
+        .description('Show a cron job detail')
+        .action(async (id) => {
+        await withDb(async (db) => {
+            const record = db.getCronJob(id);
+            if (!record) {
+                console.log(`Cron job not found: ${id}`);
+                return;
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(record.data);
+            }
+            catch {
+                parsed = record.data;
+            }
+            console.log(JSON.stringify({
+                id: record.id,
+                enabled: record.enabled,
+                createdAt: new Date(record.createdAtMs).toISOString(),
+                updatedAt: new Date(record.updatedAtMs).toISOString(),
+                job: parsed,
+            }, null, 2));
+        });
+    });
+    const setEnabled = async (id, enabled) => {
+        await withDb(async (db) => {
+            const record = db.getCronJob(id);
+            if (!record) {
+                console.log(`Cron job not found: ${id}`);
+                return;
+            }
+            let job = null;
+            try {
+                job = JSON.parse(record.data);
+            }
+            catch {
+                job = null;
+            }
+            if (job && typeof job === 'object') {
+                job.enabled = enabled;
+            }
+            const data = job ? JSON.stringify(job) : record.data;
+            db.upsertCronJob({
+                id: record.id,
+                data,
+                enabled,
+                createdAtMs: record.createdAtMs,
+                updatedAtMs: Date.now(),
+            });
+            console.log(`Cron job ${enabled ? 'enabled' : 'disabled'}: ${id}`);
+            console.log('Restart the gateway if it is already running to apply changes.');
+        });
+    };
+    cron
+        .command('enable <id>')
+        .description('Enable a cron job')
+        .action(async (id) => setEnabled(id, true));
+    cron
+        .command('disable <id>')
+        .description('Disable a cron job')
+        .action(async (id) => setEnabled(id, false));
+    cron
+        .command('delete <id>')
+        .description('Delete a cron job')
+        .action(async (id) => {
+        await withDb(async (db) => {
+            const record = db.getCronJob(id);
+            if (!record) {
+                console.log(`Cron job not found: ${id}`);
+                return;
+            }
+            db.deleteCronJob(id);
+            console.log(`Cron job deleted: ${id}`);
+            console.log('Restart the gateway if it is already running to apply changes.');
+        });
+    });
+}
+// =============================================================================
+// QMD COMMANDS
+// =============================================================================
+function createQmdCommands(program) {
+    const qmd = program
+        .command('qmd')
+        .description('Local markdown search powered by qmd');
+    const runQmd = (args, timeoutMs) => {
+        const env = { ...process.env };
+        const bunBin = (0, path_1.join)((0, os_1.homedir)(), '.bun', 'bin');
+        env.PATH = [bunBin, env.PATH || ''].filter(Boolean).join(':');
+        const result = (0, child_process_1.spawnSync)('qmd', args, {
+            stdio: 'inherit',
+            env,
+            timeout: timeoutMs,
+        });
+        if (result.error) {
+            const err = result.error;
+            if (err.code === 'ENOENT') {
+                console.error('qmd not found. Install with: bun install -g https://github.com/tobi/qmd');
+            }
+            else {
+                console.error(err.message || 'Failed to run qmd');
+            }
+            process.exitCode = 1;
+            return;
+        }
+        if (typeof result.status === 'number' && result.status !== 0) {
+            process.exitCode = result.status;
+        }
+    };
+    const buildSearchArgs = (mode, query, options) => {
+        const args = [mode, query];
+        if (options.collection)
+            args.push('-c', options.collection);
+        if (options.limit)
+            args.push('-n', options.limit);
+        if (options.json)
+            args.push('--json');
+        if (options.files)
+            args.push('--files');
+        if (options.all)
+            args.push('--all');
+        if (options.full)
+            args.push('--full');
+        if (options.minScore)
+            args.push('--min-score', options.minScore);
+        return args;
+    };
+    const addSearchCommand = (mode, description, timeoutMs) => {
+        qmd
+            .command(`${mode} <query>`)
+            .description(description)
+            .option('-c, --collection <name>', 'Restrict to a collection')
+            .option('-n, --limit <n>', 'Number of results')
+            .option('--json', 'JSON output')
+            .option('--files', 'File-only output (JSON)')
+            .option('--all', 'Return all matches above threshold')
+            .option('--full', 'Return full document content')
+            .option('--min-score <score>', 'Minimum score threshold')
+            .action((query, options) => {
+            runQmd(buildSearchArgs(mode, query, options), timeoutMs);
+        });
+    };
+    addSearchCommand('search', 'Keyword search (BM25)', 30_000);
+    addSearchCommand('vsearch', 'Semantic search (slow)', 180_000);
+    addSearchCommand('query', 'Hybrid search + rerank (slow)', 180_000);
+    qmd
+        .command('get <target>')
+        .description('Retrieve a document by path or #docid')
+        .option('--json', 'JSON output')
+        .option('--full', 'Return full document content')
+        .action((target, options) => {
+        const args = ['get', target];
+        if (options.json)
+            args.push('--json');
+        if (options.full)
+            args.push('--full');
+        runQmd(args, 30_000);
+    });
+    qmd
+        .command('multi-get <targets>')
+        .description('Retrieve multiple documents (comma-separated list)')
+        .option('--json', 'JSON output')
+        .action((targets, options) => {
+        const args = ['multi-get', targets];
+        if (options.json)
+            args.push('--json');
+        runQmd(args, 60_000);
+    });
+    qmd
+        .command('status')
+        .description('Show index status')
+        .action(() => runQmd(['status'], 30_000));
+    qmd
+        .command('update')
+        .description('Incrementally update the index')
+        .action(() => runQmd(['update'], 120_000));
+    qmd
+        .command('embed')
+        .description('Update embeddings (slow)')
+        .action(() => runQmd(['embed'], 300_000));
+    const collection = qmd
+        .command('collection')
+        .description('Manage collections');
+    collection
+        .command('add <path>')
+        .description('Add a markdown collection')
+        .requiredOption('-n, --name <name>', 'Collection name')
+        .option('-m, --mask <glob>', 'Glob mask (default "**/*.md")')
+        .action((path, options) => {
+        const args = ['collection', 'add', path, '--name', options.name];
+        if (options.mask)
+            args.push('--mask', options.mask);
+        runQmd(args, 60_000);
+    });
+    const contextCmd = qmd
+        .command('context')
+        .description('Manage collection context');
+    contextCmd
+        .command('add <collection> <description>')
+        .description('Attach a description to a collection')
+        .action((collectionName, description) => {
+        runQmd(['context', 'add', collectionName, description], 30_000);
+    });
+}
+// =============================================================================
+// USER COMMANDS
+// =============================================================================
+function createUserCommands(program) {
+    const users = program
+        .command('users')
+        .description('Manage users and per-user settings');
+    const withDb = async (fn) => {
+        const db = (0, db_1.createDatabase)();
+        (0, migrations_1.createMigrationRunner)(db).migrate();
+        try {
+            return await fn(db);
+        }
+        finally {
+            db.close();
+        }
+    };
+    users
+        .command('list')
+        .description('List known users')
+        .action(async () => {
+        await withDb((db) => {
+            const rows = db.listUsers();
+            if (rows.length === 0) {
+                console.log('No users found.');
+                return;
+            }
+            console.log('\nUsers:\n');
+            console.log('ID\t\tPlatform\tPlatformUserId\tUsername');
+            console.log('─'.repeat(80));
+            for (const user of rows) {
+                console.log(`${user.id}\t${user.platform}\t${user.platformUserId}\t${user.username || '-'}`);
+            }
+        });
+    });
+    users
+        .command('settings <platform> <platformUserId>')
+        .description('Show settings for a user')
+        .action(async (platform, platformUserId) => {
+        await withDb((db) => {
+            const user = db.getUserByPlatformId(platform, platformUserId);
+            if (!user) {
+                console.log('User not found.');
+                return;
+            }
+            console.log(JSON.stringify(user.settings || {}, null, 2));
+        });
+    });
+    users
+        .command('settings-by-id <userId>')
+        .description('Show settings for a user by internal ID')
+        .action(async (userId) => {
+        await withDb((db) => {
+            const user = db.getUser(userId);
+            if (!user) {
+                console.log('User not found.');
+                return;
+            }
+            console.log(JSON.stringify(user.settings || {}, null, 2));
+        });
+    });
+    const applySettings = async (db, userId, patch) => {
+        return db.updateUserSettings(userId, patch);
+    };
+    const parseNumber = (value) => {
+        if (value === undefined)
+            return undefined;
+        const num = Number(value);
+        if (!Number.isFinite(num))
+            return undefined;
+        return num;
+    };
+    const parseDigestTime = (value) => {
+        if (!value)
+            return undefined;
+        const match = value.match(/^(\d{1,2}):(\d{2})$/);
+        if (!match)
+            return undefined;
+        const hour = Number.parseInt(match[1], 10);
+        const minute = Number.parseInt(match[2], 10);
+        if (!Number.isFinite(hour) || hour < 0 || hour > 23)
+            return undefined;
+        if (!Number.isFinite(minute) || minute < 0 || minute > 59)
+            return undefined;
+        return `${hour.toString().padStart(2, '0')}:${minute.toString().padStart(2, '0')}`;
+    };
+    users
+        .command('set-settings <platform> <platformUserId>')
+        .description('Update settings for a user')
+        .option('--max-order-size <usd>', 'Max single order size (USD)')
+        .option('--max-position-value <usd>', 'Max exposure per position (USD)')
+        .option('--max-total-exposure <usd>', 'Max total exposure (USD)')
+        .option('--stop-loss-pct <pct>', 'Stop-loss trigger percent (e.g., 0.2 or 20)')
+        .option('--digest-enable', 'Enable daily digest notifications')
+        .option('--digest-disable', 'Disable daily digest notifications')
+        .option('--digest-time <HH:MM>', 'Set daily digest time (24h, local)')
+        .option('--digest-reset', 'Disable digest and clear time')
+        .option('--reset', 'Clear risk limits')
+        .option('--disable', 'Disable risk limits (set to 0)')
+        .action(async (platform, platformUserId, options) => {
+        await withDb(async (db) => {
+            const user = db.getUserByPlatformId(platform, platformUserId);
+            if (!user) {
+                console.log('User not found.');
+                return;
+            }
+            const patch = {};
+            if (options.reset) {
+                patch.maxOrderSize = undefined;
+                patch.maxPositionValue = undefined;
+                patch.maxTotalExposure = undefined;
+                patch.stopLossPct = undefined;
+            }
+            else if (options.disable) {
+                patch.maxOrderSize = 0;
+                patch.maxPositionValue = 0;
+                patch.maxTotalExposure = 0;
+                patch.stopLossPct = 0;
+            }
+            else {
+                const maxOrderSize = parseNumber(options.maxOrderSize);
+                const maxPositionValue = parseNumber(options.maxPositionValue);
+                const maxTotalExposure = parseNumber(options.maxTotalExposure);
+                const stopLossPct = parseNumber(options.stopLossPct);
+                if (maxOrderSize !== undefined)
+                    patch.maxOrderSize = maxOrderSize;
+                if (maxPositionValue !== undefined)
+                    patch.maxPositionValue = maxPositionValue;
+                if (maxTotalExposure !== undefined)
+                    patch.maxTotalExposure = maxTotalExposure;
+                if (stopLossPct !== undefined)
+                    patch.stopLossPct = stopLossPct;
+            }
+            if (options.digestReset) {
+                patch.digestEnabled = false;
+                patch.digestTime = undefined;
+            }
+            else {
+                if (options.digestEnable)
+                    patch.digestEnabled = true;
+                if (options.digestDisable)
+                    patch.digestEnabled = false;
+                if (options.digestTime) {
+                    const time = parseDigestTime(options.digestTime);
+                    if (!time) {
+                        console.log('Invalid --digest-time. Use HH:MM (24h).');
+                        return;
+                    }
+                    patch.digestTime = time;
+                    patch.digestEnabled = true;
+                }
+            }
+            if (Object.keys(patch).length === 0) {
+                console.log('No settings provided.');
+                return;
+            }
+            const ok = await applySettings(db, user.id, patch);
+            console.log(ok ? 'Updated settings.' : 'Failed to update settings.');
+        });
+    });
+    users
+        .command('set-settings-by-id <userId>')
+        .description('Update settings by internal user ID')
+        .option('--max-order-size <usd>', 'Max single order size (USD)')
+        .option('--max-position-value <usd>', 'Max exposure per position (USD)')
+        .option('--max-total-exposure <usd>', 'Max total exposure (USD)')
+        .option('--stop-loss-pct <pct>', 'Stop-loss trigger percent (e.g., 0.2 or 20)')
+        .option('--digest-enable', 'Enable daily digest notifications')
+        .option('--digest-disable', 'Disable daily digest notifications')
+        .option('--digest-time <HH:MM>', 'Set daily digest time (24h, local)')
+        .option('--digest-reset', 'Disable digest and clear time')
+        .option('--reset', 'Clear risk limits')
+        .option('--disable', 'Disable risk limits (set to 0)')
+        .action(async (userId, options) => {
+        await withDb(async (db) => {
+            const patch = {};
+            if (options.reset) {
+                patch.maxOrderSize = undefined;
+                patch.maxPositionValue = undefined;
+                patch.maxTotalExposure = undefined;
+                patch.stopLossPct = undefined;
+            }
+            else if (options.disable) {
+                patch.maxOrderSize = 0;
+                patch.maxPositionValue = 0;
+                patch.maxTotalExposure = 0;
+                patch.stopLossPct = 0;
+            }
+            else {
+                const maxOrderSize = parseNumber(options.maxOrderSize);
+                const maxPositionValue = parseNumber(options.maxPositionValue);
+                const maxTotalExposure = parseNumber(options.maxTotalExposure);
+                const stopLossPct = parseNumber(options.stopLossPct);
+                if (maxOrderSize !== undefined)
+                    patch.maxOrderSize = maxOrderSize;
+                if (maxPositionValue !== undefined)
+                    patch.maxPositionValue = maxPositionValue;
+                if (maxTotalExposure !== undefined)
+                    patch.maxTotalExposure = maxTotalExposure;
+                if (stopLossPct !== undefined)
+                    patch.stopLossPct = stopLossPct;
+            }
+            if (options.digestReset) {
+                patch.digestEnabled = false;
+                patch.digestTime = undefined;
+            }
+            else {
+                if (options.digestEnable)
+                    patch.digestEnabled = true;
+                if (options.digestDisable)
+                    patch.digestEnabled = false;
+                if (options.digestTime) {
+                    const time = parseDigestTime(options.digestTime);
+                    if (!time) {
+                        console.log('Invalid --digest-time. Use HH:MM (24h).');
+                        return;
+                    }
+                    patch.digestTime = time;
+                    patch.digestEnabled = true;
+                }
+            }
+            if (Object.keys(patch).length === 0) {
+                console.log('No settings provided.');
+                return;
+            }
+            const ok = await applySettings(db, userId, patch);
+            console.log(ok ? 'Updated settings.' : 'User not found.');
+        });
+    });
+}
+// =============================================================================
+// MEMORY COMMANDS
+// =============================================================================
+function createMemoryCommands(program) {
+    const memory = program
+        .command('memory')
+        .description('Manage memory');
+    const withDb = async (fn) => {
+        const db = (0, db_1.createDatabase)();
+        (0, migrations_1.createMigrationRunner)(db).migrate();
+        try {
+            return await fn(db);
+        }
+        finally {
+            db.close();
+        }
+    };
+    memory
+        .command('list <userId>')
+        .description('List memories for a user')
+        .option('-t, --type <type>', 'Filter by type (fact, preference, note, summary, context, profile)')
+        .option('-c, --channel <channel>', 'Filter by channel', 'cli')
+        .option('-l, --limit <n>', 'Limit results', '50')
+        .action(async (userId, options) => {
+        await withDb((db) => {
+            const limit = parseInt(options.limit || '50', 10);
+            let query = 'SELECT * FROM user_memory WHERE userId = ?';
+            const params = [userId];
+            if (options.channel) {
+                query += ' AND channel = ?';
+                params.push(options.channel);
+            }
+            if (options.type) {
+                query += ' AND type = ?';
+                params.push(options.type);
+            }
+            query += ' ORDER BY updatedAt DESC LIMIT ?';
+            params.push(limit);
+            try {
+                const rows = db.query(query, params);
+                if (rows.length === 0) {
+                    console.log(`\nNo memories found for user: ${userId}`);
+                    if (options.type)
+                        console.log(`  (filtered by type: ${options.type})`);
+                    return;
+                }
+                console.log(`\nMemories for ${userId} (${rows.length}):\n`);
+                console.log('Type\t\tKey\t\t\tValue\t\t\t\tUpdated');
+                console.log('─'.repeat(90));
+                for (const row of rows) {
+                    const key = row.key.length > 20 ? row.key.slice(0, 17) + '...' : row.key.padEnd(20);
+                    const value = row.value.length > 30 ? row.value.slice(0, 27) + '...' : row.value.padEnd(30);
+                    const updated = row.updatedAt.slice(0, 16).replace('T', ' ');
+                    console.log(`${row.type.padEnd(12)}\t${key}\t${value}\t${updated}`);
+                }
+            }
+            catch (e) {
+                // Table might not exist yet
+                console.log(`\nNo memories found for user: ${userId}`);
+                console.log('(Memory table not initialized - run the gateway first)');
+            }
+        });
+    });
+    memory
+        .command('clear <userId>')
+        .description('Clear all memories for a user')
+        .option('-c, --channel <channel>', 'Clear only for specific channel')
+        .option('-t, --type <type>', 'Clear only specific type')
+        .option('-y, --yes', 'Skip confirmation')
+        .action(async (userId, options) => {
+        await withDb((db) => {
+            let query = 'DELETE FROM user_memory WHERE userId = ?';
+            const params = [userId];
+            let desc = `all memories for ${userId}`;
+            if (options.channel) {
+                query += ' AND channel = ?';
+                params.push(options.channel);
+                desc += ` in channel ${options.channel}`;
+            }
+            if (options.type) {
+                query += ' AND type = ?';
+                params.push(options.type);
+                desc += ` of type ${options.type}`;
+            }
+            if (!options.yes) {
+                console.log(`About to delete ${desc}`);
+                console.log('Run with --yes to confirm');
+                return;
+            }
+            try {
+                // Count before delete
+                const countBefore = db.query('SELECT COUNT(*) as count FROM user_memory WHERE userId = ?', [userId]);
+                db.run(query, params);
+                const countAfter = db.query('SELECT COUNT(*) as count FROM user_memory WHERE userId = ?', [userId]);
+                const deleted = (countBefore[0]?.count || 0) - (countAfter[0]?.count || 0);
+                console.log(`Cleared ${deleted} memories for ${userId}`);
+            }
+            catch (e) {
+                console.log('No memories to clear (table not initialized)');
+            }
+        });
+    });
+    memory
+        .command('export <userId>')
+        .description('Export memories to JSON')
+        .option('-o, --output <file>', 'Output file')
+        .option('-c, --channel <channel>', 'Export only for specific channel')
+        .action(async (userId, options) => {
+        await withDb((db) => {
+            let query = 'SELECT * FROM user_memory WHERE userId = ?';
+            const params = [userId];
+            if (options.channel) {
+                query += ' AND channel = ?';
+                params.push(options.channel);
+            }
+            query += ' ORDER BY type, key';
+            try {
+                const rows = db.query(query, params);
+                const output = options.output || `${userId}-memories.json`;
+                if (rows.length === 0) {
+                    console.log(`No memories to export for ${userId}`);
+                    return;
+                }
+                (0, fs_1.writeFileSync)(output, JSON.stringify(rows, null, 2));
+                console.log(`Exported ${rows.length} memories to ${output}`);
+            }
+            catch (e) {
+                console.log('No memories to export (table not initialized)');
+            }
+        });
+    });
+    memory
+        .command('search <userId> <query>')
+        .description('Search memories by content')
+        .option('-c, --channel <channel>', 'Search only in specific channel')
+        .action(async (userId, query, options) => {
+        await withDb((db) => {
+            let sql = 'SELECT * FROM user_memory WHERE userId = ? AND (key LIKE ? OR value LIKE ?)';
+            const searchPattern = `%${query}%`;
+            const params = [userId, searchPattern, searchPattern];
+            if (options.channel) {
+                sql += ' AND channel = ?';
+                params.push(options.channel);
+            }
+            sql += ' ORDER BY updatedAt DESC LIMIT 20';
+            try {
+                const rows = db.query(sql, params);
+                if (rows.length === 0) {
+                    console.log(`\nNo memories matching "${query}" for ${userId}`);
+                    return;
+                }
+                console.log(`\nSearch results for "${query}" (${rows.length}):\n`);
+                for (const row of rows) {
+                    console.log(`[${row.type}] ${row.key}: ${row.value.slice(0, 60)}${row.value.length > 60 ? '...' : ''}`);
+                }
+            }
+            catch (e) {
+                console.log('Memory table not initialized');
+            }
+        });
+    });
+}
+// =============================================================================
+// HOOK COMMANDS
+// =============================================================================
+function createHookCommands(program) {
+    const hooks = program
+        .command('hooks')
+        .description('Manage hooks');
+    hooks
+        .command('list')
+        .description('List installed hooks')
+        .action(async () => {
+        const hooksDir = (0, hooks_1.getHooksDir)();
+        if (!(0, fs_1.existsSync)(hooksDir)) {
+            console.log('No hooks installed');
+            return;
+        }
+        const entries = (0, fs_1.readdirSync)(hooksDir, { withFileTypes: true }).filter((entry) => entry.isDirectory());
+        if (entries.length === 0) {
+            console.log('No hooks installed');
+            return;
+        }
+        const state = (0, hooks_1.loadHooksState)();
+        console.log(`\nInstalled hooks (${entries.length}):\n`);
+        for (const entry of entries) {
+            const hookPath = (0, path_1.join)(hooksDir, entry.name);
+            const enabled = state.sources[hookPath]?.enabled ?? true;
+            console.log(`  ${entry.name} (${enabled ? 'enabled' : 'disabled'})`);
+        }
+    });
+    hooks
+        .command('install <path>')
+        .description('Install a hook')
+        .action(async (path) => {
+        const hooksDir = (0, hooks_1.getHooksDir)();
+        if (!(0, fs_1.existsSync)(hooksDir)) {
+            (0, fs_1.mkdirSync)(hooksDir, { recursive: true });
+        }
+        const resolved = path.trim();
+        if (!resolved) {
+            console.error('Missing hook path');
+            return;
+        }
+        const stats = (0, fs_1.statSync)(resolved);
+        const hookName = resolved.split('/').filter(Boolean).pop();
+        const destDir = (0, path_1.join)(hooksDir, hookName);
+        if (!(0, fs_1.existsSync)(destDir)) {
+            (0, fs_1.mkdirSync)(destDir, { recursive: true });
+        }
+        if (stats.isDirectory()) {
+            (0, fs_1.cpSync)(resolved, destDir, { recursive: true });
+        }
+        else {
+            const content = (0, fs_1.readFileSync)(resolved, 'utf-8');
+            (0, fs_1.writeFileSync)((0, path_1.join)(destDir, 'index.js'), content);
+        }
+        (0, hooks_1.setHookSourceEnabled)(destDir, true);
+        console.log(`Installed hook: ${hookName}`);
+    });
+    hooks
+        .command('uninstall <name>')
+        .description('Uninstall a hook')
+        .action(async (name) => {
+        const hooksDir = (0, hooks_1.getHooksDir)();
+        const target = (0, path_1.join)(hooksDir, name);
+        if (!(0, fs_1.existsSync)(target)) {
+            console.log(`Hook not found: ${name}`);
+            return;
+        }
+        (0, fs_1.rmSync)(target, { recursive: true, force: true });
+        (0, hooks_1.removeHookSourceState)(target);
+        console.log(`Uninstalled hook: ${name}`);
+    });
+    hooks
+        .command('enable <name>')
+        .description('Enable a hook')
+        .action(async (name) => {
+        const hooksDir = (0, hooks_1.getHooksDir)();
+        const target = (0, path_1.join)(hooksDir, name);
+        if (!(0, fs_1.existsSync)(target)) {
+            console.log(`Hook not found: ${name}`);
+            return;
+        }
+        (0, hooks_1.setHookSourceEnabled)(target, true);
+        console.log(`Enabled hook: ${name}`);
+    });
+    hooks
+        .command('disable <name>')
+        .description('Disable a hook')
+        .action(async (name) => {
+        const hooksDir = (0, hooks_1.getHooksDir)();
+        const target = (0, path_1.join)(hooksDir, name);
+        if (!(0, fs_1.existsSync)(target)) {
+            console.log(`Hook not found: ${name}`);
+            return;
+        }
+        (0, hooks_1.setHookSourceEnabled)(target, false);
+        console.log(`Disabled hook: ${name}`);
+    });
+    hooks
+        .command('trace')
+        .description('Show recent hook traces')
+        .option('-n, --limit <n>', 'Number of trace entries to show', '50')
+        .option('--clear', 'Clear trace log')
+        .action(async (options) => {
+        const hooksDir = (0, hooks_1.getHooksDir)();
+        const tracePath = (0, path_1.join)(hooksDir, 'trace.log');
+        if (options.clear) {
+            if ((0, fs_1.existsSync)(tracePath)) {
+                (0, fs_1.truncateSync)(tracePath, 0);
+            }
+            console.log('Hook trace log cleared');
+            return;
+        }
+        if (!(0, fs_1.existsSync)(tracePath)) {
+            console.log('No hook trace log found');
+            return;
+        }
+        const limit = Math.max(1, Number.parseInt(options.limit, 10) || 50);
+        const content = (0, fs_1.readFileSync)(tracePath, 'utf-8').trim();
+        if (!content) {
+            console.log('Hook trace log is empty');
+            return;
+        }
+        const lines = content.split('\n').filter(Boolean);
+        const slice = lines.slice(Math.max(0, lines.length - limit));
+        console.log(`\nHook traces (last ${slice.length}):\n`);
+        for (const line of slice) {
+            try {
+                const entry = JSON.parse(line);
+                const name = entry.hookName || entry.hookId || 'unknown';
+                const status = entry.status || 'ok';
+                const duration = typeof entry.durationMs === 'number' ? `${entry.durationMs}ms` : '';
+                const error = entry.error ? ` - ${entry.error}` : '';
+                console.log(`  ${entry.event} :: ${name} :: ${status} ${duration}${error}`);
+            }
+            catch {
+                console.log(`  ${line}`);
+            }
+        }
+    });
+    const hookState = hooks
+        .command('state')
+        .description('Manage hook state storage');
+    hookState
+        .command('get <name> [key]')
+        .description('Get hook state (whole or key)')
+        .action(async (name, key) => {
+        const hookKey = (0, hooks_1.resolveHookStateKey)(name);
+        const store = (0, hooks_1.loadHookStateStore)();
+        const data = store.data[hookKey];
+        if (!data) {
+            console.log('No state found for hook');
+            return;
+        }
+        if (key) {
+            console.log(JSON.stringify(data[key], null, 2));
+            return;
+        }
+        console.log(JSON.stringify(data, null, 2));
+    });
+    hookState
+        .command('set <name> <key> <value>')
+        .description('Set hook state (value can be JSON)')
+        .action(async (name, key, value) => {
+        const hookKey = (0, hooks_1.resolveHookStateKey)(name);
+        const store = (0, hooks_1.loadHookStateStore)();
+        let parsed = value;
+        try {
+            parsed = JSON.parse(value);
+        }
+        catch {
+            // keep as string
+        }
+        if (!store.data[hookKey]) {
+            store.data[hookKey] = {};
+        }
+        store.data[hookKey][key] = parsed;
+        store.updatedAt = new Date().toISOString();
+        (0, hooks_1.saveHookStateStore)(undefined, store);
+        console.log('Hook state updated');
+    });
+    hookState
+        .command('clear <name> [key]')
+        .description('Clear hook state (entire hook or single key)')
+        .action(async (name, key) => {
+        const hookKey = (0, hooks_1.resolveHookStateKey)(name);
+        const store = (0, hooks_1.loadHookStateStore)();
+        if (!store.data[hookKey]) {
+            console.log('No state found for hook');
+            return;
+        }
+        if (key) {
+            delete store.data[hookKey][key];
+        }
+        else {
+            delete store.data[hookKey];
+        }
+        store.updatedAt = new Date().toISOString();
+        (0, hooks_1.saveHookStateStore)(undefined, store);
+        console.log('Hook state cleared');
+    });
+}
+// =============================================================================
+// MCP COMMANDS
+// =============================================================================
+function createMcpCommands(program) {
+    const mcp = program
+        .command('mcp')
+        .description('Manage MCP servers');
+    mcp
+        .command('list')
+        .description('List configured MCP servers')
+        .action(async () => {
+        const mcpConfigPaths = [
+            (0, path_1.join)(process.cwd(), '.mcp.json'),
+            (0, path_1.join)((0, os_1.homedir)(), '.config', 'clodds', 'mcp.json'),
+        ];
+        for (const path of mcpConfigPaths) {
+            if ((0, fs_1.existsSync)(path)) {
+                const config = JSON.parse((0, fs_1.readFileSync)(path, 'utf-8'));
+                console.log(`\nMCP servers from ${path}:\n`);
+                if (config.mcpServers) {
+                    for (const [name, server] of Object.entries(config.mcpServers)) {
+                        const s = server;
+                        if (s.transport === 'sse') {
+                            console.log(`  ${name}: sse ${s.sseEndpoint || ''}`.trim());
+                            if (s.messageEndpoint) {
+                                console.log(`    message: ${s.messageEndpoint}`);
+                            }
+                        }
+                        else {
+                            console.log(`  ${name}: ${s.command || '(missing command)'}`);
+                        }
+                    }
+                }
+                return;
+            }
+        }
+        console.log('No MCP configuration found');
+    });
+    mcp
+        .command('add <name> <command>')
+        .description('Add an MCP server')
+        .option('-a, --args <args>', 'Command arguments (comma-separated)')
+        .option('-e, --env <env>', 'Environment variables (KEY=VALUE,KEY2=VALUE2)')
+        .option('--global', 'Add to global config instead of project')
+        .action(async (name, command, options) => {
+        const configPath = options.global
+            ? (0, path_1.join)((0, os_1.homedir)(), '.config', 'clodds', 'mcp.json')
+            : (0, path_1.join)(process.cwd(), '.mcp.json');
+        // Ensure directory exists for global config
+        if (options.global) {
+            const configDir = (0, path_1.join)((0, os_1.homedir)(), '.config', 'clodds');
+            if (!(0, fs_1.existsSync)(configDir)) {
+                (0, fs_1.mkdirSync)(configDir, { recursive: true });
+            }
+        }
+        // Load or create config
+        let config = { mcpServers: {} };
+        if ((0, fs_1.existsSync)(configPath)) {
+            try {
+                config = JSON.parse((0, fs_1.readFileSync)(configPath, 'utf-8'));
+            }
+            catch (e) {
+                console.error(`Error reading ${configPath}: ${e}`);
+                return;
+            }
+        }
+        if (!config.mcpServers) {
+            config.mcpServers = {};
+        }
+        // Check if already exists
+        if (config.mcpServers[name]) {
+            console.log(`MCP server "${name}" already exists. Use 'mcp remove' first to replace.`);
+            return;
+        }
+        // Build server config
+        const serverConfig = { command };
+        if (options.args) {
+            serverConfig.args = options.args.split(',').map(a => a.trim());
+        }
+        if (options.env) {
+            serverConfig.env = {};
+            for (const pair of options.env.split(',')) {
+                const [key, ...valueParts] = pair.split('=');
+                if (key && valueParts.length > 0) {
+                    serverConfig.env[key.trim()] = valueParts.join('=').trim();
+                }
+            }
+        }
+        config.mcpServers[name] = serverConfig;
+        // Write config
+        (0, fs_1.writeFileSync)(configPath, JSON.stringify(config, null, 2));
+        console.log(`Added MCP server "${name}" to ${configPath}`);
+        console.log(`  Command: ${command}`);
+        if (serverConfig.args)
+            console.log(`  Args: ${serverConfig.args.join(' ')}`);
+        if (serverConfig.env)
+            console.log(`  Env: ${Object.keys(serverConfig.env).join(', ')}`);
+    });
+    mcp
+        .command('remove <name>')
+        .description('Remove an MCP server')
+        .option('--global', 'Remove from global config instead of project')
+        .action(async (name, options) => {
+        const configPath = options.global
+            ? (0, path_1.join)((0, os_1.homedir)(), '.config', 'clodds', 'mcp.json')
+            : (0, path_1.join)(process.cwd(), '.mcp.json');
+        if (!(0, fs_1.existsSync)(configPath)) {
+            console.log(`No MCP config found at ${configPath}`);
+            return;
+        }
+        let config;
+        try {
+            config = JSON.parse((0, fs_1.readFileSync)(configPath, 'utf-8'));
+        }
+        catch (e) {
+            console.error(`Error reading ${configPath}: ${e}`);
+            return;
+        }
+        if (!config.mcpServers || !config.mcpServers[name]) {
+            console.log(`MCP server "${name}" not found in ${configPath}`);
+            return;
+        }
+        delete config.mcpServers[name];
+        (0, fs_1.writeFileSync)(configPath, JSON.stringify(config, null, 2));
+        console.log(`Removed MCP server "${name}" from ${configPath}`);
+    });
+    mcp
+        .command('test <name>')
+        .description('Test connection to MCP server')
+        .option('--global', 'Look in global config instead of project')
+        .option('--timeout <ms>', 'Timeout in milliseconds', '5000')
+        .action(async (name, options) => {
+        const configPaths = options.global
+            ? [(0, path_1.join)((0, os_1.homedir)(), '.config', 'clodds', 'mcp.json')]
+            : [(0, path_1.join)(process.cwd(), '.mcp.json'), (0, path_1.join)((0, os_1.homedir)(), '.config', 'clodds', 'mcp.json')];
+        let serverConfig = null;
+        let foundPath = '';
+        for (const configPath of configPaths) {
+            if ((0, fs_1.existsSync)(configPath)) {
+                try {
+                    const config = JSON.parse((0, fs_1.readFileSync)(configPath, 'utf-8'));
+                    if (config.mcpServers?.[name]) {
+                        serverConfig = config.mcpServers[name];
+                        foundPath = configPath;
+                        break;
+                    }
+                }
+                catch { }
+            }
+        }
+        if (!serverConfig || !serverConfig.command) {
+            console.log(`MCP server "${name}" not found`);
+            return;
+        }
+        console.log(`Testing MCP server "${name}" from ${foundPath}...`);
+        console.log(`  Command: ${serverConfig.command} ${(serverConfig.args || []).join(' ')}`);
+        // Try to spawn the process and check if it starts
+        const { spawn } = require('child_process');
+        const timeout = parseInt(options.timeout || '5000', 10);
+        try {
+            const proc = spawn(serverConfig.command, serverConfig.args || [], {
+                env: { ...process.env, ...serverConfig.env },
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            let output = '';
+            let errorOutput = '';
+            proc.stdout.on('data', (data) => {
+                output += data.toString();
+            });
+            proc.stderr.on('data', (data) => {
+                errorOutput += data.toString();
+            });
+            const result = await Promise.race([
+                new Promise((resolve) => {
+                    // If process emits any data or stays alive for a bit, consider it started
+                    setTimeout(() => resolve('started'), 1000);
+                }),
+                new Promise((_, reject) => {
+                    proc.on('error', (err) => reject(err));
+                }),
+                new Promise((resolve) => {
+                    proc.on('exit', (code) => {
+                        if (code !== 0)
+                            resolve('exited');
+                    });
+                }),
+                new Promise((resolve) => {
+                    setTimeout(() => resolve('timeout'), timeout);
+                }),
+            ]);
+            // Kill the process after test
+            proc.kill();
+            if (result === 'started' || result === 'timeout') {
+                console.log(`\n✅ MCP server "${name}" started successfully`);
+                if (output)
+                    console.log(`  Output: ${output.slice(0, 200)}`);
+            }
+            else {
+                console.log(`\n❌ MCP server "${name}" failed to start`);
+                if (errorOutput)
+                    console.log(`  Error: ${errorOutput.slice(0, 200)}`);
+            }
+        }
+        catch (e) {
+            const err = e;
+            console.log(`\n❌ Failed to start MCP server "${name}"`);
+            console.log(`  Error: ${err.message}`);
+            if (err.code === 'ENOENT') {
+                console.log(`  Command not found: ${serverConfig.command}`);
+            }
+        }
+    });
+}
+// =============================================================================
+// MARKET INDEX COMMANDS
+// =============================================================================
+function createMarketIndexCommands(program) {
+    const marketIndex = program
+        .command('market-index')
+        .description('Market index maintenance');
+    marketIndex
+        .command('stats')
+        .description('Show market index stats (counts by platform)')
+        .option('-p, --platforms <platforms>', 'Comma-separated platforms')
+        .action(async (options) => {
+        const { initDatabase } = await Promise.resolve().then(() => __importStar(require('../../db')));
+        const { createEmbeddingsService } = await Promise.resolve().then(() => __importStar(require('../../embeddings')));
+        const { createMarketIndexService } = await Promise.resolve().then(() => __importStar(require('../../market-index')));
+        const db = await initDatabase();
+        const embeddings = createEmbeddingsService(db);
+        const marketIndexService = createMarketIndexService(db, embeddings);
+        const platforms = options.platforms
+            ? options.platforms.split(',').map((p) => p.trim()).filter(Boolean)
+            : undefined;
+        const stats = marketIndexService.stats(platforms);
+        console.log('\nMarket Index Stats:');
+        console.log(`  Total: ${stats.total}`);
+        for (const [platform, count] of Object.entries(stats.byPlatform)) {
+            console.log(`  ${platform}: ${count}`);
+        }
+        if (stats.lastSyncAt) {
+            console.log(`\nLast Sync: ${stats.lastSyncAt.toISOString()}`);
+            if (stats.lastSyncIndexed !== undefined) {
+                console.log(`  Indexed: ${stats.lastSyncIndexed}`);
+            }
+            if (stats.lastSyncDurationMs !== undefined) {
+                console.log(`  Duration: ${stats.lastSyncDurationMs}ms`);
+            }
+            if (stats.lastPruned !== undefined) {
+                console.log(`  Pruned: ${stats.lastPruned}`);
+            }
+        }
+    });
+    marketIndex
+        .command('sync')
+        .description('Run a market index sync now')
+        .option('-p, --platforms <platforms>', 'Comma-separated platforms')
+        .option('-l, --limit <limit>', 'Limit per platform', (v) => Number.parseInt(v, 10))
+        .option('-s, --status <status>', 'Status: open|closed|settled|all')
+        .option('--include-sports', 'Include sports markets')
+        .option('--min-volume-24h <num>', 'Minimum 24h volume', (v) => Number.parseFloat(v))
+        .option('--min-liquidity <num>', 'Minimum liquidity', (v) => Number.parseFloat(v))
+        .option('--min-open-interest <num>', 'Minimum open interest', (v) => Number.parseFloat(v))
+        .option('--min-predictions <num>', 'Minimum predictions', (v) => Number.parseInt(v, 10))
+        .option('--exclude-resolved', 'Exclude resolved markets')
+        .option('--prune', 'Prune stale entries during sync')
+        .option('--stale-after-ms <ms>', 'Stale age threshold (ms)', (v) => Number.parseInt(v, 10))
+        .action(async (options) => {
+        const { initDatabase } = await Promise.resolve().then(() => __importStar(require('../../db')));
+        const { createEmbeddingsService } = await Promise.resolve().then(() => __importStar(require('../../embeddings')));
+        const { createMarketIndexService } = await Promise.resolve().then(() => __importStar(require('../../market-index')));
+        const db = await initDatabase();
+        const embeddings = createEmbeddingsService(db);
+        const marketIndexService = createMarketIndexService(db, embeddings);
+        const platforms = options.platforms
+            ? options.platforms.split(',').map((p) => p.trim()).filter(Boolean)
+            : undefined;
+        const result = await marketIndexService.sync({
+            platforms: platforms,
+            limitPerPlatform: options.limit,
+            status: options.status,
+            excludeSports: options.includeSports ? false : undefined,
+            minVolume24h: options.minVolume24h,
+            minLiquidity: options.minLiquidity,
+            minOpenInterest: options.minOpenInterest,
+            minPredictions: options.minPredictions,
+            excludeResolved: options.excludeResolved,
+            prune: options.prune,
+            staleAfterMs: options.staleAfterMs,
+        });
+        console.log('\nMarket Index Sync:');
+        console.log(`  Indexed: ${result.indexed}`);
+        for (const [platform, count] of Object.entries(result.byPlatform)) {
+            console.log(`  ${platform}: ${count}`);
+        }
+    });
+}
+// =============================================================================
+// PERMISSIONS COMMANDS
+// =============================================================================
+function createPermissionCommands(program) {
+    const permissions = program
+        .command('permissions')
+        .description('Manage permissions');
+    permissions
+        .command('list')
+        .description('List permission settings')
+        .option('-a, --agent <agentId>', 'Agent ID', 'default')
+        .action(async (options) => {
+        const agentId = options.agent || 'default';
+        const security = permissions_1.execApprovals.getSecurityConfig(agentId);
+        const allowlist = permissions_1.execApprovals.getAllowlist(agentId);
+        console.log('\nPermission settings:');
+        console.log(`  Agent: ${agentId}`);
+        console.log(`  Exec mode: ${security.mode}`);
+        console.log(`  Ask mode: ${security.ask}`);
+        console.log(`  Approval timeout: ${security.approvalTimeout ?? 60000}ms`);
+        console.log(`  Fallback mode: ${security.fallbackMode ?? 'deny'}`);
+        console.log('\nAllowlist:');
+        if (allowlist.length === 0) {
+            console.log('  (empty)');
+        }
+        else {
+            for (const entry of allowlist) {
+                const when = entry.addedAt ? new Date(entry.addedAt).toLocaleString() : '-';
+                console.log(`  ${entry.id}  ${entry.type}  ${entry.pattern}  (${when})`);
+            }
+        }
+    });
+    permissions
+        .command('allow <pattern>')
+        .description('Add command to allowlist')
+        .option('-a, --agent <agentId>', 'Agent ID', 'default')
+        .option('-t, --type <type>', 'Match type: prefix|glob|regex', 'prefix')
+        .option('-d, --description <desc>', 'Description/reason')
+        .option('--by <name>', 'Added by')
+        .action(async (pattern, options) => {
+        const entry = permissions_1.execApprovals.addToAllowlist(options.agent || 'default', pattern, options.type || 'prefix', {
+            description: options.description,
+            addedBy: options.by,
+        });
+        console.log(`Added to allowlist: ${entry.id} (${entry.type}) ${entry.pattern}`);
+    });
+    permissions
+        .command('remove <entryId>')
+        .description('Remove allowlist entry')
+        .option('-a, --agent <agentId>', 'Agent ID', 'default')
+        .action(async (entryId, options) => {
+        const removed = permissions_1.execApprovals.removeFromAllowlist(options.agent || 'default', entryId);
+        if (removed) {
+            console.log(`Removed allowlist entry: ${entryId}`);
+        }
+        else {
+            console.log(`Entry not found: ${entryId}`);
+        }
+    });
+    permissions
+        .command('mode <mode>')
+        .description('Set exec security mode (deny|allowlist|full)')
+        .option('-a, --agent <agentId>', 'Agent ID', 'default')
+        .action(async (mode, options) => {
+        if (!['deny', 'allowlist', 'full'].includes(mode)) {
+            console.error('Invalid mode. Use: deny, allowlist, full');
+            process.exitCode = 1;
+            return;
+        }
+        permissions_1.execApprovals.setSecurityConfig(options.agent || 'default', { mode: mode });
+        console.log(`Set exec mode to ${mode}`);
+    });
+    permissions
+        .command('ask <mode>')
+        .description('Set approval ask mode (off|on-miss|always)')
+        .option('-a, --agent <agentId>', 'Agent ID', 'default')
+        .action(async (mode, options) => {
+        if (!['off', 'on-miss', 'always'].includes(mode)) {
+            console.error('Invalid ask mode. Use: off, on-miss, always');
+            process.exitCode = 1;
+            return;
+        }
+        permissions_1.execApprovals.setSecurityConfig(options.agent || 'default', { ask: mode });
+        console.log(`Set ask mode to ${mode}`);
+    });
+    permissions
+        .command('pending')
+        .description('List pending approval requests')
+        .action(async () => {
+        const pending = permissions_1.execApprovals.getPendingApprovalsFromDisk();
+        if (pending.length === 0) {
+            console.log('No pending approvals.');
+            return;
+        }
+        console.log('\nPending approvals:\n');
+        console.log('ID\t\tCommand\t\tAgent\t\tExpires');
+        console.log('─'.repeat(80));
+        for (const req of pending) {
+            const expires = req.expiresAt ? req.expiresAt.toLocaleString() : '-';
+            console.log(`${req.id}\t${req.command}\t${req.agentId}\t${expires}`);
+            if (req.requester) {
+                console.log(`  requested by ${req.requester.userId} (${req.requester.channel})`);
+            }
+        }
+    });
+    permissions
+        .command('approve <requestId>')
+        .description('Approve a pending request')
+        .option('--always', 'Allow always (adds to allowlist)')
+        .option('--by <name>', 'Approver name')
+        .action(async (requestId, options) => {
+        const decision = options.always ? 'allow-always' : 'allow-once';
+        const ok = permissions_1.execApprovals.recordDecision(requestId, decision, options.by);
+        if (!ok) {
+            console.log(`Request not found: ${requestId}`);
+            process.exitCode = 1;
+            return;
+        }
+        console.log(`Approved ${requestId} (${decision})`);
+    });
+    permissions
+        .command('deny <requestId>')
+        .description('Deny a pending request')
+        .option('--by <name>', 'Approver name')
+        .action(async (requestId, options) => {
+        const ok = permissions_1.execApprovals.recordDecision(requestId, 'deny', options.by);
+        if (!ok) {
+            console.log(`Request not found: ${requestId}`);
+            process.exitCode = 1;
+            return;
+        }
+        console.log(`Denied ${requestId}`);
+    });
+}
+// =============================================================================
+// USAGE COMMANDS
+// =============================================================================
+function createUsageCommands(program) {
+    const usage = program
+        .command('usage')
+        .description('View usage statistics');
+    const withDb = async (fn) => {
+        const db = (0, db_1.createDatabase)();
+        (0, migrations_1.createMigrationRunner)(db).migrate();
+        try {
+            return await fn(db);
+        }
+        finally {
+            db.close();
+        }
+    };
+    const formatCost = (cost) => cost < 0.01 ? `$${cost.toFixed(6)}` : `$${cost.toFixed(4)}`;
+    usage
+        .command('summary')
+        .description('Show usage summary')
+        .option('-d, --days <days>', 'Number of days', '7')
+        .action(async (options) => {
+        await withDb((db) => {
+            const days = parseInt(options.days || '7', 10);
+            const since = new Date();
+            since.setDate(since.getDate() - days);
+            const sinceStr = since.toISOString();
+            try {
+                const results = db.query(`
+            SELECT
+              COUNT(*) as requests,
+              COALESCE(SUM(input_tokens), 0) as input_tokens,
+              COALESCE(SUM(output_tokens), 0) as output_tokens,
+              COALESCE(SUM(estimated_cost), 0) as cost
+            FROM usage_records
+            WHERE timestamp >= ?
+          `, [sinceStr]);
+                const result = results[0];
+                if (!result || result.requests === 0) {
+                    console.log(`\nUsage summary (last ${days} days):\n`);
+                    console.log('  No usage data recorded');
+                    console.log('\n  Usage is tracked when the gateway is running.');
+                    return;
+                }
+                const totalTokens = result.input_tokens + result.output_tokens;
+                console.log(`\nUsage summary (last ${days} days):\n`);
+                console.log(`  Total requests:    ${result.requests.toLocaleString()}`);
+                console.log(`  Input tokens:      ${result.input_tokens.toLocaleString()}`);
+                console.log(`  Output tokens:     ${result.output_tokens.toLocaleString()}`);
+                console.log(`  Total tokens:      ${totalTokens.toLocaleString()}`);
+                console.log(`  Estimated cost:    ${formatCost(result.cost)}`);
+            }
+            catch (e) {
+                console.log('\nUsage table not initialized - run the gateway first');
+            }
+        });
+    });
+    usage
+        .command('by-model')
+        .description('Show usage by model')
+        .option('-d, --days <days>', 'Number of days', '7')
+        .action(async (options) => {
+        await withDb((db) => {
+            const days = parseInt(options.days || '7', 10);
+            const since = new Date();
+            since.setDate(since.getDate() - days);
+            const sinceStr = since.toISOString();
+            try {
+                const rows = db.query(`
+            SELECT
+              model,
+              COUNT(*) as requests,
+              SUM(input_tokens) as input_tokens,
+              SUM(output_tokens) as output_tokens,
+              SUM(estimated_cost) as cost
+            FROM usage_records
+            WHERE timestamp >= ?
+            GROUP BY model
+            ORDER BY cost DESC
+          `, [sinceStr]);
+                if (rows.length === 0) {
+                    console.log('\nUsage by model:\n');
+                    console.log('  No usage data recorded');
+                    return;
+                }
+                console.log(`\nUsage by model (last ${days} days):\n`);
+                console.log('Model\t\t\t\t\tRequests\tTokens\t\tCost');
+                console.log('─'.repeat(85));
+                for (const row of rows) {
+                    const model = row.model.length > 30 ? row.model.slice(0, 27) + '...' : row.model.padEnd(30);
+                    const tokens = (row.input_tokens + row.output_tokens).toLocaleString();
+                    console.log(`${model}\t${row.requests}\t\t${tokens.padEnd(12)}\t${formatCost(row.cost)}`);
+                }
+            }
+            catch (e) {
+                console.log('\nUsage table not initialized - run the gateway first');
+            }
+        });
+    });
+    usage
+        .command('by-user')
+        .description('Show usage by user')
+        .option('-d, --days <days>', 'Number of days', '7')
+        .option('-l, --limit <n>', 'Limit results', '20')
+        .action(async (options) => {
+        await withDb((db) => {
+            const days = parseInt(options.days || '7', 10);
+            const limit = parseInt(options.limit || '20', 10);
+            const since = new Date();
+            since.setDate(since.getDate() - days);
+            const sinceStr = since.toISOString();
+            try {
+                const rows = db.query(`
+            SELECT
+              user_id,
+              COUNT(*) as requests,
+              SUM(input_tokens) as input_tokens,
+              SUM(output_tokens) as output_tokens,
+              SUM(estimated_cost) as cost
+            FROM usage_records
+            WHERE timestamp >= ?
+            GROUP BY user_id
+            ORDER BY cost DESC
+            LIMIT ?
+          `, [sinceStr, limit]);
+                if (rows.length === 0) {
+                    console.log('\nUsage by user:\n');
+                    console.log('  No usage data recorded');
+                    return;
+                }
+                console.log(`\nUsage by user (last ${days} days, top ${limit}):\n`);
+                console.log('User ID\t\t\t\t\tRequests\tTokens\t\tCost');
+                console.log('─'.repeat(85));
+                for (const row of rows) {
+                    const userId = row.user_id.length > 28 ? row.user_id.slice(0, 25) + '...' : row.user_id.padEnd(28);
+                    const tokens = (row.input_tokens + row.output_tokens).toLocaleString();
+                    console.log(`${userId}\t${row.requests}\t\t${tokens.padEnd(12)}\t${formatCost(row.cost)}`);
+                }
+            }
+            catch (e) {
+                console.log('\nUsage table not initialized - run the gateway first');
+            }
+        });
+    });
+    usage
+        .command('export')
+        .description('Export usage data')
+        .option('-o, --output <file>', 'Output file')
+        .option('-d, --days <days>', 'Number of days to export', '30')
+        .option('--csv', 'Export as CSV instead of JSON')
+        .action(async (options) => {
+        await withDb((db) => {
+            const days = parseInt(options.days || '30', 10);
+            const since = new Date();
+            since.setDate(since.getDate() - days);
+            const sinceStr = since.toISOString();
+            try {
+                const rows = db.query(`
+            SELECT
+              id, session_id, user_id, model,
+              input_tokens, output_tokens, total_tokens,
+              estimated_cost, timestamp
+            FROM usage_records
+            WHERE timestamp >= ?
+            ORDER BY timestamp DESC
+          `, [sinceStr]);
+                if (rows.length === 0) {
+                    console.log('No usage data to export');
+                    return;
+                }
+                const ext = options.csv ? 'csv' : 'json';
+                const output = options.output || `usage-export-${new Date().toISOString().slice(0, 10)}.${ext}`;
+                if (options.csv) {
+                    const headers = ['id', 'session_id', 'user_id', 'model', 'input_tokens', 'output_tokens', 'total_tokens', 'estimated_cost', 'timestamp'];
+                    const csvContent = [
+                        headers.join(','),
+                        ...rows.map(row => headers.map(h => {
+                            const val = row[h];
+                            if (typeof val === 'string' && val.includes(','))
+                                return `"${val}"`;
+                            return val;
+                        }).join(','))
+                    ].join('\n');
+                    (0, fs_1.writeFileSync)(output, csvContent);
+                }
+                else {
+                    (0, fs_1.writeFileSync)(output, JSON.stringify(rows, null, 2));
+                }
+                console.log(`Exported ${rows.length} usage records to ${output}`);
+            }
+            catch (e) {
+                console.log('Usage table not initialized - run the gateway first');
+            }
+        });
+    });
+    usage
+        .command('today')
+        .description('Show today\'s usage')
+        .action(async () => {
+        await withDb((db) => {
+            const today = new Date().toISOString().slice(0, 10);
+            try {
+                const results = db.query(`
+            SELECT
+              COUNT(*) as requests,
+              COALESCE(SUM(input_tokens), 0) as input_tokens,
+              COALESCE(SUM(output_tokens), 0) as output_tokens,
+              COALESCE(SUM(estimated_cost), 0) as cost
+            FROM usage_records
+            WHERE timestamp >= ?
+          `, [today]);
+                const result = results[0];
+                if (!result || result.requests === 0) {
+                    console.log(`\nToday's usage (${today}):\n`);
+                    console.log('  No usage yet today');
+                    return;
+                }
+                console.log(`\nToday's usage (${today}):\n`);
+                console.log(`  Requests:      ${result.requests.toLocaleString()}`);
+                console.log(`  Input tokens:  ${result.input_tokens.toLocaleString()}`);
+                console.log(`  Output tokens: ${result.output_tokens.toLocaleString()}`);
+                console.log(`  Total tokens:  ${(result.input_tokens + result.output_tokens).toLocaleString()}`);
+                console.log(`  Cost:          ${formatCost(result.cost)}`);
+            }
+            catch (e) {
+                console.log('Usage table not initialized - run the gateway first');
+            }
+        });
+    });
+}
+// =============================================================================
+// INIT COMMAND
+// =============================================================================
+function createInitCommand(program) {
+    program
+        .command('init')
+        .description('Initialize Clodds in current directory')
+        .option('-f, --force', 'Overwrite existing config')
+        .action(async (options) => {
+        const configPath = (0, path_1.join)(process.cwd(), '.clodds.json');
+        if ((0, fs_1.existsSync)(configPath) && !options.force) {
+            console.log('Clodds already initialized. Use --force to overwrite.');
+            return;
+        }
+        const defaultConfig = {
+            name: 'clodds-project',
+            version: '0.1.0',
+            model: 'claude-3-5-sonnet-20241022',
+            features: {
+                memory: true,
+                tools: true,
+                hooks: true,
+            },
+        };
+        (0, fs_1.writeFileSync)(configPath, JSON.stringify(defaultConfig, null, 2));
+        console.log('Initialized Clodds project.');
+        console.log(`Config written to ${configPath}`);
+    });
+}
+// =============================================================================
+// UPGRADE COMMAND
+// =============================================================================
+function createUpgradeCommand(program) {
+    program
+        .command('upgrade')
+        .description('Upgrade Clodds to latest version')
+        .option('--check', 'Check for updates only')
+        .action(async (options) => {
+        console.log('Checking for updates...');
+        if (options.check) {
+            console.log('Current version: 0.1.0');
+            console.log('Latest version: 0.1.0');
+            console.log('You are up to date!');
+        }
+        else {
+            console.log('To upgrade, run: npm install -g clodds@latest');
+        }
+    });
+}
+// =============================================================================
+// LOGIN COMMAND
+// =============================================================================
+function createLoginCommand(program) {
+    program
+        .command('login')
+        .description('Login to Clodds services')
+        .option('-p, --provider <provider>', 'Provider (anthropic, openai)')
+        .action(async (options) => {
+        const provider = options.provider || 'anthropic';
+        console.log(`\nTo configure ${provider}:`);
+        console.log(`  clodds config set ${provider}.apiKey YOUR_API_KEY`);
+    });
+}
+// =============================================================================
+// LOGOUT COMMAND
+// =============================================================================
+function createLogoutCommand(program) {
+    program
+        .command('logout')
+        .description('Logout from Clodds services')
+        .option('-a, --all', 'Logout from all providers')
+        .action(async (options) => {
+        console.log('Logged out from Clodds services');
+    });
+}
+// =============================================================================
+// VERSION INFO
+// =============================================================================
+function createVersionCommand(program) {
+    program
+        .command('version')
+        .description('Show detailed version info')
+        .action(async () => {
+        console.log('\nClodds Version Info\n');
+        console.log('  Version: 0.1.0');
+        console.log('  Node.js: ' + process.version);
+        console.log('  Platform: ' + process.platform);
+        console.log('  Arch: ' + process.arch);
+    });
+}
+// =============================================================================
+// WHATSAPP COMMANDS
+// =============================================================================
+function createWhatsAppCommands(program) {
+    const whatsapp = program
+        .command('whatsapp')
+        .description('WhatsApp channel utilities');
+    whatsapp
+        .command('login')
+        .description('Link a WhatsApp account via QR code')
+        .option('-a, --account <id>', 'Account ID from channels.whatsapp.accounts')
+        .option('--auth-dir <path>', 'Override auth directory')
+        .option('--timeout <ms>', 'Timeout in milliseconds', (value) => Number.parseInt(value, 10))
+        .action(async (options) => {
+        const config = await (0, config_1.loadConfig)();
+        const whatsappConfig = config.channels?.whatsapp;
+        if (!whatsappConfig) {
+            console.log('WhatsApp is not configured in your config file.');
+            return;
+        }
+        const resolved = (0, index_1.resolveWhatsAppAuthDir)(whatsappConfig, {
+            accountId: options.account,
+            authDirOverride: options.authDir,
+        });
+        const timeoutMs = Number.isFinite(options.timeout) ? options.timeout : undefined;
+        console.log(`Starting WhatsApp login for account "${resolved.accountId}"...`);
+        console.log(`Auth dir: ${resolved.authDir}`);
+        const result = await (0, index_1.loginWhatsAppWithQr)(resolved.authDir, timeoutMs);
+        if (result.connected) {
+            console.log(`WhatsApp linked${result.jid ? ` (${result.jid})` : ''}.`);
+        }
+        else {
+            console.log('WhatsApp login timed out or failed.');
+        }
+    });
+}
+// =============================================================================
+// CREDS TEST COMMAND
+// =============================================================================
+function createCredsCommands(program) {
+    const creds = program
+        .command('creds')
+        .description('Test and validate API credentials');
+    creds
+        .command('test [platform]')
+        .description('Test API credentials for a platform')
+        .action(async (platform) => {
+        console.log('\n🔑 Credential Validation\n');
+        const results = [];
+        // Test Anthropic
+        const anthropicKey = process.env.ANTHROPIC_API_KEY;
+        if (!platform || platform === 'anthropic') {
+            if (!anthropicKey) {
+                results.push({
+                    name: 'Anthropic API',
+                    status: 'fail',
+                    message: 'ANTHROPIC_API_KEY not set',
+                    fix: 'Get key from: https://console.anthropic.com',
+                });
+            }
+            else if (!anthropicKey.startsWith('sk-ant-')) {
+                results.push({
+                    name: 'Anthropic API',
+                    status: 'warn',
+                    message: 'Key format looks wrong (should start with sk-ant-)',
+                    fix: 'Verify key at: https://console.anthropic.com',
+                });
+            }
+            else {
+                // Test the key
+                try {
+                    const response = await fetch('https://api.anthropic.com/v1/messages', {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                            'x-api-key': anthropicKey,
+                            'anthropic-version': '2023-06-01',
+                        },
+                        body: JSON.stringify({
+                            model: 'claude-3-haiku-20240307',
+                            max_tokens: 1,
+                            messages: [{ role: 'user', content: 'hi' }],
+                        }),
+                    });
+                    if (response.ok) {
+                        results.push({
+                            name: 'Anthropic API',
+                            status: 'pass',
+                            message: 'Key valid and working',
+                        });
+                    }
+                    else if (response.status === 401) {
+                        results.push({
+                            name: 'Anthropic API',
+                            status: 'fail',
+                            message: 'Invalid API key',
+                            fix: 'Check key at: https://console.anthropic.com',
+                        });
+                    }
+                    else if (response.status === 429) {
+                        results.push({
+                            name: 'Anthropic API',
+                            status: 'warn',
+                            message: 'Rate limited (but key is valid)',
+                        });
+                    }
+                    else {
+                        results.push({
+                            name: 'Anthropic API',
+                            status: 'warn',
+                            message: `Unexpected response: ${response.status}`,
+                        });
+                    }
+                }
+                catch (e) {
+                    results.push({
+                        name: 'Anthropic API',
+                        status: 'warn',
+                        message: `Network error: ${e.message}`,
+                        fix: 'Check internet connection',
+                    });
+                }
+            }
+        }
+        // Test Polymarket
+        if (!platform || platform === 'polymarket') {
+            const polyKey = process.env.POLY_API_KEY;
+            const polySecret = process.env.POLY_API_SECRET;
+            const polyPass = process.env.POLY_API_PASSPHRASE;
+            const polyPrivate = process.env.POLY_PRIVATE_KEY;
+            if (!polyKey && !polySecret && !polyPass) {
+                results.push({
+                    name: 'Polymarket',
+                    status: 'warn',
+                    message: 'Not configured (optional)',
+                    fix: 'Get keys from: https://polymarket.com/settings/api',
+                });
+            }
+            else if (!polyKey || !polySecret || !polyPass) {
+                results.push({
+                    name: 'Polymarket',
+                    status: 'fail',
+                    message: 'Incomplete credentials (need API key, secret, and passphrase)',
+                    fix: 'Set all: POLY_API_KEY, POLY_API_SECRET, POLY_API_PASSPHRASE',
+                });
+            }
+            else {
+                // Test fetch markets (read-only, no auth needed)
+                try {
+                    const response = await fetch('https://clob.polymarket.com/markets?limit=1');
+                    if (response.ok) {
+                        results.push({
+                            name: 'Polymarket (read)',
+                            status: 'pass',
+                            message: 'Can fetch markets',
+                        });
+                    }
+                    else {
+                        results.push({
+                            name: 'Polymarket (read)',
+                            status: 'warn',
+                            message: `API returned ${response.status}`,
+                        });
+                    }
+                }
+                catch {
+                    results.push({
+                        name: 'Polymarket (read)',
+                        status: 'warn',
+                        message: 'Network error',
+                    });
+                }
+                // Check for trading capability
+                if (!polyPrivate) {
+                    results.push({
+                        name: 'Polymarket (trade)',
+                        status: 'warn',
+                        message: 'POLY_PRIVATE_KEY not set (cannot trade)',
+                        fix: 'Add your wallet private key to enable trading',
+                    });
+                }
+                else {
+                    results.push({
+                        name: 'Polymarket (trade)',
+                        status: 'pass',
+                        message: 'Trading credentials configured',
+                    });
+                }
+            }
+        }
+        // Test Kalshi
+        if (!platform || platform === 'kalshi') {
+            const kalshiKey = process.env.KALSHI_API_KEY;
+            const kalshiSecret = process.env.KALSHI_API_SECRET;
+            const kalshiEmail = process.env.KALSHI_EMAIL;
+            if (!kalshiKey && !kalshiEmail) {
+                results.push({
+                    name: 'Kalshi',
+                    status: 'warn',
+                    message: 'Not configured (optional)',
+                    fix: 'Get keys from: https://kalshi.com/account/api',
+                });
+            }
+            else if (kalshiKey && !kalshiSecret) {
+                results.push({
+                    name: 'Kalshi',
+                    status: 'fail',
+                    message: 'API key set but missing secret',
+                    fix: 'Set KALSHI_API_SECRET',
+                });
+            }
+            else if (kalshiKey) {
+                results.push({
+                    name: 'Kalshi',
+                    status: 'pass',
+                    message: 'API key credentials configured',
+                });
+            }
+            else if (kalshiEmail) {
+                results.push({
+                    name: 'Kalshi',
+                    status: 'warn',
+                    message: 'Using legacy email auth (API keys recommended)',
+                    fix: 'Switch to API keys: https://kalshi.com/account/api',
+                });
+            }
+        }
+        // Test Telegram
+        if (!platform || platform === 'telegram') {
+            const telegramToken = process.env.TELEGRAM_BOT_TOKEN;
+            if (!telegramToken) {
+                results.push({
+                    name: 'Telegram',
+                    status: 'warn',
+                    message: 'Not configured',
+                    fix: 'Get token from: https://t.me/BotFather',
+                });
+            }
+            else {
+                try {
+                    const response = await fetch(`https://api.telegram.org/bot${telegramToken}/getMe`);
+                    const data = await response.json();
+                    if (data.ok) {
+                        results.push({
+                            name: 'Telegram',
+                            status: 'pass',
+                            message: `Bot: @${data.result?.username}`,
+                        });
+                    }
+                    else {
+                        results.push({
+                            name: 'Telegram',
+                            status: 'fail',
+                            message: 'Invalid bot token',
+                            fix: 'Check token with @BotFather',
+                        });
+                    }
+                }
+                catch {
+                    results.push({
+                        name: 'Telegram',
+                        status: 'warn',
+                        message: 'Network error testing token',
+                    });
+                }
+            }
+        }
+        // Test Discord
+        if (!platform || platform === 'discord') {
+            const discordToken = process.env.DISCORD_BOT_TOKEN;
+            if (!discordToken) {
+                results.push({
+                    name: 'Discord',
+                    status: 'warn',
+                    message: 'Not configured',
+                    fix: 'Get token from: https://discord.com/developers/applications',
+                });
+            }
+            else {
+                try {
+                    const response = await fetch('https://discord.com/api/v10/users/@me', {
+                        headers: { Authorization: `Bot ${discordToken}` },
+                    });
+                    if (response.ok) {
+                        const data = await response.json();
+                        results.push({
+                            name: 'Discord',
+                            status: 'pass',
+                            message: `Bot: ${data.username}`,
+                        });
+                    }
+                    else if (response.status === 401) {
+                        results.push({
+                            name: 'Discord',
+                            status: 'fail',
+                            message: 'Invalid bot token',
+                            fix: 'Check token at: https://discord.com/developers/applications',
+                        });
+                    }
+                    else {
+                        results.push({
+                            name: 'Discord',
+                            status: 'warn',
+                            message: `API returned ${response.status}`,
+                        });
+                    }
+                }
+                catch {
+                    results.push({
+                        name: 'Discord',
+                        status: 'warn',
+                        message: 'Network error testing token',
+                    });
+                }
+            }
+        }
+        // Test OpenAI
+        if (!platform || platform === 'openai') {
+            const openaiKey = process.env.OPENAI_API_KEY;
+            if (!openaiKey) {
+                results.push({
+                    name: 'OpenAI',
+                    status: 'warn',
+                    message: 'Not configured (optional)',
+                    fix: 'Get key from: https://platform.openai.com/api-keys',
+                });
+            }
+            else {
+                try {
+                    const response = await fetch('https://api.openai.com/v1/models', {
+                        headers: { Authorization: `Bearer ${openaiKey}` },
+                    });
+                    if (response.ok) {
+                        results.push({ name: 'OpenAI', status: 'pass', message: 'Key valid' });
+                    }
+                    else if (response.status === 401) {
+                        results.push({ name: 'OpenAI', status: 'fail', message: 'Invalid API key', fix: 'Check at platform.openai.com' });
+                    }
+                    else {
+                        results.push({ name: 'OpenAI', status: 'warn', message: `HTTP ${response.status}` });
+                    }
+                }
+                catch {
+                    results.push({ name: 'OpenAI', status: 'warn', message: 'Network error' });
+                }
+            }
+        }
+        // Test Slack
+        if (!platform || platform === 'slack') {
+            const slackToken = process.env.SLACK_BOT_TOKEN;
+            if (!slackToken) {
+                results.push({
+                    name: 'Slack',
+                    status: 'warn',
+                    message: 'Not configured (optional)',
+                    fix: 'Get token from: https://api.slack.com/apps',
+                });
+            }
+            else {
+                try {
+                    const response = await fetch('https://slack.com/api/auth.test', {
+                        headers: { Authorization: `Bearer ${slackToken}` },
+                    });
+                    const data = await response.json();
+                    if (data.ok) {
+                        results.push({ name: 'Slack', status: 'pass', message: `${data.user} @ ${data.team}` });
+                    }
+                    else {
+                        results.push({ name: 'Slack', status: 'fail', message: data.error ?? 'Invalid token', fix: 'Check at api.slack.com/apps' });
+                    }
+                }
+                catch {
+                    results.push({ name: 'Slack', status: 'warn', message: 'Network error' });
+                }
+            }
+        }
+        // Display results
+        const icons = { pass: '✅', warn: '⚠️ ', fail: '❌' };
+        for (const result of results) {
+            console.log(`${icons[result.status]} ${result.name}: ${result.message}`);
+            if (result.fix) {
+                console.log(`   Fix: ${result.fix}`);
+            }
+        }
+        const passed = results.filter(r => r.status === 'pass').length;
+        const warned = results.filter(r => r.status === 'warn').length;
+        const failed = results.filter(r => r.status === 'fail').length;
+        console.log(`\nSummary: ${passed} passed, ${warned} warnings, ${failed} failed`);
+        if (failed > 0) {
+            console.log('\n💡 Run `clodds doctor` for full system diagnostics');
+            process.exitCode = 1;
+        }
+    });
+}
+// =============================================================================
+// LOCALE COMMANDS
+// =============================================================================
+function createLocaleCommands(program) {
+    const locale = program
+        .command('locale')
+        .description('Manage language/locale settings');
+    locale
+        .command('list')
+        .description('List supported languages')
+        .action(async () => {
+        const { getSupportedLocales, getLocale } = await Promise.resolve().then(() => __importStar(require('../../i18n/index')));
+        const current = getLocale();
+        const locales = getSupportedLocales();
+        console.log('\n📍 Supported Languages\n');
+        for (const loc of locales) {
+            const marker = loc.code === current ? ' ← current' : '';
+            console.log(`  ${loc.code}  ${loc.nativeName.padEnd(10)} (${loc.name})${marker}`);
+        }
+        console.log('\nSet with: clodds locale set <code>');
+        console.log('Or: CLODDS_LOCALE=<code> in .env\n');
+    });
+    locale
+        .command('get')
+        .description('Show current locale')
+        .action(async () => {
+        const { getLocale, getSupportedLocales } = await Promise.resolve().then(() => __importStar(require('../../i18n/index')));
+        const current = getLocale();
+        const info = getSupportedLocales().find(l => l.code === current);
+        console.log(`\nCurrent locale: ${current} (${info?.nativeName || current})\n`);
+    });
+    locale
+        .command('set <code>')
+        .description('Set locale (e.g., en, zh, es, ja)')
+        .action(async (code) => {
+        const { setLocale, isLocaleSupported, getSupportedLocales } = await Promise.resolve().then(() => __importStar(require('../../i18n/index')));
+        if (!isLocaleSupported(code)) {
+            console.error(`\n❌ Unsupported locale: ${code}`);
+            console.log('\nSupported locales:');
+            for (const loc of getSupportedLocales()) {
+                console.log(`  ${loc.code}  ${loc.nativeName}`);
+            }
+            process.exit(1);
+        }
+        // Save to config
+        const configPath = (0, path_1.join)((0, os_1.homedir)(), '.clodds', 'config.json');
+        let config = {};
+        if ((0, fs_1.existsSync)(configPath)) {
+            config = JSON.parse((0, fs_1.readFileSync)(configPath, 'utf-8'));
+        }
+        config.locale = code.toLowerCase();
+        const configDir = (0, path_1.join)((0, os_1.homedir)(), '.clodds');
+        if (!(0, fs_1.existsSync)(configDir)) {
+            (0, fs_1.mkdirSync)(configDir, { recursive: true });
+        }
+        (0, fs_1.writeFileSync)(configPath, JSON.stringify(config, null, 2));
+        setLocale(code);
+        const info = getSupportedLocales().find(l => l.code === code.toLowerCase());
+        console.log(`\n✅ Locale set to: ${code} (${info?.nativeName || code})\n`);
+    });
+    locale
+        .command('test [key]')
+        .description('Test translation (default: welcome.message)')
+        .action(async (key) => {
+        const { t, getLocale } = await Promise.resolve().then(() => __importStar(require('../../i18n/index')));
+        const testKey = key || 'welcome.message';
+        const result = t(testKey);
+        console.log(`\nLocale: ${getLocale()}`);
+        console.log(`Key: ${testKey}`);
+        console.log(`Result: ${result}\n`);
+    });
+}
+// =============================================================================
+// LEDGER COMMANDS
+// =============================================================================
+function createLedgerCommands(program) {
+    const ledger = program
+        .command('ledger')
+        .description('Trade ledger - decision audit trail');
+    const withDb = async (fn) => {
+        const db = (0, db_1.createDatabase)();
+        (0, migrations_1.createMigrationRunner)(db).migrate();
+        try {
+            return await fn(db);
+        }
+        finally {
+            db.close();
+        }
+    };
+    ledger
+        .command('list [userId]')
+        .description('List recent decisions')
+        .option('-n, --limit <n>', 'Number of records', '20')
+        .option('-c, --category <cat>', 'Filter by category (trade/copy/arbitrage/risk)')
+        .option('-d, --decision <dec>', 'Filter by decision (approved/rejected/blocked)')
+        .option('-p, --platform <plt>', 'Filter by platform')
+        .action(async (userId, options) => {
+        await withDb(async (db) => {
+            const { LedgerStorage } = await Promise.resolve().then(() => __importStar(require('../../ledger/storage')));
+            const storage = new LedgerStorage(db);
+            storage.init();
+            const uid = userId || 'default';
+            const records = storage.list(uid, {
+                limit: parseInt(options?.limit || '20', 10),
+                category: options?.category,
+                decision: options?.decision,
+                platform: options?.platform,
+            });
+            if (records.length === 0) {
+                console.log('\nNo decisions found\n');
+                return;
+            }
+            console.log(`\n📒 Trade Ledger (${records.length} decisions)\n`);
+            const { formatDecision } = await Promise.resolve().then(() => __importStar(require('../../ledger/index')));
+            for (const record of records) {
+                console.log(formatDecision(record));
+            }
+        });
+    });
+    ledger
+        .command('stats [userId]')
+        .description('Show decision statistics')
+        .option('-p, --period <p>', 'Period (24h/7d/30d/90d/all)', '7d')
+        .option('-c, --category <cat>', 'Filter by category')
+        .action(async (userId, options) => {
+        await withDb(async (db) => {
+            const { LedgerStorage } = await Promise.resolve().then(() => __importStar(require('../../ledger/storage')));
+            const storage = new LedgerStorage(db);
+            storage.init();
+            const uid = userId || 'default';
+            const stats = storage.stats(uid, {
+                period: options?.period,
+                category: options?.category,
+            });
+            const { formatStats } = await Promise.resolve().then(() => __importStar(require('../../ledger/index')));
+            console.log('\n' + formatStats(stats));
+        });
+    });
+    ledger
+        .command('calibration [userId]')
+        .description('Show confidence calibration')
+        .action(async (userId) => {
+        await withDb(async (db) => {
+            const { LedgerStorage } = await Promise.resolve().then(() => __importStar(require('../../ledger/storage')));
+            const storage = new LedgerStorage(db);
+            storage.init();
+            const uid = userId || 'default';
+            const cal = storage.calibration(uid);
+            console.log('\n📊 Confidence Calibration\n');
+            console.log(`Overall accuracy: ${cal.overallAccuracy.toFixed(1)}% (${cal.totalWithOutcome} decisions with outcome)\n`);
+            if (cal.totalWithOutcome > 0) {
+                console.log('By confidence bucket:');
+                for (const bucket of cal.buckets) {
+                    if (bucket.count > 0) {
+                        const bar = '█'.repeat(Math.round(bucket.accuracyRate / 10));
+                        console.log(`  ${bucket.range.padEnd(8)} ${bucket.accuracyRate.toFixed(0).padStart(3)}% ${bar} (${bucket.count} decisions)`);
+                    }
+                }
+            }
+            console.log('');
+        });
+    });
+    ledger
+        .command('export [userId]')
+        .description('Export decisions to file')
+        .option('-f, --format <fmt>', 'Format (json/csv)', 'json')
+        .option('-o, --output <file>', 'Output file')
+        .action(async (userId, options) => {
+        await withDb(async (db) => {
+            const { LedgerStorage } = await Promise.resolve().then(() => __importStar(require('../../ledger/storage')));
+            const storage = new LedgerStorage(db);
+            storage.init();
+            const uid = userId || 'default';
+            const format = (options?.format || 'json');
+            const data = storage.export(uid, format);
+            const output = options?.output || `ledger-${uid}-${Date.now()}.${format}`;
+            (0, fs_1.writeFileSync)(output, data);
+            console.log(`\n✅ Exported to ${output}\n`);
+        });
+    });
+    ledger
+        .command('prune')
+        .description('Delete old decisions')
+        .option('-d, --days <n>', 'Retention days', '90')
+        .option('-y, --yes', 'Skip confirmation')
+        .action(async (options) => {
+        const days = parseInt(options.days || '90', 10);
+        if (!options.yes) {
+            console.log(`\n⚠️  This will delete decisions older than ${days} days.`);
+            console.log('Run with --yes to confirm\n');
+            return;
+        }
+        await withDb(async (db) => {
+            const { LedgerStorage } = await Promise.resolve().then(() => __importStar(require('../../ledger/storage')));
+            const storage = new LedgerStorage(db);
+            storage.init();
+            const count = storage.prune(days);
+            console.log(`\n🗑️  Pruned ${count} old decisions\n`);
+        });
+    });
+    ledger
+        .command('verify <id>')
+        .description('Verify decision hash integrity')
+        .action(async (id) => {
+        await withDb(async (db) => {
+            const { LedgerStorage } = await Promise.resolve().then(() => __importStar(require('../../ledger/storage')));
+            const { verifyHash } = await Promise.resolve().then(() => __importStar(require('../../ledger/hash')));
+            const storage = new LedgerStorage(db);
+            storage.init();
+            const record = storage.get(id);
+            if (!record) {
+                console.log(`\n❌ Decision not found: ${id}\n`);
+                process.exitCode = 1;
+                return;
+            }
+            if (!record.hash) {
+                console.log(`\n⚠️  No hash stored for decision ${id.slice(0, 8)}\n`);
+                console.log('Enable hashIntegrity in ledger config to store hashes.\n');
+                return;
+            }
+            const valid = verifyHash(record, record.hash);
+            if (valid) {
+                console.log(`\n✅ Hash verified: ${record.hash.slice(0, 16)}...\n`);
+            }
+            else {
+                console.log(`\n❌ Hash mismatch - record may have been tampered with\n`);
+                process.exitCode = 1;
+            }
+        });
+    });
+    ledger
+        .command('config')
+        .description('Show ledger configuration')
+        .action(async () => {
+        const configPath = (0, path_1.join)((0, os_1.homedir)(), '.clodds', 'config.json');
+        let ledgerConfig = {
+            enabled: false,
+            captureAll: false,
+            hashIntegrity: false,
+            retentionDays: 90,
+            onchainAnchor: false,
+        };
+        if ((0, fs_1.existsSync)(configPath)) {
+            const data = JSON.parse((0, fs_1.readFileSync)(configPath, 'utf-8'));
+            ledgerConfig = { ...ledgerConfig, ...data.ledger };
+        }
+        console.log('\n📒 Trade Ledger Configuration\n');
+        console.log(`  enabled:        ${ledgerConfig.enabled ? '✅' : '❌'}`);
+        console.log(`  captureAll:     ${ledgerConfig.captureAll ? 'All tools' : 'Trading tools only'}`);
+        console.log(`  hashIntegrity:  ${ledgerConfig.hashIntegrity ? 'SHA-256 enabled' : 'Disabled'}`);
+        console.log(`  retentionDays:  ${ledgerConfig.retentionDays}`);
+        console.log(`  onchainAnchor:  ${ledgerConfig.onchainAnchor ? 'Enabled' : 'Disabled'}`);
+        console.log('\nEnable with: clodds config set ledger.enabled true\n');
+    });
+    ledger
+        .command('anchor <id>')
+        .description('Anchor decision hash to blockchain')
+        .option('-c, --chain <chain>', 'Chain to use (solana/polygon/base)', 'solana')
+        .action(async (id, options) => {
+        await withDb(async (db) => {
+            const { LedgerStorage } = await Promise.resolve().then(() => __importStar(require('../../ledger/storage')));
+            const { createAnchorService } = await Promise.resolve().then(() => __importStar(require('../../ledger/anchor')));
+            const storage = new LedgerStorage(db);
+            storage.init();
+            const record = storage.get(id);
+            if (!record) {
+                console.log(`\n❌ Decision not found: ${id}\n`);
+                process.exitCode = 1;
+                return;
+            }
+            if (!record.hash) {
+                console.log(`\n⚠️  No hash stored for decision ${id.slice(0, 8)}`);
+                console.log('Enable hashIntegrity in ledger config first.\n');
+                return;
+            }
+            const chain = (options.chain || 'solana');
+            console.log(`\n⏳ Anchoring to ${chain}...`);
+            const anchor = createAnchorService({ chain });
+            const result = await anchor.anchor(record.hash);
+            if (result.success) {
+                console.log(`\n✅ Anchored to ${chain}`);
+                console.log(`   Hash: ${record.hash.slice(0, 16)}...`);
+                console.log(`   Tx: ${result.txHash}\n`);
+            }
+            else {
+                console.log(`\n❌ Anchor failed: ${result.error}\n`);
+                process.exitCode = 1;
+            }
+        });
+    });
+    ledger
+        .command('verify-anchor <txHash> <hash>')
+        .description('Verify an onchain anchor')
+        .option('-c, --chain <chain>', 'Chain to check (solana/polygon/base)', 'solana')
+        .action(async (txHash, hash, options) => {
+        const { verifyAnchor } = await Promise.resolve().then(() => __importStar(require('../../ledger/anchor')));
+        const chain = (options.chain || 'solana');
+        console.log(`\n⏳ Verifying on ${chain}...`);
+        const result = await verifyAnchor(txHash, hash, chain);
+        if (result.verified) {
+            console.log(`\n✅ Anchor verified on ${chain}`);
+            console.log(`   Tx: ${txHash}`);
+            console.log(`   Hash: ${hash.slice(0, 16)}...\n`);
+        }
+        else {
+            console.log(`\n❌ Verification failed: ${result.error}\n`);
+            process.exitCode = 1;
+        }
+    });
+}
+// =============================================================================
+// BITTENSOR COMMANDS
+// =============================================================================
+function btcliExec(pythonPath, args, timeoutMs = 30_000) {
+    const result = (0, child_process_1.spawnSync)(pythonPath, ['-m', 'bittensor', ...args], {
+        encoding: 'utf-8',
+        timeout: timeoutMs,
+    });
+    return {
+        ok: result.status === 0,
+        stdout: (result.stdout ?? '').trim(),
+        stderr: (result.stderr ?? '').trim(),
+    };
+}
+function detectPython() {
+    for (const cmd of ['python3', 'python']) {
+        const r = (0, child_process_1.spawnSync)(cmd, ['--version'], { encoding: 'utf-8', timeout: 5_000 });
+        if (r.status === 0)
+            return cmd;
+    }
+    return null;
+}
+function hasBtcli(pythonPath) {
+    const r = (0, child_process_1.spawnSync)(pythonPath, ['-c', 'import bittensor; print(bittensor.__version__)'], {
+        encoding: 'utf-8',
+        timeout: 10_000,
+    });
+    return r.status === 0;
+}
+function createBittensorCommands(program) {
+    const bittensor = program
+        .command('bittensor')
+        .alias('tao')
+        .description('Bittensor subnet mining management');
+    // ── setup: full onboarding wizard ──────────────────────────────────────────
+    bittensor
+        .command('setup')
+        .description('One-command setup: installs btcli, creates wallet, configures Clodds')
+        .option('--wallet-name <name>', 'Wallet name', 'default')
+        .option('--skip-install', 'Skip btcli installation')
+        .action(async (options) => {
+        const walletName = options.walletName ?? 'default';
+        const pythonEnv = process.env.BITTENSOR_PYTHON_PATH;
+        console.log('\n=== Bittensor Mining Setup ===\n');
+        // Step 0: Choose network
+        const { createInterface } = await Promise.resolve().then(() => __importStar(require('readline')));
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        const ask = (prompt) => new Promise((resolve) => rl.question(prompt, (a) => resolve(a.trim())));
+        let network;
+        while (true) {
+            const choice = await ask('Network? (1) mainnet - real TAO, real earnings  (2) testnet - free to experiment\nChoose [1/2]: ');
+            if (choice === '1' || choice.toLowerCase() === 'mainnet') {
+                network = 'mainnet';
+                break;
+            }
+            else if (choice === '2' || choice.toLowerCase() === 'testnet') {
+                network = 'testnet';
+                break;
+            }
+            console.log('  Please enter 1 or 2.\n');
+        }
+        rl.close();
+        console.log(`\n  Selected: ${network}\n`);
+        // Step 1: Find Python
+        console.log('[1/5] Checking Python...');
+        const pythonPath = pythonEnv || detectPython();
+        if (!pythonPath) {
+            console.log('  Python 3 not found. Install it first:');
+            console.log('    macOS:  brew install python3');
+            console.log('    Ubuntu: sudo apt install python3 python3-pip');
+            console.log('    Windows: https://python.org/downloads\n');
+            process.exitCode = 1;
+            return;
+        }
+        const pyVer = (0, child_process_1.spawnSync)(pythonPath, ['--version'], { encoding: 'utf-8' });
+        console.log(`  Found: ${pyVer.stdout?.trim() || pythonPath}`);
+        // Step 2: Install btcli
+        console.log('\n[2/5] Checking btcli...');
+        if (hasBtcli(pythonPath)) {
+            const ver = (0, child_process_1.spawnSync)(pythonPath, ['-c', 'import bittensor; print(bittensor.__version__)'], { encoding: 'utf-8' });
+            console.log(`  Already installed: bittensor ${ver.stdout?.trim()}`);
+        }
+        else if (options.skipInstall) {
+            console.log('  btcli not found (skipped install)');
+        }
+        else {
+            console.log('  Installing bittensor (this takes 1-2 minutes)...');
+            const install = (0, child_process_1.spawnSync)(pythonPath, ['-m', 'pip', 'install', 'bittensor', '--quiet'], {
+                encoding: 'utf-8',
+                timeout: 180_000,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            if (install.status === 0) {
+                console.log('  Installed successfully');
+            }
+            else {
+                console.log(`  Installation failed: ${install.stderr?.slice(0, 200)}`);
+                console.log('  Try manually: pip install bittensor\n');
+                process.exitCode = 1;
+                return;
+            }
+        }
+        // Step 3: Create wallet
+        console.log('\n[3/5] Setting up wallet...');
+        const walletDir = (0, path_1.join)((0, os_1.homedir)(), '.bittensor', 'wallets', walletName);
+        const coldkeyPath = (0, path_1.join)(walletDir, 'coldkey');
+        if ((0, fs_1.existsSync)(coldkeyPath)) {
+            console.log(`  Wallet "${walletName}" already exists at ${walletDir}`);
+        }
+        else {
+            console.log(`  Creating wallet "${walletName}"...`);
+            // Create coldkey
+            const coldkey = btcliExec(pythonPath, [
+                'wallet', 'create',
+                '--wallet.name', walletName,
+                '--no_prompt',
+            ], 30_000);
+            if (coldkey.ok || (0, fs_1.existsSync)(coldkeyPath)) {
+                console.log('  Wallet created');
+            }
+            else {
+                // Try the newer btcli syntax
+                const coldkey2 = (0, child_process_1.spawnSync)(pythonPath, ['-m', 'bittensor.cli', 'wallet', 'create', '--wallet.name', walletName, '--no_prompt'], {
+                    encoding: 'utf-8',
+                    timeout: 30_000,
+                });
+                if (coldkey2.status === 0 || (0, fs_1.existsSync)(coldkeyPath)) {
+                    console.log('  Wallet created');
+                }
+                else {
+                    console.log('  Auto-create failed. Create manually:');
+                    console.log(`    btcli wallet create --wallet.name ${walletName}`);
+                }
+            }
+        }
+        // Show wallet address
+        const overview = btcliExec(pythonPath, [
+            'wallet', 'overview',
+            '--wallet.name', walletName,
+            '--no_prompt',
+        ], 15_000);
+        const addrMatch = overview.stdout.match(/coldkey[:\s]+(\w{48})/i)
+            || overview.stdout.match(/(5[A-Za-z0-9]{47})/);
+        if (addrMatch) {
+            console.log(`  Address: ${addrMatch[1]}`);
+        }
+        // Step 4: Write config
+        console.log('\n[4/5] Configuring Clodds...');
+        const cloddsDir = (0, path_1.join)((0, os_1.homedir)(), '.clodds');
+        const configPath = (0, path_1.join)(cloddsDir, 'clodds.json');
+        let existingConfig = {};
+        if ((0, fs_1.existsSync)(configPath)) {
+            try {
+                existingConfig = JSON.parse((0, fs_1.readFileSync)(configPath, 'utf-8'));
+            }
+            catch {
+                // fresh config
+            }
+        }
+        else {
+            (0, fs_1.mkdirSync)(cloddsDir, { recursive: true });
+        }
+        existingConfig.bittensor = {
+            enabled: true,
+            network,
+            coldkeyPath: (0, path_1.join)((0, os_1.homedir)(), '.bittensor', 'wallets', walletName, 'coldkey'),
+            pythonPath,
+        };
+        (0, fs_1.writeFileSync)(configPath, JSON.stringify(existingConfig, null, 2));
+        console.log(`  Written to ${configPath}`);
+        console.log(`  Network: ${network}`);
+        // Step 5: Summary
+        console.log('\n[5/5] Next steps:\n');
+        if (network === 'testnet') {
+            console.log('  You\'re on TESTNET - free to experiment, no real TAO needed.\n');
+            console.log('  Get testnet TAO:');
+            console.log('    btcli wallet faucet --wallet.name default --subtensor.network test\n');
+        }
+        else {
+            console.log('  You\'re on MAINNET - you need real TAO to register.\n');
+            if (addrMatch) {
+                console.log(`  Fund your wallet: send TAO to ${addrMatch[1]}`);
+                console.log('  Buy TAO: Binance, KuCoin, Gate.io, or MEXC\n');
+            }
+        }
+        console.log('  Register on a subnet (Chutes SN64 recommended):');
+        console.log('    clodds bittensor register 64\n');
+        console.log('  Then start Clodds:');
+        console.log('    clodds start\n');
+        console.log('  Monitor in chat:');
+        console.log('    /tao status');
+        console.log('    /tao earnings\n');
+    });
+    // ── wallet: show / create ──────────────────────────────────────────────────
+    const wallet = bittensor
+        .command('wallet')
+        .description('Wallet management');
+    wallet
+        .command('show')
+        .description('Show wallet address and balance')
+        .option('--name <name>', 'Wallet name', 'default')
+        .action(async (options) => {
+        const pythonPath = process.env.BITTENSOR_PYTHON_PATH || detectPython();
+        if (!pythonPath) {
+            console.log('\nPython not found. Run: clodds bittensor setup\n');
+            return;
+        }
+        const name = options.name ?? 'default';
+        console.log(`\nWallet: ${name}`);
+        const overview = btcliExec(pythonPath, [
+            'wallet', 'overview',
+            '--wallet.name', name,
+            '--no_prompt',
+        ], 15_000);
+        if (overview.ok) {
+            console.log(overview.stdout);
+        }
+        else {
+            console.log(`  Not found. Create: clodds bittensor setup\n`);
+        }
+    });
+    wallet
+        .command('create')
+        .description('Create a new Bittensor wallet')
+        .option('--name <name>', 'Wallet name', 'default')
+        .action(async (options) => {
+        const pythonPath = process.env.BITTENSOR_PYTHON_PATH || detectPython();
+        if (!pythonPath || !hasBtcli(pythonPath)) {
+            console.log('\nbtcli not found. Run: clodds bittensor setup\n');
+            return;
+        }
+        const name = options.name ?? 'default';
+        console.log(`\nCreating wallet "${name}"...`);
+        const result = btcliExec(pythonPath, [
+            'wallet', 'create',
+            '--wallet.name', name,
+            '--no_prompt',
+        ], 30_000);
+        if (result.ok) {
+            console.log('Wallet created successfully.');
+            console.log(result.stdout);
+        }
+        else {
+            console.log(`Failed: ${result.stderr || result.stdout}`);
+        }
+        console.log('');
+    });
+    wallet
+        .command('balance')
+        .description('Check TAO balance')
+        .option('--name <name>', 'Wallet name', 'default')
+        .action(async (options) => {
+        const pythonPath = process.env.BITTENSOR_PYTHON_PATH || detectPython();
+        if (!pythonPath || !hasBtcli(pythonPath)) {
+            console.log('\nbtcli not found. Run: clodds bittensor setup\n');
+            return;
+        }
+        const result = btcliExec(pythonPath, [
+            'wallet', 'balance',
+            '--wallet.name', options.name ?? 'default',
+            '--no_prompt',
+        ], 15_000);
+        console.log(result.ok ? `\n${result.stdout}\n` : `\nFailed: ${result.stderr}\n`);
+    });
+    // ── register: join a subnet ────────────────────────────────────────────────
+    bittensor
+        .command('register <subnetId>')
+        .description('Register on a subnet (e.g. 64 for Chutes)')
+        .option('--name <name>', 'Wallet name', 'default')
+        .action(async (subnetId, options) => {
+        const pythonPath = process.env.BITTENSOR_PYTHON_PATH || detectPython();
+        if (!pythonPath || !hasBtcli(pythonPath)) {
+            console.log('\nbtcli not found. Run: clodds bittensor setup\n');
+            return;
+        }
+        const id = parseInt(subnetId, 10);
+        if (isNaN(id)) {
+            console.log('\nInvalid subnet ID. Example: clodds bittensor register 64\n');
+            return;
+        }
+        // Read network from config
+        let network = 'mainnet';
+        const cfgPath = (0, path_1.join)((0, os_1.homedir)(), '.clodds', 'clodds.json');
+        if ((0, fs_1.existsSync)(cfgPath)) {
+            try {
+                const cfg = JSON.parse((0, fs_1.readFileSync)(cfgPath, 'utf-8'));
+                if (cfg.bittensor?.network)
+                    network = cfg.bittensor.network;
+            }
+            catch { }
+        }
+        console.log(`\nRegistering on subnet ${id} (${network})...`);
+        console.log('This may cost TAO. Check your balance first: clodds bittensor wallet balance\n');
+        const args = [
+            'subnet', 'register',
+            '--netuid', String(id),
+            '--wallet.name', options.name ?? 'default',
+            '--no_prompt',
+        ];
+        if (network === 'testnet') {
+            args.push('--subtensor.network', 'test');
+        }
+        const result = btcliExec(pythonPath, args, 120_000);
+        if (result.ok) {
+            console.log('Registered successfully!');
+            console.log(result.stdout);
+        }
+        else {
+            console.log(`Registration failed: ${result.stderr || result.stdout}`);
+        }
+        console.log('');
+    });
+    // ── status ─────────────────────────────────────────────────────────────────
+    bittensor
+        .command('status')
+        .description('Show Bittensor mining status')
+        .action(async () => {
+        const { loadConfig } = await Promise.resolve().then(() => __importStar(require('../../utils/config')));
+        const config = await loadConfig();
+        if (!config.bittensor?.enabled) {
+            console.log('\nBittensor is not enabled. Run: clodds bittensor setup\n');
+            return;
+        }
+        console.log('\nBittensor Configuration:');
+        console.log(`  Network: ${config.bittensor.network ?? 'mainnet'}`);
+        console.log(`  Coldkey: ${config.bittensor.coldkeyPath ?? '(not set)'}`);
+        console.log(`  Python: ${config.bittensor.pythonPath ?? 'python3'}`);
+        const subnets = config.bittensor.subnets ?? [];
+        if (subnets.length > 0) {
+            console.log('  Subnets:');
+            for (const s of subnets) {
+                console.log(`    SN${s.subnetId} [${s.type}]: ${s.enabled ? 'enabled' : 'disabled'}`);
+            }
+        }
+        else {
+            console.log('  Subnets: none configured');
+        }
+        console.log('\nLive status (requires running gateway):');
+        console.log('  curl localhost:18789/api/bittensor/status\n');
+    });
+    // ── earnings: query from running gateway ─────────────────────────────────
+    bittensor
+        .command('earnings')
+        .description('Show TAO earnings (queries running gateway)')
+        .option('-p, --period <period>', 'Period: hourly, daily, weekly, monthly, all', 'daily')
+        .option('--port <port>', 'Gateway port', '18789')
+        .action(async (options) => {
+        const port = options.port ?? '18789';
+        const period = options.period ?? 'daily';
+        try {
+            const token = process.env.CLODDS_TOKEN;
+            const headers = {};
+            if (token)
+                headers['Authorization'] = `Bearer ${token}`;
+            const r = await fetch(`http://127.0.0.1:${port}/api/bittensor/earnings?period=${period}`, { headers });
+            if (!r.ok) {
+                console.log(`\nGateway returned ${r.status}. Is Clodds running? (clodds start)\n`);
+                return;
+            }
+            const body = await r.json();
+            const data = body.data ?? [];
+            if (data.length === 0) {
+                console.log(`\nNo ${period} earnings recorded yet.\n`);
+                return;
+            }
+            const totalTao = data.reduce((s, e) => s + e.taoEarned, 0);
+            const totalUsd = data.reduce((s, e) => s + e.usdEarned, 0);
+            console.log(`\n${period.charAt(0).toUpperCase() + period.slice(1)} Earnings:`);
+            console.log(`  TAO: ${totalTao.toFixed(4)}`);
+            console.log(`  USD: $${totalUsd.toFixed(2)}`);
+            console.log(`  Records: ${data.length}\n`);
+        }
+        catch {
+            console.log('\nCould not reach gateway. Is Clodds running? (clodds start)\n');
+        }
+    });
+    // ── miners: query from running gateway ───────────────────────────────────
+    bittensor
+        .command('miners')
+        .description('Show registered miner statuses (queries running gateway)')
+        .option('--port <port>', 'Gateway port', '18789')
+        .action(async (options) => {
+        const port = options.port ?? '18789';
+        try {
+            const token = process.env.CLODDS_TOKEN;
+            const headers = {};
+            if (token)
+                headers['Authorization'] = `Bearer ${token}`;
+            const r = await fetch(`http://127.0.0.1:${port}/api/bittensor/miners`, { headers });
+            if (!r.ok) {
+                console.log(`\nGateway returned ${r.status}. Is Clodds running? (clodds start)\n`);
+                return;
+            }
+            const body = await r.json();
+            const data = body.data ?? [];
+            if (data.length === 0) {
+                console.log('\nNo miners registered.\n');
+                return;
+            }
+            console.log('\nRegistered Miners:');
+            for (const m of data) {
+                console.log(`  SN${m.subnetId} UID${m.uid}: trust=${m.trust.toFixed(3)} incentive=${m.incentive.toFixed(3)} emission=${m.emission.toFixed(6)} rank=${m.rank} ${m.active ? 'ACTIVE' : 'OFFLINE'}`);
+            }
+            console.log('');
+        }
+        catch {
+            console.log('\nCould not reach gateway. Is Clodds running? (clodds start)\n');
+        }
+    });
+    // ── subnets: query from running gateway ──────────────────────────────────
+    bittensor
+        .command('subnets')
+        .description('List available Bittensor subnets (queries running gateway)')
+        .option('--port <port>', 'Gateway port', '18789')
+        .action(async (options) => {
+        const port = options.port ?? '18789';
+        try {
+            const token = process.env.CLODDS_TOKEN;
+            const headers = {};
+            if (token)
+                headers['Authorization'] = `Bearer ${token}`;
+            const r = await fetch(`http://127.0.0.1:${port}/api/bittensor/subnets`, { headers });
+            if (!r.ok) {
+                console.log(`\nGateway returned ${r.status}. Is Clodds running? (clodds start)\n`);
+                return;
+            }
+            const body = await r.json();
+            const data = body.data ?? [];
+            if (data.length === 0) {
+                console.log('\nCould not fetch subnets. Check connection.\n');
+                return;
+            }
+            console.log('\nAvailable Subnets:');
+            for (const s of data.slice(0, 30)) {
+                console.log(`  SN${s.netuid} (${s.name}): ${s.minerCount} miners, reg: ${s.registrationCost.toFixed(4)} TAO`);
+            }
+            if (data.length > 30)
+                console.log(`  ... and ${data.length - 30} more`);
+            console.log('');
+        }
+        catch {
+            console.log('\nCould not reach gateway. Is Clodds running? (clodds start)\n');
+        }
+    });
+    // ── check: dependency verification ─────────────────────────────────────────
+    bittensor
+        .command('check')
+        .description('Verify all dependencies are installed')
+        .action(() => {
+        console.log('\n=== Bittensor Dependency Check ===\n');
+        // Python
+        const pythonPath = process.env.BITTENSOR_PYTHON_PATH || detectPython();
+        if (pythonPath) {
+            const ver = (0, child_process_1.spawnSync)(pythonPath, ['--version'], { encoding: 'utf-8' });
+            console.log(`  Python:       ${ver.stdout?.trim()} (${pythonPath})`);
+        }
+        else {
+            console.log('  Python:       NOT FOUND');
+        }
+        // btcli
+        if (pythonPath && hasBtcli(pythonPath)) {
+            const ver = (0, child_process_1.spawnSync)(pythonPath, ['-c', 'import bittensor; print(bittensor.__version__)'], { encoding: 'utf-8' });
+            console.log(`  bittensor:    ${ver.stdout?.trim()}`);
+        }
+        else {
+            console.log('  bittensor:    NOT INSTALLED');
+        }
+        // Wallet
+        const walletDir = (0, path_1.join)((0, os_1.homedir)(), '.bittensor', 'wallets', 'default');
+        console.log(`  Wallet:       ${(0, fs_1.existsSync)(walletDir) ? 'found' : 'not found'} (${walletDir})`);
+        // @polkadot/api
+        try {
+            require.resolve('@polkadot/api');
+            console.log('  @polkadot/api: installed');
+        }
+        catch {
+            console.log('  @polkadot/api: NOT INSTALLED');
+        }
+        // Config
+        const configPath = (0, path_1.join)((0, os_1.homedir)(), '.clodds', 'clodds.json');
+        if ((0, fs_1.existsSync)(configPath)) {
+            try {
+                const cfg = JSON.parse((0, fs_1.readFileSync)(configPath, 'utf-8'));
+                console.log(`  Config:       ${cfg.bittensor?.enabled ? 'enabled' : 'disabled'} (${configPath})`);
+            }
+            catch {
+                console.log(`  Config:       error reading (${configPath})`);
+            }
+        }
+        else {
+            console.log('  Config:       not found');
+        }
+        console.log('\nIf anything is missing, run: clodds bittensor setup\n');
+    });
+}
+// =============================================================================
+// DOCTOR COMMAND - comprehensive system health check
+// =============================================================================
+function createDoctorCommand(program) {
+    program
+        .command('doctor')
+        .description('Run comprehensive system health checks')
+        .option('--verbose', 'Show detailed output')
+        .action(async (options) => {
+        const verbose = !!options.verbose;
+        console.log('\n=== Clodds System Doctor ===\n');
+        const results = [];
+        // ── 1. Core: Config + DB ─────────────────────────────────────────────
+        console.log('Checking core...');
+        const configPath = (0, path_1.join)((0, os_1.homedir)(), '.clodds', 'clodds.json');
+        if ((0, fs_1.existsSync)(configPath)) {
+            results.push({ name: 'Config file', status: 'pass', message: configPath });
+        }
+        else {
+            results.push({ name: 'Config file', status: 'warn', message: 'Not found', fix: 'Run: clodds onboard' });
+        }
+        const envPath = (0, path_1.join)((0, os_1.homedir)(), '.clodds', '.env');
+        if ((0, fs_1.existsSync)(envPath)) {
+            results.push({ name: '.env file', status: 'pass', message: envPath });
+        }
+        else {
+            results.push({ name: '.env file', status: 'warn', message: 'Not found (using env vars only)' });
+        }
+        try {
+            const db = (0, db_1.createDatabase)();
+            const runner = (0, migrations_1.createMigrationRunner)(db);
+            runner.migrate();
+            results.push({ name: 'Database', status: 'pass', message: 'SQLite OK, migrations applied' });
+        }
+        catch (e) {
+            results.push({ name: 'Database', status: 'fail', message: `Error: ${e.message}` });
+        }
+        // ── 2. AI Providers ──────────────────────────────────────────────────
+        console.log('Checking AI providers...');
+        const anthropicKey = process.env.ANTHROPIC_API_KEY;
+        if (!anthropicKey) {
+            results.push({ name: 'Anthropic', status: 'fail', message: 'ANTHROPIC_API_KEY not set', fix: 'https://console.anthropic.com' });
+        }
+        else {
+            try {
+                const r = await fetch('https://api.anthropic.com/v1/messages', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json', 'x-api-key': anthropicKey, 'anthropic-version': '2023-06-01' },
+                    body: JSON.stringify({ model: 'claude-3-haiku-20240307', max_tokens: 1, messages: [{ role: 'user', content: 'hi' }] }),
+                });
+                if (r.ok || r.status === 429) {
+                    results.push({ name: 'Anthropic', status: 'pass', message: r.ok ? 'Key valid' : 'Key valid (rate limited)' });
+                }
+                else {
+                    results.push({ name: 'Anthropic', status: 'fail', message: `HTTP ${r.status}`, fix: 'Check key at console.anthropic.com' });
+                }
+            }
+            catch (e) {
+                results.push({ name: 'Anthropic', status: 'warn', message: `Network error: ${e.message}` });
+            }
+        }
+        const openaiKey = process.env.OPENAI_API_KEY;
+        if (openaiKey) {
+            try {
+                const r = await fetch('https://api.openai.com/v1/models', {
+                    headers: { Authorization: `Bearer ${openaiKey}` },
+                });
+                results.push({
+                    name: 'OpenAI',
+                    status: r.ok || r.status === 429 ? 'pass' : 'fail',
+                    message: r.ok ? 'Key valid' : `HTTP ${r.status}`,
+                    fix: r.ok ? undefined : 'Check key at platform.openai.com',
+                });
+            }
+            catch (e) {
+                results.push({ name: 'OpenAI', status: 'warn', message: `Network error: ${e.message}` });
+            }
+        }
+        else if (verbose) {
+            results.push({ name: 'OpenAI', status: 'warn', message: 'Not configured (optional)' });
+        }
+        // ── 3. Messaging Channels ────────────────────────────────────────────
+        console.log('Checking channels...');
+        // Telegram
+        const tgToken = process.env.TELEGRAM_BOT_TOKEN;
+        if (tgToken) {
+            try {
+                const r = await fetch(`https://api.telegram.org/bot${tgToken}/getMe`);
+                const d = await r.json();
+                results.push({
+                    name: 'Telegram',
+                    status: d.ok ? 'pass' : 'fail',
+                    message: d.ok ? `@${d.result?.username}` : 'Invalid token',
+                    fix: d.ok ? undefined : 'Get token from @BotFather',
+                });
+            }
+            catch {
+                results.push({ name: 'Telegram', status: 'warn', message: 'Network error' });
+            }
+        }
+        else if (verbose) {
+            results.push({ name: 'Telegram', status: 'warn', message: 'Not configured' });
+        }
+        // Discord
+        const dcToken = process.env.DISCORD_BOT_TOKEN;
+        if (dcToken) {
+            try {
+                const r = await fetch('https://discord.com/api/v10/users/@me', {
+                    headers: { Authorization: `Bot ${dcToken}` },
+                });
+                if (r.ok) {
+                    const d = await r.json();
+                    results.push({ name: 'Discord', status: 'pass', message: `Bot: ${d.username}` });
+                }
+                else {
+                    results.push({ name: 'Discord', status: 'fail', message: `HTTP ${r.status}`, fix: 'Check token at discord.com/developers' });
+                }
+            }
+            catch {
+                results.push({ name: 'Discord', status: 'warn', message: 'Network error' });
+            }
+        }
+        else if (verbose) {
+            results.push({ name: 'Discord', status: 'warn', message: 'Not configured' });
+        }
+        // Slack
+        const slackToken = process.env.SLACK_BOT_TOKEN;
+        if (slackToken) {
+            try {
+                const r = await fetch('https://slack.com/api/auth.test', {
+                    headers: { Authorization: `Bearer ${slackToken}` },
+                });
+                const d = await r.json();
+                results.push({
+                    name: 'Slack',
+                    status: d.ok ? 'pass' : 'fail',
+                    message: d.ok ? `${d.user} @ ${d.team}` : (d.error ?? 'Invalid token'),
+                    fix: d.ok ? undefined : 'Check token at api.slack.com/apps',
+                });
+            }
+            catch {
+                results.push({ name: 'Slack', status: 'warn', message: 'Network error' });
+            }
+        }
+        else if (verbose) {
+            results.push({ name: 'Slack', status: 'warn', message: 'Not configured' });
+        }
+        // WhatsApp - check auth dir exists
+        const waAuthDir = (0, path_1.join)(process.cwd(), '.whatsapp-auth');
+        const waConfigAuthDir = (() => {
+            try {
+                const cfg = (0, fs_1.existsSync)(configPath) ? JSON.parse((0, fs_1.readFileSync)(configPath, 'utf-8')) : {};
+                return cfg.channels?.whatsapp?.authDir;
+            }
+            catch {
+                return undefined;
+            }
+        })();
+        const waDir = waConfigAuthDir || waAuthDir;
+        if ((0, fs_1.existsSync)(waDir)) {
+            results.push({ name: 'WhatsApp', status: 'pass', message: `Auth at ${waDir}` });
+        }
+        else if (verbose) {
+            results.push({ name: 'WhatsApp', status: 'warn', message: 'No auth session', fix: 'Run: clodds whatsapp setup' });
+        }
+        // ── 4. Trading Platforms ─────────────────────────────────────────────
+        console.log('Checking trading platforms...');
+        const polyKey = process.env.POLY_API_KEY;
+        const polySecret = process.env.POLY_API_SECRET;
+        const polyPass = process.env.POLY_API_PASSPHRASE;
+        if (polyKey && polySecret && polyPass) {
+            try {
+                const r = await fetch('https://clob.polymarket.com/markets?limit=1');
+                results.push({
+                    name: 'Polymarket',
+                    status: r.ok ? 'pass' : 'warn',
+                    message: r.ok ? 'API reachable, credentials configured' : `API returned ${r.status}`,
+                });
+            }
+            catch {
+                results.push({ name: 'Polymarket', status: 'warn', message: 'Network error' });
+            }
+            if (!process.env.POLY_PRIVATE_KEY) {
+                results.push({ name: 'Polymarket (trade)', status: 'warn', message: 'POLY_PRIVATE_KEY not set — read-only mode' });
+            }
+        }
+        else if (verbose) {
+            results.push({ name: 'Polymarket', status: 'warn', message: 'Not configured' });
+        }
+        const kalshiKey = process.env.KALSHI_API_KEY;
+        if (kalshiKey) {
+            results.push({
+                name: 'Kalshi',
+                status: process.env.KALSHI_API_SECRET ? 'pass' : 'fail',
+                message: process.env.KALSHI_API_SECRET ? 'API key + secret configured' : 'Missing KALSHI_API_SECRET',
+            });
+        }
+        else if (verbose) {
+            results.push({ name: 'Kalshi', status: 'warn', message: 'Not configured' });
+        }
+        // ── 5. External Services ─────────────────────────────────────────────
+        console.log('Checking services...');
+        const redisHost = process.env.REDIS_HOST;
+        if (redisHost) {
+            results.push({ name: 'Redis', status: 'warn', message: `Configured: ${redisHost} (not tested — requires connection)` });
+        }
+        else if (verbose) {
+            results.push({ name: 'Redis', status: 'warn', message: 'Not configured (optional — used for execution queue)' });
+        }
+        const pgUrl = process.env.DATABASE_URL;
+        if (pgUrl) {
+            results.push({ name: 'PostgreSQL', status: 'warn', message: 'DATABASE_URL set (not tested — requires connection)' });
+        }
+        else if (verbose) {
+            results.push({ name: 'PostgreSQL', status: 'warn', message: 'Not configured (optional — for tick recording)' });
+        }
+        // ── 6. Bittensor ────────────────────────────────────────────────────
+        let btEnabled = false;
+        try {
+            const cfg = (0, fs_1.existsSync)(configPath) ? JSON.parse((0, fs_1.readFileSync)(configPath, 'utf-8')) : {};
+            btEnabled = cfg.bittensor?.enabled === true;
+        }
+        catch { }
+        if (btEnabled || process.env.BITTENSOR_ENABLED === 'true') {
+            console.log('Checking Bittensor...');
+            const py = process.env.BITTENSOR_PYTHON_PATH || detectPython();
+            if (py) {
+                results.push({ name: 'Python', status: 'pass', message: py });
+                if (hasBtcli(py)) {
+                    results.push({ name: 'btcli', status: 'pass', message: 'Installed' });
+                }
+                else {
+                    results.push({ name: 'btcli', status: 'fail', message: 'Not installed', fix: 'Run: clodds bittensor setup' });
+                }
+            }
+            else {
+                results.push({ name: 'Python', status: 'fail', message: 'Not found', fix: 'Install Python 3' });
+            }
+            const walletDir = (0, path_1.join)((0, os_1.homedir)(), '.bittensor', 'wallets', 'default');
+            results.push({
+                name: 'Bittensor wallet',
+                status: (0, fs_1.existsSync)(walletDir) ? 'pass' : 'fail',
+                message: (0, fs_1.existsSync)(walletDir) ? walletDir : 'Not found',
+                fix: (0, fs_1.existsSync)(walletDir) ? undefined : 'Run: clodds bittensor setup',
+            });
+        }
+        else if (verbose) {
+            results.push({ name: 'Bittensor', status: 'warn', message: 'Not enabled' });
+        }
+        // ── 7. Features Summary ──────────────────────────────────────────────
+        if (verbose) {
+            console.log('Checking features...');
+            const features = [
+                { name: 'Paper Trading', enabled: process.env.PAPER_TRADING === 'true', envVar: 'PAPER_TRADING' },
+                { name: 'Tick Recording', enabled: !!process.env.TICK_DB_URL, envVar: 'TICK_DB_URL' },
+                { name: 'x402 Payments', enabled: process.env.X402_ENABLED === 'true', envVar: 'X402_ENABLED' },
+                { name: 'Copy Trading', enabled: !!process.env.WHALE_TRACKER_WALLETS, envVar: 'WHALE_TRACKER_WALLETS' },
+                { name: 'News Feed', enabled: !!process.env.TWITTER_BEARER_TOKEN, envVar: 'TWITTER_BEARER_TOKEN' },
+                { name: 'Execution Queue', enabled: !!process.env.REDIS_HOST, envVar: 'REDIS_HOST' },
+                { name: 'Cron Jobs', enabled: process.env.CRON_ENABLED === 'true', envVar: 'CRON_ENABLED' },
+                { name: 'Bittensor Mining', enabled: btEnabled || process.env.BITTENSOR_ENABLED === 'true', envVar: 'BITTENSOR_ENABLED' },
+            ];
+            for (const f of features) {
+                results.push({
+                    name: f.name,
+                    status: f.enabled ? 'pass' : 'warn',
+                    message: f.enabled ? 'Enabled' : `Disabled (set ${f.envVar} to enable)`,
+                });
+            }
+        }
+        // ── Display ──────────────────────────────────────────────────────────
+        console.log('');
+        const icons = { pass: '\x1b[32m✓\x1b[0m', warn: '\x1b[33m!\x1b[0m', fail: '\x1b[31m✗\x1b[0m' };
+        for (const r of results) {
+            console.log(`  ${icons[r.status]} ${r.name}: ${r.message}`);
+            if (r.fix) {
+                console.log(`    Fix: ${r.fix}`);
+            }
+        }
+        const passed = results.filter(r => r.status === 'pass').length;
+        const warned = results.filter(r => r.status === 'warn').length;
+        const failed = results.filter(r => r.status === 'fail').length;
+        console.log(`\n  ${passed} passed, ${warned} warnings, ${failed} failed`);
+        if (failed > 0) {
+            console.log('\n  Fix the failures above and run `clodds doctor` again.');
+            process.exitCode = 1;
+        }
+        else if (warned > 0) {
+            console.log('\n  Warnings are optional — fix them if you need those features.');
+        }
+        else {
+            console.log('\n  Everything looks good!');
+        }
+        console.log(`\n  Tip: Run \`clodds doctor --verbose\` to see all features and optional services.\n`);
+    });
+}
+// =============================================================================
+// ONBOARD COMMAND - interactive setup wizard
+// =============================================================================
+function createOnboardCommand(program) {
+    program
+        .command('onboard')
+        .alias('setup')
+        .description('Interactive setup wizard — get running in 60 seconds')
+        .option('--api-key <key>', 'Anthropic API key (skip prompt)')
+        .option('--channel <name>', 'Channel to configure (telegram, discord, slack, webchat)')
+        .option('--no-start', 'Skip the "start now?" prompt')
+        .action(async (options) => {
+        const { createInterface } = await Promise.resolve().then(() => __importStar(require('readline')));
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        const ask = (prompt) => new Promise((resolve) => rl.question(prompt, (a) => resolve(a.trim())));
+        // ANSI helpers
+        const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+        const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+        const green = (s) => `\x1b[32m${s}\x1b[0m`;
+        const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
+        const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+        const red = (s) => `\x1b[31m${s}\x1b[0m`;
+        const magenta = (s) => `\x1b[35m${s}\x1b[0m`;
+        const bgCyan = (s) => `\x1b[46m\x1b[30m${s}\x1b[0m`;
+        const cloddsDir = (0, path_1.join)((0, os_1.homedir)(), '.clodds');
+        const envPath = (0, path_1.join)(cloddsDir, '.env');
+        const configPath = (0, path_1.join)(cloddsDir, 'clodds.json');
+        // Track what we'll write
+        const envVars = {};
+        const configObj = {};
+        // Load existing config if present
+        if ((0, fs_1.existsSync)(configPath)) {
+            try {
+                Object.assign(configObj, JSON.parse((0, fs_1.readFileSync)(configPath, 'utf-8')));
+            }
+            catch { /* fresh */ }
+        }
+        // Load existing .env if present
+        if ((0, fs_1.existsSync)(envPath)) {
+            try {
+                const lines = (0, fs_1.readFileSync)(envPath, 'utf-8').split('\n');
+                for (const line of lines) {
+                    const match = line.match(/^([A-Z_]+)=(.+)$/);
+                    if (match)
+                        envVars[match[1]] = match[2];
+                }
+            }
+            catch { /* fresh */ }
+        }
+        // ═══════════════════════════════════════════════════════════════════
+        // WELCOME
+        // ═══════════════════════════════════════════════════════════════════
+        const figlet = await Promise.resolve().then(() => __importStar(require('figlet')));
+        const banner = figlet.default.textSync('Clodds', { font: 'ANSI Shadow' });
+        console.log('');
+        console.log(`              ${cyan('\u2584\u2584\u2588\u2588\u2588\u2588\u2588\u2588\u2584\u2584')}`);
+        console.log(`            ${cyan('\u2584\u2588\u2588')}${magenta('\u2580')}      ${magenta('\u2580')}${cyan('\u2588\u2588\u2584')}`);
+        console.log(`           ${cyan('\u2588\u2588\u2588')}  ${magenta('\u2726')}    ${magenta('\u2726')}  ${cyan('\u2588\u2588\u2588')}`);
+        console.log(`           ${cyan('\u2588\u2588\u2588')}    ${magenta('\u25c8')}     ${cyan('\u2588\u2588\u2588')}`);
+        console.log(`            ${cyan('\u2580\u2588\u2588')}${magenta('\u2584')}      ${magenta('\u2584')}${cyan('\u2588\u2588\u2580')}`);
+        console.log(`              ${cyan('\u2580\u2580\u2588\u2588\u2588\u2588\u2588\u2588\u2580\u2580')}`);
+        console.log(`              ${yellow('\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557')}`);
+        console.log(`              ${yellow('\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D')}`);
+        console.log('');
+        for (const line of banner.split('\n')) {
+            if (line.trim())
+                console.log(`  ${magenta(line)}`);
+        }
+        console.log('');
+        console.log(`  ${bold('AI Trading Terminal')} ${dim('for prediction markets, crypto & futures')}`);
+        console.log(`  ${dim('10 markets  \u00b7  22 channels  \u00b7  110 skills')}`);
+        console.log('');
+        console.log(`  ${dim('='.repeat(56))}`);
+        console.log('');
+        // ═══════════════════════════════════════════════════════════════════
+        // STEP 1: API KEY
+        // ═══════════════════════════════════════════════════════════════════
+        console.log(`  ${bgCyan(' 1 ')} ${bold('Anthropic API Key')}`);
+        console.log(`  ${dim('Powers the Claude AI brain. Get one free at:')}`);
+        console.log(`  ${cyan('https://console.anthropic.com')}`);
+        console.log('');
+        let apiKey = options.apiKey || envVars.ANTHROPIC_API_KEY || process.env.ANTHROPIC_API_KEY || '';
+        const isPlaceholder = !apiKey || apiKey === 'sk-ant-...' || apiKey.length < 20;
+        if (isPlaceholder) {
+            apiKey = await ask(`  ${bold('Paste API key:')} `);
+            if (!apiKey || apiKey.length < 10) {
+                console.log('');
+                console.log(`  ${red('No key provided.')} Add it later:`);
+                console.log(`  ${dim('echo "ANTHROPIC_API_KEY=sk-ant-..." >> ~/.clodds/.env')}`);
+                console.log('');
+                rl.close();
+                return;
+            }
+        }
+        else {
+            const masked = apiKey.slice(0, 10) + '...' + apiKey.slice(-4);
+            console.log(`  ${dim('Found:')} ${masked}`);
+            const reuse = await ask(`  ${bold('Use this key?')} ${dim('[Y/n]')} `);
+            if (reuse.toLowerCase() === 'n') {
+                apiKey = await ask(`  ${bold('Paste new key:')} `);
+            }
+        }
+        envVars.ANTHROPIC_API_KEY = apiKey;
+        // Validate
+        process.stdout.write(`  ${dim('Validating...')}`);
+        try {
+            const r = await fetch('https://api.anthropic.com/v1/messages', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': apiKey,
+                    'anthropic-version': '2023-06-01',
+                },
+                body: '{}',
+            });
+            // 401 = bad key. Anything else (400, 429, etc.) = key authenticated fine.
+            if (r.status === 401) {
+                console.log(`\r  ${yellow('Invalid key')} — continuing anyway          `);
+            }
+            else {
+                console.log(`\r  ${green('Valid')}                              `);
+            }
+        }
+        catch {
+            console.log(`\r  ${yellow('Offline')} — skipped validation        `);
+        }
+        console.log('');
+        // ═══════════════════════════════════════════════════════════════════
+        // STEP 2: CHANNEL
+        // ═══════════════════════════════════════════════════════════════════
+        console.log(`  ${bgCyan(' 2 ')} ${bold('Messaging Channel')}`);
+        console.log(`  ${dim('WebChat is built-in at')} ${cyan('http://localhost:18789/webchat')}`);
+        console.log(`  ${dim('Optionally connect a platform:')}`);
+        console.log('');
+        console.log(`    ${bold('1')}  WebChat only       ${dim('zero config, works immediately')}`);
+        console.log(`    ${bold('2')}  Telegram            ${green('recommended')} ${dim('— easiest setup')}`);
+        console.log(`    ${bold('3')}  Discord             ${dim('bot token from discord.com/developers')}`);
+        console.log(`    ${bold('4')}  Slack               ${dim('bot + app tokens from api.slack.com')}`);
+        console.log('');
+        let channelChoice = options.channel || '';
+        if (!channelChoice) {
+            const choice = await ask(`  ${bold('Choose')} ${dim('[1-4, default 1]:')} `);
+            const map = { '1': 'webchat', '2': 'telegram', '3': 'discord', '4': 'slack', '': 'webchat' };
+            channelChoice = map[choice] || choice.toLowerCase();
+        }
+        console.log('');
+        // ═══════════════════════════════════════════════════════════════════
+        // STEP 3: CHANNEL TOKEN
+        // ═══════════════════════════════════════════════════════════════════
+        if (channelChoice === 'telegram') {
+            console.log(`  ${bgCyan(' 3 ')} ${bold('Telegram Setup')}`);
+            console.log(`  ${dim('1.')} Open Telegram, message ${cyan('@BotFather')}`);
+            console.log(`  ${dim('2.')} Send ${bold('/newbot')} and follow the prompts`);
+            console.log(`  ${dim('3.')} Copy the token it gives you`);
+            console.log('');
+            let token = envVars.TELEGRAM_BOT_TOKEN || process.env.TELEGRAM_BOT_TOKEN || '';
+            if (token) {
+                console.log(`  ${dim('Found:')} ${token.slice(0, 8)}...`);
+                const reuse = await ask(`  ${bold('Use this token?')} ${dim('[Y/n]')} `);
+                if (reuse.toLowerCase() === 'n')
+                    token = '';
+            }
+            if (!token) {
+                token = await ask(`  ${bold('Bot token:')} `);
+            }
+            if (token) {
+                envVars.TELEGRAM_BOT_TOKEN = token;
+                configObj.channels = { ...(configObj.channels || {}), telegram: { enabled: true } };
+                // Validate token
+                process.stdout.write(`  ${dim('Validating...')}`);
+                try {
+                    const r = await fetch(`https://api.telegram.org/bot${token}/getMe`);
+                    const d = await r.json();
+                    if (d.ok) {
+                        console.log(`\r  ${green(`@${d.result?.username}`)} connected       `);
+                    }
+                    else {
+                        console.log(`\r  ${yellow('Token may be invalid')} — continuing       `);
+                    }
+                }
+                catch {
+                    console.log(`\r  ${yellow('Offline')} — skipped validation       `);
+                }
+            }
+            else {
+                console.log(`  ${dim('Skipped. Add later: TELEGRAM_BOT_TOKEN=... in ~/.clodds/.env')}`);
+            }
+        }
+        else if (channelChoice === 'discord') {
+            console.log(`  ${bgCyan(' 3 ')} ${bold('Discord Setup')}`);
+            console.log(`  ${dim('1.')} Go to ${cyan('https://discord.com/developers/applications')}`);
+            console.log(`  ${dim('2.')} Create app > Bot > Reset Token > Copy`);
+            console.log('');
+            let token = envVars.DISCORD_BOT_TOKEN || process.env.DISCORD_BOT_TOKEN || '';
+            if (token) {
+                console.log(`  ${dim('Found:')} ${token.slice(0, 8)}...`);
+                const reuse = await ask(`  ${bold('Use this token?')} ${dim('[Y/n]')} `);
+                if (reuse.toLowerCase() === 'n')
+                    token = '';
+            }
+            if (!token) {
+                token = await ask(`  ${bold('Bot token:')} `);
+            }
+            if (token) {
+                envVars.DISCORD_BOT_TOKEN = token;
+                const appId = await ask(`  ${bold('Application ID')} ${dim('(optional, Enter to skip):')} `);
+                if (appId)
+                    envVars.DISCORD_APP_ID = appId;
+                configObj.channels = { ...(configObj.channels || {}), discord: { enabled: true } };
+                console.log(`  ${green('Discord configured')}`);
+            }
+            else {
+                console.log(`  ${dim('Skipped. Add later: DISCORD_BOT_TOKEN=... in ~/.clodds/.env')}`);
+            }
+        }
+        else if (channelChoice === 'slack') {
+            console.log(`  ${bgCyan(' 3 ')} ${bold('Slack Setup')}`);
+            console.log(`  ${dim('1.')} Go to ${cyan('https://api.slack.com/apps')} > Create App`);
+            console.log(`  ${dim('2.')} OAuth > Bot Token (xoxb-...) and App Token (xapp-...)`);
+            console.log('');
+            let botToken = envVars.SLACK_BOT_TOKEN || process.env.SLACK_BOT_TOKEN || '';
+            if (!botToken) {
+                botToken = await ask(`  ${bold('Bot token')} ${dim('(xoxb-...):')} `);
+            }
+            let appToken = envVars.SLACK_APP_TOKEN || process.env.SLACK_APP_TOKEN || '';
+            if (!appToken) {
+                appToken = await ask(`  ${bold('App token')} ${dim('(xapp-...):')} `);
+            }
+            if (botToken && appToken) {
+                envVars.SLACK_BOT_TOKEN = botToken;
+                envVars.SLACK_APP_TOKEN = appToken;
+                configObj.channels = { ...(configObj.channels || {}), slack: { enabled: true } };
+                console.log(`  ${green('Slack configured')}`);
+            }
+            else {
+                console.log(`  ${dim('Incomplete. Add tokens later in ~/.clodds/.env')}`);
+            }
+        }
+        else {
+            console.log(`  ${bgCyan(' 3 ')} ${bold('WebChat')} ${dim('— no extra setup needed')}`);
+        }
+        console.log('');
+        // ═══════════════════════════════════════════════════════════════════
+        // STEP 4: WRITE CONFIG
+        // ═══════════════════════════════════════════════════════════════════
+        console.log(`  ${bgCyan(' 4 ')} ${bold('Saving')}`);
+        if (!(0, fs_1.existsSync)(cloddsDir)) {
+            (0, fs_1.mkdirSync)(cloddsDir, { recursive: true });
+        }
+        // Auto-generate credential encryption key if not set
+        if (!envVars.CLODDS_CREDENTIAL_KEY && !process.env.CLODDS_CREDENTIAL_KEY) {
+            const { randomBytes } = await Promise.resolve().then(() => __importStar(require('crypto')));
+            envVars.CLODDS_CREDENTIAL_KEY = randomBytes(32).toString('hex');
+        }
+        // Write .env
+        const envContent = Object.entries(envVars)
+            .filter(([_, v]) => v && v !== 'sk-ant-...')
+            .map(([k, v]) => `${k}=${v}`)
+            .join('\n') + '\n';
+        (0, fs_1.writeFileSync)(envPath, envContent, { mode: 0o600 });
+        console.log(`  ${green('wrote')} ${dim(envPath)}`);
+        // Write config
+        if (!configObj.gateway) {
+            configObj.gateway = { port: 18789 };
+        }
+        (0, fs_1.writeFileSync)(configPath, JSON.stringify(configObj, null, 2));
+        console.log(`  ${green('wrote')} ${dim(configPath)}`);
+        // ═══════════════════════════════════════════════════════════════════
+        // DONE
+        // ═══════════════════════════════════════════════════════════════════
+        console.log('');
+        console.log(`  ${green(bold('Setup complete.'))}  Everything you need is ready.`);
+        console.log('');
+        console.log(`  ${dim('Quick reference:')}`);
+        console.log(`    ${bold('clodds start')}     ${dim('launch the gateway')}`);
+        console.log(`    ${bold('clodds doctor')}    ${dim('run diagnostics')}`);
+        console.log(`    ${bold('clodds repl')}      ${dim('local test shell')}`);
+        console.log('');
+        console.log(`  ${dim('WebChat:')} ${cyan('http://localhost:18789/webchat')}`);
+        if (channelChoice === 'telegram' && envVars.TELEGRAM_BOT_TOKEN) {
+            console.log(`  ${dim('Telegram:')} message your bot to start chatting`);
+        }
+        else if (channelChoice === 'discord' && envVars.DISCORD_BOT_TOKEN) {
+            console.log(`  ${dim('Discord:')} invite your bot, then mention it`);
+        }
+        console.log('');
+        if (options.start !== false) {
+            const startNow = await ask(`  ${bold('Start Clodds now?')} ${dim('[Y/n]')} `);
+            rl.close();
+            if (!startNow || startNow.toLowerCase() === 'y' || startNow.toLowerCase() === 'yes') {
+                for (const [k, v] of Object.entries(envVars)) {
+                    process.env[k] = v;
+                }
+                console.log('');
+                const config = await (0, config_1.loadConfig)();
+                const { configureHttpClient } = await Promise.resolve().then(() => __importStar(require('../../utils/http.js')));
+                configureHttpClient(config.http);
+                const { createGateway } = await Promise.resolve().then(() => __importStar(require('../../gateway/index.js')));
+                process.stdout.write(`  ${dim('Starting...')}`);
+                const gateway = await createGateway(config);
+                await gateway.start();
+                // Restore logging now that the gateway is running
+                const { logger: rootLog } = await Promise.resolve().then(() => __importStar(require('../../utils/logger.js')));
+                rootLog.level = 'info';
+                console.log(`\r  ${green(bold('Clodds is running'))}                `);
+                console.log('');
+                console.log(`  ${cyan(`http://localhost:${config.gateway.port}/webchat`)}`);
+                console.log(`  ${dim('Press Ctrl+C to stop')}`);
+                console.log('');
+                const shutdown = async () => {
+                    console.log(`\n  ${dim('Shutting down...')}`);
+                    await gateway.stop();
+                    process.exit(0);
+                };
+                process.on('SIGINT', shutdown);
+                process.on('SIGTERM', shutdown);
+            }
+        }
+        else {
+            rl.close();
+        }
+    });
+}
+// =============================================================================
+// MAIN EXPORT
+// =============================================================================
+function addAllCommands(program) {
+    createConfigCommands(program);
+    createModelCommands(program);
+    createSessionCommands(program);
+    createCronCommands(program);
+    createQmdCommands(program);
+    createUserCommands(program);
+    createMemoryCommands(program);
+    createHookCommands(program);
+    createMcpCommands(program);
+    createMarketIndexCommands(program);
+    createPermissionCommands(program);
+    createUsageCommands(program);
+    createCredsCommands(program);
+    createLocaleCommands(program);
+    createLedgerCommands(program);
+    createInitCommand(program);
+    createUpgradeCommand(program);
+    createLoginCommand(program);
+    createLogoutCommand(program);
+    createWhatsAppCommands(program);
+    createBittensorCommands(program);
+    createOnboardCommand(program);
+    createDoctorCommand(program);
+    createVersionCommand(program);
+}
+//# sourceMappingURL=index.js.map