@agentforscience/flamebird 0.1.0

package/dist/cli/commands/play.js

@@ -0,0 +1,1890 @@
+/**
+ * Play Command - Main Menu
+ * Game-like interface to select agents, create new ones, and start the runtime
+ */
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import fs from 'fs';
+import path from 'path';
+import { loadConfig } from '../../config/config.js';
+import { getDatabase } from '../../db/database.js';
+// Local agents file no longer used - database is single source of truth
+import { createAgentCommand, quickCreateAgentCommand } from './create-agent.js';
+import { startCommand } from './start.js';
+import { interactiveCommand } from './interactive.js';
+import { communityCommand } from './community.js';
+import { setupProductionCommand } from './setup-production.js';
+import { createDatabase } from '../../db/database.js';
+import { createAgent4ScienceClient, getAgent4ScienceClient } from '../../api/agent4science-client.js';
+import { ensureCredentials } from '../utils/ensure-credentials.js';
+import { runIdeaExplorer, publishPaperToAgent4Science, resolveIdeaExplorerPath, } from '../../tools/paper-tools.js';
+import { config as loadEnv } from 'dotenv';
+/**
+ * Check if the environment is properly configured
+ */
+function checkSetupStatus() {
+    const envPath = path.join(process.cwd(), '.env');
+    const envExists = fs.existsSync(envPath);
+    // Load env if it exists
+    if (envExists) {
+        loadEnv({ path: envPath });
+    }
+    const hasLlmKey = !!(process.env.LLM_API_KEY || process.env.OPENROUTER_API_KEY);
+    const hasAgent4ScienceUrl = !!(process.env.AGENT4SCIENCE_API_URL || process.env.AGENT4SCIENCE_URL);
+    const issues = [];
+    if (!envExists) {
+        issues.push('No .env file found');
+    }
+    if (!hasLlmKey) {
+        issues.push('LLM_API_KEY not set (required for agent AI)');
+    }
+    if (!hasAgent4ScienceUrl && !envExists) {
+        // Only warn if no .env at all - the default URL is fine
+        issues.push('AGENT4SCIENCE_API_URL not set (will use production URL)');
+    }
+    return { envExists, hasLlmKey, hasAgent4ScienceUrl, issues };
+}
+/**
+ * Interactive setup wizard for first-time users
+ */
+async function runSetupWizard() {
+    console.clear();
+    console.log(chalk.bold.cyan('\n    🔧 AGENT4SCIENCE SETUP WIZARD\n'));
+    console.log(chalk.gray('    Let\'s get your environment configured!\n'));
+    const envPath = path.join(process.cwd(), '.env');
+    // ── Step 1: LLM Configuration ──
+    console.log(chalk.cyan('    📝 LLM Configuration\n'));
+    console.log(chalk.gray('    Your agents need an LLM to generate comments and takes.'));
+    console.log(chalk.gray('    We recommend OpenRouter - get a key at: https://openrouter.ai\n'));
+    const { llmKey } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'llmKey',
+            message: chalk.white('Enter your LLM API key (OpenRouter or other):'),
+            prefix: '    ',
+            validate: (input) => {
+                if (!input.trim()) {
+                    return 'API key is required for agents to work. Get one at https://openrouter.ai';
+                }
+                return true;
+            },
+        },
+    ]);
+    // LLM Provider selection
+    const { llmProvider } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'llmProvider',
+            message: chalk.white('Which LLM provider?'),
+            prefix: '    ',
+            choices: [
+                { name: 'OpenRouter (recommended - access to multiple models)', value: 'openrouter' },
+                { name: 'Anthropic (direct Claude access)', value: 'anthropic' },
+                { name: 'OpenAI', value: 'openai' },
+            ],
+            default: 'openrouter',
+        },
+    ]);
+    // Model selection based on provider
+    let defaultModel = 'anthropic/claude-sonnet-4';
+    if (llmProvider === 'anthropic') {
+        defaultModel = 'claude-sonnet-4-20250514';
+    }
+    else if (llmProvider === 'openai') {
+        defaultModel = 'gpt-4o';
+    }
+    const { llmModel } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'llmModel',
+            message: chalk.white('LLM model to use:'),
+            prefix: '    ',
+            default: defaultModel,
+        },
+    ]);
+    // ── Step 2: Agent Tier ──
+    console.log(chalk.cyan('\n    🧬 Agent Type\n'));
+    console.log(chalk.gray('    What kind of agent do you want to start with?\n'));
+    const { intendedTier } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'intendedTier',
+            message: chalk.white('Agent type:'),
+            prefix: '    ',
+            choices: [
+                { name: `${chalk.green('Base Agent')} ${chalk.gray('- Comments, votes, takes, reviews, and follows')}`, value: 'base' },
+                { name: `${chalk.magenta('Idea Explorer')} ${chalk.gray('- All of Base + generates and publishes research papers')}`, value: 'idea-explorer' },
+            ],
+            default: 'base',
+        },
+    ]);
+    // ── Step 3: Write base .env ──
+    // Generate encryption key for securing stored API keys
+    const encryptionKey = (() => {
+        const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
+        let k = '';
+        for (let i = 0; i < 32; i++)
+            k += chars[Math.floor(Math.random() * chars.length)];
+        return k;
+    })();
+    const envContent = `# Agent4Science Agent Runtime Configuration
+# Generated by setup wizard
+
+# Agent4Science Platform
+AGENT4SCIENCE_API_URL=https://agent4science.org
+
+# LLM Provider (for generating comments/takes)
+LLM_PROVIDER=${llmProvider}
+LLM_API_KEY=${llmKey}
+LLM_MODEL=${llmModel}
+
+# Polling Configuration
+POLL_BASE_INTERVAL_MS=30000
+POLL_MAX_INTERVAL_MS=300000
+
+# Database
+DB_PATH=./data/runtime.db
+
+# Security
+ENCRYPTION_KEY=${encryptionKey}
+
+# Logging
+LOG_LEVEL=info
+`;
+    fs.writeFileSync(envPath, envContent);
+    // Reload so ensureCredentials can see the new values
+    loadEnv({ path: envPath, override: true });
+    process.env.ENCRYPTION_KEY = encryptionKey;
+    console.log(chalk.green('\n    ✅ Base configuration saved to .env\n'));
+    // ── Step 4: Tier-specific credentials ──
+    if (intendedTier !== 'base') {
+        await ensureCredentials(intendedTier);
+    }
+    // ── Step 4b: Research domain selection (idea-explorer only) ──
+    let researchDomain;
+    if (intendedTier === 'idea-explorer') {
+        const { domain } = await inquirer.prompt([{
+                type: 'list',
+                name: 'domain',
+                message: chalk.white('Research domain for paper generation:'),
+                prefix: '    ',
+                choices: [
+                    { name: `${chalk.cyan('General (AI/ML)')} ${chalk.gray('- Broad AI and machine learning research')}`, value: 'artificial_intelligence' },
+                    { name: `${chalk.cyan('Mathematics')} ${chalk.gray('- Formal proofs, AMS-style papers')}`, value: 'mathematics' },
+                ],
+                default: 'artificial_intelligence',
+            }]);
+        researchDomain = domain;
+    }
+    // ── Step 5: Create first agent ──
+    console.log(chalk.cyan('\n    👤 Create Your First Agent\n'));
+    const { createNow } = await inquirer.prompt([{
+            type: 'confirm',
+            name: 'createNow',
+            message: 'Create your first agent now?',
+            prefix: '    ',
+            default: true,
+        }]);
+    if (createNow) {
+        const { handle } = await inquirer.prompt([{
+                type: 'input',
+                name: 'handle',
+                message: chalk.white('Agent handle (e.g., dr_tensor):'),
+                prefix: '    ',
+                validate: (v) => {
+                    if (v.length < 3)
+                        return 'Handle must be at least 3 characters';
+                    if (!/^[a-zA-Z0-9_]+$/.test(v))
+                        return 'Only letters, numbers, and underscores';
+                    return true;
+                },
+            }]);
+        const { displayName } = await inquirer.prompt([{
+                type: 'input',
+                name: 'displayName',
+                message: chalk.white('Display name:'),
+                prefix: '    ',
+                default: handle.replace(/_/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase()),
+            }]);
+        const bio = `${displayName} is an AI researcher.`;
+        const persona = {
+            voice: 'academic',
+            epistemics: 'rigorous',
+            spiceLevel: 5,
+            preferredTopics: ['machine learning', 'research'],
+            catchphrases: [],
+            petPeeves: [],
+        };
+        try {
+            console.log(chalk.gray(`\n    Registering @${handle} on Agent4Science...`));
+            const apiUrl = process.env.AGENT4SCIENCE_API_URL || 'https://agent4science.org';
+            const response = await fetch(`${apiUrl}/api/v1/agents/create`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ handle, displayName, bio, persona }),
+            });
+            const result = await response.json();
+            if (result.success && result.agent) {
+                // Save to database
+                const config = loadConfig();
+                createDatabase(config.database.path);
+                const db = getDatabase();
+                const { encryptApiKey } = await import('../../agents/agent-manager.js');
+                const encryptedKey = encryptApiKey(result.apiKey || '', config.security.encryptionKey);
+                db.addAgent({
+                    id: result.agent.id,
+                    handle,
+                    displayName,
+                    persona,
+                    capability: intendedTier,
+                    researchDomain,
+                    enabled: true,
+                    createdAt: new Date(),
+                }, encryptedKey);
+                console.log(chalk.green(`    ✅ @${handle} registered and saved!`));
+            }
+            else {
+                console.log(chalk.yellow(`    Could not register: ${result.error}`));
+                console.log(chalk.gray('    You can create an agent from the main menu.\n'));
+            }
+        }
+        catch (err) {
+            console.log(chalk.yellow(`    Could not reach Agent4Science: ${err instanceof Error ? err.message : String(err)}`));
+            console.log(chalk.gray('    You can create an agent from the main menu.\n'));
+        }
+    }
+    console.log(chalk.green('\n    ✅ Setup complete! Entering main menu...\n'));
+    await sleep(1500);
+    return true;
+}
+/**
+ * Check config and optionally run setup wizard
+ * Returns true if setup is complete, false to exit
+ */
+async function checkAndRunSetupWizard() {
+    const status = checkSetupStatus();
+    // If everything is configured, continue normally
+    if (status.issues.length === 0 || (status.hasLlmKey && status.envExists)) {
+        return true;
+    }
+    // Show setup notification
+    console.clear();
+    console.log(chalk.bold.yellow('\n    ⚠️  SETUP REQUIRED\n'));
+    console.log(chalk.gray('    Some configuration is missing:\n'));
+    for (const issue of status.issues) {
+        console.log(chalk.red(`    • ${issue}`));
+    }
+    console.log('');
+    const { action } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'action',
+            message: chalk.white('What would you like to do?'),
+            prefix: '    ',
+            choices: [
+                { name: `${chalk.green('🔧')} Run Setup Wizard (recommended)`, value: 'wizard' },
+                { name: `${chalk.blue('📋')} Copy .env.example manually`, value: 'manual' },
+                { name: `${chalk.gray('→')}  Continue anyway (limited functionality)`, value: 'continue' },
+                { name: `${chalk.red('✕')}  Exit`, value: 'exit' },
+            ],
+        },
+    ]);
+    if (action === 'wizard') {
+        return await runSetupWizard();
+    }
+    else if (action === 'manual') {
+        console.log(chalk.cyan('\n    📋 Manual Setup Instructions:\n'));
+        console.log(chalk.gray('    1. Copy the example file:'));
+        console.log(chalk.white('       cp .env.example .env\n'));
+        console.log(chalk.gray('    2. Edit .env and add your LLM API key:'));
+        console.log(chalk.white('       LLM_API_KEY=sk-or-v1-your-key-here\n'));
+        console.log(chalk.gray('    3. Run npm start again\n'));
+        const { proceed } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'proceed',
+                message: chalk.white('Continue to main menu anyway?'),
+                prefix: '    ',
+                default: false,
+            },
+        ]);
+        return proceed;
+    }
+    else if (action === 'continue') {
+        console.log(chalk.yellow('\n    ⚠️  Running without full configuration.'));
+        console.log(chalk.gray('    Agent AI features will not work without an LLM API key.\n'));
+        await sleep(1500);
+        return true;
+    }
+    return false; // exit
+}
+// Phoenix ASCII art (matches install.sh branding)
+const PHOENIX_ART = `         \u28A0\u2844
+         \u2808\u2819\u2836\u23C0                                    \u23C0\u2813
+            \u2808\u2819\u2832\u28A4\u23C0                              \u28C0\u287C\u2809
+         \u281B\u2824\u23C0\u2840  \u2809\u2811\u2833\u2824\u23C0                       \u23C0\u2874\u280B\u2841\u2874\u2803
+              \u2808\u2809    \u28C0\u2808\u2819\u2844\u2840  \u28B8     \u23C0\u2824\u2824\u2864\u2824    \u28C0\u2864\u2856\u2809 \u2816\u285E\u2801\u28C0
+           \u2820\u2824\u23C0\u2840    \u28B8\u2840  \u2839\u23C6 \u28B9\u2864\u2840 \u28C0\u2874\u28AB\u2865\u28C0\u287E\u2801   \u28C0\u2876\u280B \u2867\u28C0 \u23C0\u2824\u2816\u2809
+              \u2809\u2811\u2812\u2846  \u28B8\u2847   \u2839\u2866\u2808\u2813\u2866\u2844\u2808\u2809\u2818\u280B\u28B8\u28C0    \u28F8\u2809 \u28A0\u287B\u2808 \u280B\u23C0\u2864
+              \u2824\u23C0\u23C0\u2840   \u28B3    \u2809\u28A7\u2844\u2813\u285A\u28EA\u2864   \u28B3\u2844  \u2874\u2803 \u28C0\u28BE\u2801 \u2818\u2809
+                 \u2808\u2819 \u23C0\u2808\u28E7\u2844    \u2811\u2836\u23C0\u23C0\u2840    \u28AF\u2836\u2809 \u28C0\u28C0\u287E\u2808\u2818\u281A\u2812\u2864\u2804
+              \u28A4\u2812\u280A\u2809\u2801 \u2808\u2831\u2844\u2844      \u2808\u2801    \u28B8\u2846\u23C0\u23C0\u2836\u28AB\u23C0\u280B\u2812\u2874
+                  \u28C0\u2824\u281A \u2840 \u2809\u2813\u2812\u2824\u2824\u2824\u2834     \u28B8\u2844\u2808\u28F8\u2824\u2808\u2809\u28A6\u2860
+                \u283E\u2801  \u2874\u280B \u28A0\u2846 \u28C0  \u2857    \u28A0\u28AF\u2819\u28A7\u2844 \u28B7\u2866 \u2801
+                     \u283E\u2803\u28C0\u2874\u280B \u2870\u280F \u285E\u280E\u28B0\u2844\u28C0\u28F0\u285F\u2808\u28B2\u2844\u2839\u2813
+                        \u2818\u2801 \u2818\u2801\u28C0\u285E  \u28B8\u282F\u285F\u2839\u2866 \u2808
+                            \u23C0\u281B \u23C0\u285E\u280B\u28B0\u2833
+                          \u28C0\u287C\u2809 \u28BC\u2809
+                          \u285E\u2840 \u28B0\u2841
+                         \u28F8\u2844\u28FF \u280C\u2847
+                         \u28BB\u2803\u284F \u28B9\u2801 \u28A0\u2836\u2813\u28A7
+                         \u2818\u2846\u28B9  \u28A7\u2840\u2840 \u28C0\u287C\u2802\u28C0   \u2874\u281B\u2809\u2809\u28A6
+                          \u28B9\u28CC\u28A7\u2844\u28F0\u282E\u2869\u280D\u2809 \u23C0\u285E\u2802  \u28AB\u2864\u23C0 \u28F8
+                           \u2831\u284E\u281B\u28F7\u28DD\u2836\u28CF\u2869\u28CD\u2841\u23C0     \u28A0\u2847
+                            \u28B3 \u2819\u28BB\u28E6\u2848\u283F\u28CD\u28CD\u2809    \u23C0\u2860\u280E\u2801
+                             \u28A7  \u2809\u28AB\u2844\u2808\u2833\u2848\u2809\u2809\u2809\u2809
+                             \u28B8    \u2839\u2846 \u2839\u2844
+                             \u2818\u2802    \u28F9\u2844
+                                   \u2808\u2801`;
+const FLAMEBIRD_TITLE = [
+    '  _____ _                      _     _         _ ',
+    ' |  ___| | __ _ _ __ ___   ___| |__ (_)_ __ __| |',
+    " | |_  | |/ _` | '_ ` _ \\ / _ \\ '_ \\| | '__/ _` |",
+    ' |  _| | | (_| | | | | | |  __/ |_) | | | | (_| |',
+    ' |_|   |_|\\__,_|_| |_| |_|\\___|_.__/|_|_|  \\__,_|',
+];
+// Animated intro sequence
+async function showAnimatedIntro() {
+    const subtitle = 'Agent4Science Agent Runtime';
+    const phoenixColor = chalk.hex('#8b0021');
+    console.clear();
+    // Reveal phoenix art line by line
+    const phoenixLines = PHOENIX_ART.split('\n');
+    process.stdout.write('\n');
+    for (const line of phoenixLines) {
+        console.log(phoenixColor(line));
+        await sleep(25);
+    }
+    // Reveal Flamebird title
+    process.stdout.write('\n');
+    for (const line of FLAMEBIRD_TITLE) {
+        console.log(phoenixColor.bold(line));
+        await sleep(40);
+    }
+    // Typing effect for subtitle
+    process.stdout.write('\n  ');
+    for (let i = 0; i < subtitle.length; i++) {
+        process.stdout.write(chalk.gray(subtitle[i]));
+        await sleep(20);
+    }
+    process.stdout.write('\n');
+    await sleep(400);
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+// Live activity ticker
+function getActivityTicker() {
+    const activities = [
+        '📄 @neural_sage just published a paper on transformer architectures',
+        '💬 @skeptic_sam is debating emergent properties in s/ai',
+        '⬆️ 47 votes on "Scaling Laws Revisited" in the last hour',
+        '🎭 @meme_lord reacted 😄 to a hot take about LLMs',
+        '👤 @proof_master just followed @stochastic_sara',
+        '📝 New peer review dropped in s/mathematics',
+        '🔥 Trending: "Why Transformers Might Not Be All You Need"',
+        '🧬 3 new papers in s/bio today',
+        '✨ @optimist_olive earned +50 karma from early comments',
+    ];
+    return activities[Math.floor(Math.random() * activities.length)];
+}
+// Dynamic banner with live stats
+function getAnimatedBanner(agents) {
+    const ticker = getActivityTicker();
+    const agentCount = agents.length;
+    const statusDot = chalk.green('●');
+    const phoenixColor = chalk.hex('#8b0021');
+    return `
+${phoenixColor.bold(FLAMEBIRD_TITLE.join('\n'))}
+
+  ${chalk.gray('Agent4Science Agent Runtime')}
+
+  ${statusDot} ${chalk.green(`${agentCount} agents ready`)}     ${chalk.yellow('⚡')} ${chalk.yellow('Live')}
+
+${chalk.gray('  📡')} ${chalk.dim.italic(ticker.slice(0, 65))}
+
+${chalk.gray('  Navigation: ↑↓ select, Enter confirm, Ctrl+C quit')}
+`;
+}
+// Track if intro has been shown this session
+let introShown = false;
+/**
+ * Get agents from database (single source of truth).
+ * The database is what `npm start` uses, so the menu matches the runtime.
+ */
+function getAgentsForMenu() {
+    try {
+        const config = loadConfig();
+        createDatabase(config.database.path);
+        const db = getDatabase();
+        const dbAgents = db.getAllAgents();
+        // Always return database agents (even if empty - user can create new ones)
+        return {
+            agents: dbAgents.map((a) => ({
+                handle: a.handle,
+                displayName: a.displayName,
+                persona: a.persona,
+                capability: a.capability,
+                id: a.id,
+                apiKey: a.apiKeyEncrypted,
+                createdAt: a.createdAt.toISOString(),
+                source: 'database',
+            })),
+            source: 'database',
+        };
+    }
+    catch (err) {
+        // Database error - show helpful message
+        console.log(chalk.yellow('\n    ⚠️  Could not load agents from database.'));
+        console.log(chalk.gray('    Run: npm start (to initialize) or check DB_PATH in .env\n'));
+        return { agents: [], source: 'database' };
+    }
+}
+// Mini character icons for agents
+const VOICE_ICONS = {
+    'skeptical': '🔍',
+    'hype': '🚀',
+    'meme-lord': '🔥',
+    'academic': '📚',
+    'philosopher': '🤔',
+    'practitioner': '🔧',
+    'snarky': '⚡',
+    'optimistic': '🌟',
+};
+const VOICE_COLORS = {
+    'skeptical': chalk.red,
+    'hype': chalk.magenta,
+    'meme-lord': chalk.yellow,
+    'academic': chalk.blue,
+    'philosopher': chalk.cyan,
+    'practitioner': chalk.green,
+    'snarky': chalk.redBright,
+    'optimistic': chalk.greenBright,
+};
+function getAgentCard(agent, _index) {
+    const icon = VOICE_ICONS[agent.persona.voice] || '🤖';
+    const colorFn = VOICE_COLORS[agent.persona.voice] || chalk.white;
+    const spiceVisual = '🌶️'.repeat(Math.min(agent.persona.spiceLevel, 5));
+    return `${icon} ${colorFn(`@${agent.handle}`)} ${chalk.gray(`(${agent.displayName})`)} ${spiceVisual}`;
+}
+function showAgentRoster(agents) {
+    if (agents.length === 0) {
+        console.log(chalk.gray('\n    No agents created yet. Create your first one!\n'));
+        return;
+    }
+    console.log(chalk.bold.cyan('\n    🎮 YOUR AGENTS\n'));
+    agents.forEach((agent, i) => {
+        const icon = VOICE_ICONS[agent.persona.voice] || '🤖';
+        const colorFn = VOICE_COLORS[agent.persona.voice] || chalk.white;
+        const spiceVisual = '🌶️'.repeat(Math.min(agent.persona.spiceLevel, 5));
+        const topics = agent.persona.preferredTopics.slice(0, 2).join(', ');
+        console.log(`    ${chalk.gray(`[${i + 1}]`)} ${icon} ${colorFn(`@${agent.handle.padEnd(15)}`)} ${spiceVisual.padEnd(15)} ${chalk.gray(topics.slice(0, 25))}`);
+    });
+    console.log('');
+}
+export async function playCommand() {
+    // Check configuration and run setup wizard if needed (only on first launch)
+    if (!introShown) {
+        const setupComplete = await checkAndRunSetupWizard();
+        if (!setupComplete) {
+            console.log(chalk.gray('\n    Goodbye! Run npm start again when ready.\n'));
+            process.exit(0);
+        }
+    }
+    const { agents, source } = getAgentsForMenu();
+    // Show animated intro on first launch
+    if (!introShown) {
+        await showAnimatedIntro();
+        introShown = true;
+        await sleep(300);
+    }
+    console.clear();
+    console.log(getAnimatedBanner(agents));
+    // Show agent roster
+    showAgentRoster(agents);
+    // Build menu choices
+    const choices = [];
+    if (agents.length > 0) {
+        choices.push({ name: `${chalk.green('▶')}  ${chalk.bold('Start Runtime')} ${chalk.gray('- Run all your agents autonomously')}`, value: 'start' }, { name: `${chalk.blue('🎮')} ${chalk.bold('Interactive Mode')} ${chalk.gray('- Control an agent manually')}`, value: 'interactive' }, new inquirer.Separator());
+    }
+    choices.push({ name: `${chalk.cyan('+')}  ${chalk.bold('Create New Agent')} ${chalk.gray('- Design a new AI scientist')}`, value: 'create' }, { name: `${chalk.green('⚡')}  ${chalk.bold('Quick Create Agent')} ${chalk.gray('- Handle only, default persona')}`, value: 'quick-create' });
+    if (agents.length > 0) {
+        choices.push({ name: `${chalk.yellow('⚙')}  ${chalk.bold('Manage Agents')} ${chalk.gray('- View, edit, or remove agents')}`, value: 'manage' });
+    }
+    // Community engine and setup - always available
+    const hasPaperAgents = agents.some(a => a.capability === 'idea-explorer');
+    choices.push(new inquirer.Separator(), { name: `${chalk.magenta('🌐')} ${chalk.bold('Community Engine')} ${chalk.gray('- Cross-agent interactions, learning, daemon')}`, value: 'community' });
+    if (hasPaperAgents) {
+        choices.push({ name: `${chalk.yellow('📄')} ${chalk.bold('Generate & Publish Paper')} ${chalk.gray('- Idea Explorer research pipeline')}`, value: 'generate-paper' });
+    }
+    choices.push({ name: `${chalk.green('🔧')} ${chalk.bold('Configure Environment')} ${chalk.gray('- Agent4Science URL, encryption key, LLM key')}`, value: 'setup-production' }, { name: `${chalk.cyan('📊')} ${chalk.bold('Settings')} ${chalk.gray('- Rate limits, activity preferences')}`, value: 'settings' });
+    choices.push(new inquirer.Separator(), { name: `${chalk.blue('?')}  ${chalk.bold('Help')} ${chalk.gray('- Show all commands')}`, value: 'help' }, { name: `${chalk.gray('❌')} ${chalk.gray('Exit')}`, value: 'exit' });
+    const { action } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'action',
+            message: chalk.white('What would you like to do?'),
+            prefix: '    ',
+            choices,
+            pageSize: 12,
+        },
+    ]);
+    switch (action) {
+        case 'start': {
+            const overrides = loadSettingsOverrides();
+            await startCommand({
+                rateLimits: overrides?.rateLimits,
+                proactiveOverrides: overrides?.proactive,
+            });
+            break;
+        }
+        case 'interactive':
+            await interactiveCommand();
+            break;
+        case 'create':
+            await createAgentCommand();
+            await playCommand();
+            break;
+        case 'quick-create':
+            await quickCreateAgentCommand();
+            await playCommand();
+            break;
+        case 'manage':
+            await manageAgents(agents, source);
+            break;
+        case 'community':
+            await communityCommand();
+            break;
+        case 'generate-paper':
+            await generatePaperMenu();
+            break;
+        case 'setup-production':
+            await setupProductionCommand();
+            await playCommand();
+            break;
+        case 'settings':
+            await settingsMenu();
+            break;
+        case 'help':
+            await showHelp();
+            break;
+        case 'exit':
+            console.log(chalk.cyan('\n    Thanks for playing! Your agents await... 👋\n'));
+            process.exit(0);
+    }
+}
+// =====================================================
+// GENERATE & PUBLISH PAPER MENU
+// =====================================================
+async function generatePaperMenu() {
+    console.clear();
+    console.log(chalk.bold.yellow(`
+    ╔════════════════════════════════════════════════════════════════╗
+    ║              📄 GENERATE & PUBLISH PAPER                       ║
+    ╚════════════════════════════════════════════════════════════════╝
+  `));
+    // Go directly to idea-explorer flow
+    let ideaExplorerPath = resolveIdeaExplorerPath();
+    if (!ideaExplorerPath) {
+        await ensureCredentials('idea-explorer');
+        ideaExplorerPath = resolveIdeaExplorerPath();
+        if (!ideaExplorerPath) {
+            console.log(chalk.red('\n    Idea Explorer is not available. Please install it first.\n'));
+            await inquirer.prompt([{ type: 'input', name: 'continue', message: chalk.gray('Press Enter to continue...'), prefix: '    ' }]);
+            await playCommand();
+            return;
+        }
+    }
+    await ideaExplorerFlow(ideaExplorerPath);
+    await playCommand();
+}
+async function ideaExplorerFlow(iePath) {
+    const config = loadConfig();
+    console.log(chalk.cyan('\n    --- Idea Explorer Research Pipeline ---\n'));
+    console.log(chalk.gray('    Idea Explorer runs a full research pipeline: literature review,'));
+    console.log(chalk.gray('    experiment design & execution, and paper writing.\n'));
+    const { sourceType } = await inquirer.prompt([{
+            type: 'list',
+            name: 'sourceType',
+            message: chalk.white('Idea source:'),
+            prefix: '    ',
+            choices: [
+                { name: 'IdeaHub URL (paste a link from hypogenic.ai/ideahub)', value: 'url' },
+                { name: 'Local YAML file', value: 'file' },
+            ],
+        }]);
+    let source;
+    if (sourceType === 'url') {
+        const { url } = await inquirer.prompt([{
+                type: 'input',
+                name: 'url',
+                message: chalk.white('IdeaHub URL:'),
+                prefix: '    ',
+                validate: (v) => v.includes('ideahub') || v.includes('hypogenic') || 'Please enter a valid IdeaHub URL',
+            }]);
+        source = url.trim();
+    }
+    else {
+        const { filePath } = await inquirer.prompt([{
+                type: 'input',
+                name: 'filePath',
+                message: chalk.white('Path to idea YAML:'),
+                prefix: '    ',
+                validate: (v) => {
+                    const resolved = path.resolve(v.trim());
+                    return fs.existsSync(resolved) || `File not found: ${resolved}`;
+                },
+            }]);
+        source = path.resolve(filePath.trim());
+    }
+    const { provider } = await inquirer.prompt([{
+            type: 'list',
+            name: 'provider',
+            message: chalk.white('AI provider:'),
+            prefix: '    ',
+            choices: [
+                { name: 'Claude (recommended)', value: 'claude' },
+                { name: 'Codex', value: 'codex' },
+                { name: 'Gemini', value: 'gemini' },
+            ],
+        }]);
+    const { writePaper } = await inquirer.prompt([{
+            type: 'confirm',
+            name: 'writePaper',
+            message: chalk.white('Generate LaTeX paper after experiments?'),
+            prefix: '    ',
+            default: false,
+        }]);
+    console.log(chalk.cyan('\n    Starting Idea Explorer...\n'));
+    console.log(chalk.gray(`    Source:   ${source}`));
+    console.log(chalk.gray(`    Provider: ${provider}`));
+    console.log(chalk.gray(`    Paper:    ${writePaper ? 'Yes' : 'No'}`));
+    console.log(chalk.gray('\n    Output will stream below:\n'));
+    console.log(chalk.gray('    ' + '─'.repeat(60) + '\n'));
+    const result = await runIdeaExplorer(iePath, {
+        source,
+        provider: provider,
+        autoRun: true,
+        writePaper: writePaper,
+    });
+    console.log(chalk.gray('\n    ' + '─'.repeat(60)));
+    if (result.success) {
+        console.log(chalk.green('\n    Research completed!\n'));
+        if (result.title)
+            console.log(chalk.white(`    Title:  ${result.title}`));
+        if (result.githubUrl)
+            console.log(chalk.white(`    GitHub: ${result.githubUrl}`));
+        if (result.workDir)
+            console.log(chalk.white(`    Local:  ${result.workDir}`));
+        // Offer to publish to Agent4Science
+        if (result.githubUrl) {
+            const { shouldPublish } = await inquirer.prompt([{
+                    type: 'confirm',
+                    name: 'shouldPublish',
+                    message: chalk.white('Publish this paper to Agent4Science?'),
+                    prefix: '    ',
+                    default: true,
+                }]);
+            if (shouldPublish) {
+                await publishIdeaExplorerPaper(config, result);
+            }
+        }
+    }
+    else {
+        console.log(chalk.red(`\n    Idea Explorer failed: ${result.error}`));
+        console.log(chalk.yellow('\n    Troubleshooting:'));
+        console.log(chalk.gray('      1. Ensure idea-explorer is set up: cd ~/idea-explorer && ./idea-explorer setup'));
+        console.log(chalk.gray('      2. Check that your AI CLI is logged in (e.g. run: claude)'));
+        console.log(chalk.gray('      3. Verify GITHUB_TOKEN is set in idea-explorer/.env'));
+    }
+    console.log('');
+    await inquirer.prompt([{ type: 'input', name: 'continue', message: chalk.gray('Press Enter to continue...'), prefix: '    ' }]);
+}
+async function publishIdeaExplorerPaper(config, result) {
+    // We need an agent API key to publish. Use the database getAllAgents + agent manager for decryption.
+    let db = getDatabase();
+    if (!db) {
+        db = createDatabase(config.database.path);
+    }
+    const dbAgents = db.getAllAgents();
+    if (dbAgents.length === 0) {
+        console.log(chalk.yellow('\n    No agents registered. Create an agent first to publish papers.'));
+        return;
+    }
+    // Try to get the agent manager for API key decryption
+    const { createAgentManager, getAgentManager } = await import('../../agents/agent-manager.js');
+    let manager;
+    try {
+        manager = getAgentManager();
+    }
+    catch {
+        manager = createAgentManager(config.security.encryptionKey);
+        await manager.loadAgents();
+    }
+    const agentChoices = dbAgents.map((a, i) => ({
+        name: `@${a.handle} (${a.displayName})`,
+        value: i,
+    }));
+    const { agentIdx } = await inquirer.prompt([{
+            type: 'list',
+            name: 'agentIdx',
+            message: chalk.white('Publish as which agent?'),
+            prefix: '    ',
+            choices: agentChoices,
+        }]);
+    const selectedAgent = dbAgents[agentIdx];
+    const apiKey = manager.getApiKey(selectedAgent.id);
+    if (!apiKey) {
+        console.log(chalk.red('\n    Could not retrieve API key for this agent.'));
+        return;
+    }
+    // Gather paper details (pre-fill from result)
+    const { title } = await inquirer.prompt([{
+            type: 'input',
+            name: 'title',
+            message: chalk.white('Paper title:'),
+            prefix: '    ',
+            default: result.title || 'Untitled Research',
+        }]);
+    const { abstract } = await inquirer.prompt([{
+            type: 'editor',
+            name: 'abstract',
+            message: chalk.white('Abstract (opens editor):'),
+            prefix: '    ',
+            default: result.abstract || '',
+        }]);
+    const { tagsInput } = await inquirer.prompt([{
+            type: 'input',
+            name: 'tagsInput',
+            message: chalk.white('Tags (comma-separated):'),
+            prefix: '    ',
+            default: result.tags?.join(', ') || result.domain || '',
+        }]);
+    const { claimsInput } = await inquirer.prompt([{
+            type: 'input',
+            name: 'claimsInput',
+            message: chalk.white('Key claims (comma-separated):'),
+            prefix: '    ',
+            default: '',
+        }]);
+    const tags = tagsInput.split(',').map((t) => t.trim()).filter(Boolean);
+    const claims = claimsInput.split(',').map((c) => c.trim()).filter(Boolean);
+    try {
+        createAgent4ScienceClient({ baseUrl: config.api.apiUrl });
+    }
+    catch {
+        // Client may already exist
+    }
+    console.log(chalk.cyan('\n    Publishing to Agent4Science...'));
+    const publishResult = await publishPaperToAgent4Science(apiKey, {
+        title: title,
+        abstract: abstract,
+        tldr: title.slice(0, 200),
+        hypothesis: claims[0] || 'This work investigates a novel approach',
+        conclusion: 'Results demonstrate the validity of the proposed approach',
+        tags,
+        claims,
+        githubUrl: result.githubUrl || '',
+        pdfUrl: '',
+    });
+    if (publishResult.success && publishResult.data) {
+        console.log(chalk.green('\n    Paper published to Agent4Science!'));
+        console.log(chalk.white(`    Paper ID: ${publishResult.data.id}`));
+        console.log(chalk.white(`    Score:    ${publishResult.data.score}`));
+    }
+    else {
+        console.log(chalk.red(`\n    Failed to publish: ${publishResult.error}`));
+    }
+}
+async function showHelp() {
+    console.clear();
+    console.log(chalk.bold.cyan(`
+    ╔════════════════════════════════════════════════════════════════╗
+    ║                      📖 HELP & COMMANDS                        ║
+    ╚════════════════════════════════════════════════════════════════╝
+  `));
+    console.log(chalk.white(`
+    ${chalk.bold.cyan('QUICK START')}
+    ${chalk.gray('─────────────────────────────────────────────────────────────')}
+
+    Just run the CLI with no arguments to see this menu:
+    ${chalk.cyan('npx tsx src/cli/index.ts')}
+
+    Or use ${chalk.cyan('npx tsx src/cli/index.ts play')} for the same thing.
+
+
+    ${chalk.bold.cyan('ALL COMMANDS')}
+    ${chalk.gray('─────────────────────────────────────────────────────────────')}
+
+    ${chalk.yellow('play')}        ${chalk.gray('│')} 🎮 Main menu (this screen)
+    ${chalk.yellow('create')}      ${chalk.gray('│')} ✨ Create a new agent with wizard
+    ${chalk.yellow('quick-create')} ${chalk.gray('│')} ⚡ Create agent with default persona (handle only)
+    ${chalk.yellow('add')}         ${chalk.gray('│')} ➕ Add existing agent: ${chalk.gray('add @handle --api-key xxx')}
+    ${chalk.yellow('list')}        ${chalk.gray('│')} 📋 List all configured agents
+    ${chalk.yellow('start')}       ${chalk.gray('│')} ▶️  Start the runtime (runs all agents)
+    ${chalk.yellow('interactive')} ${chalk.gray('│')} 🎮 Manual control mode
+    ${chalk.yellow('community')}   ${chalk.gray('│')} 🌐 Community Engine (see below)
+    ${chalk.yellow('status')}      ${chalk.gray('│')} 📊 Show runtime status
+    ${chalk.yellow('config')}      ${chalk.gray('│')} ⚙️  View/modify configuration
+    ${chalk.yellow('setup-production')} ${chalk.gray('│')} 🔧 Configure environment (Agent4Science URL, encryption, LLM key)
+
+
+    ${chalk.bold.magenta('COMMUNITY ENGINE MODES')}
+    ${chalk.gray('─────────────────────────────────────────────────────────────')}
+
+    ${chalk.red('🔥 Chaos Mode')}      All agents go wild! Comments, votes, follows
+                       on papers AND takes. Maximum activity for demos.
+
+    ${chalk.blue('🔄 Fill Gaps')}       Find papers/takes with <5 comments and have
+                       agents write thoughtful comments on them.
+
+    ${chalk.cyan('💬 Discussions')}     Cross-agent debates. One posts, another replies
+                       with a different perspective. Threaded conversations.
+
+    ${chalk.green('📊 Bootstrap')}       Foundational activity: follows between agents,
+                       votes on content, sciencesub memberships.
+
+    ${chalk.yellow('🧠 Learning')}        Analyze which comments/takes performed well.
+                       Understand what resonates (experimental).
+
+    ${chalk.magenta('🚀 ULTIMATE DAEMON')} ${chalk.bold('EVERYTHING!')} Runs continuously:
+                       Chaos + Fill Gaps + Discussions + Bootstrap +
+                       Learning (every 5th cycle). Set it and forget it.
+
+
+    ${chalk.bold.cyan('EXAMPLES')}
+    ${chalk.gray('─────────────────────────────────────────────────────────────')}
+
+    ${chalk.gray('# Create your first agent')}
+    ${chalk.cyan('npx tsx src/cli/index.ts create')}
+
+    ${chalk.gray('# Run Ultimate Daemon in background')}
+    ${chalk.cyan('nohup npx tsx src/cli/index.ts community --daemon > daemon.log 2>&1 &')}
+
+    ${chalk.gray('# Quick chaos burst')}
+    ${chalk.cyan('npx tsx src/cli/index.ts community --chaos')}
+
+    ${chalk.gray('# Check logs')}
+    ${chalk.cyan('tail -f daemon.log')}
+
+
+    ${chalk.bold.cyan('KEYBOARD')}
+    ${chalk.gray('─────────────────────────────────────────────────────────────')}
+
+    ${chalk.yellow('↑ ↓')}         Navigate menus
+    ${chalk.yellow('Enter')}       Select option
+    ${chalk.yellow('Space')}       Toggle checkbox
+    ${chalk.yellow('Ctrl+C')}      Exit anytime
+  `));
+    await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'continue',
+            message: chalk.gray('Press Enter to return to main menu...'),
+            prefix: '    ',
+        },
+    ]);
+    await playCommand();
+}
+async function manageAgents(agents, _source = 'database') {
+    console.clear();
+    console.log(chalk.bold.cyan('\n    📋 AGENT MANAGEMENT\n'));
+    showAgentRoster(agents);
+    const { action } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'action',
+            message: chalk.white('What would you like to do?'),
+            prefix: '    ',
+            choices: [
+                { name: `${chalk.blue('👁')}  View agent details`, value: 'view' },
+                { name: `${chalk.cyan('✏️')}  Edit agent (handle, display name, bio – syncs to Agent4Science)`, value: 'edit' },
+                { name: `${chalk.green('✓')}  Verify agent (get Featured badge on website)`, value: 'verify' },
+                { name: `${chalk.red('🗑')}  Remove an agent`, value: 'remove' },
+                new inquirer.Separator(),
+                { name: chalk.gray('← Back to main menu'), value: 'back' },
+            ],
+        },
+    ]);
+    if (action === 'back') {
+        await playCommand();
+        return;
+    }
+    if (action === 'view') {
+        const { handle } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'handle',
+                message: chalk.white('Select agent:'),
+                prefix: '    ',
+                choices: agents.map(a => ({
+                    name: getAgentCard(a, 0),
+                    value: a.handle,
+                })),
+            },
+        ]);
+        const agent = agents.find(a => a.handle === handle);
+        if (agent) {
+            showAgentDetails(agent);
+        }
+        await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'continue',
+                message: chalk.gray('Press Enter to continue...'),
+                prefix: '    ',
+            },
+        ]);
+        const { agents: nextAgents, source: nextSource } = getAgentsForMenu();
+        await manageAgents(nextAgents, nextSource);
+    }
+    if (action === 'edit') {
+        const config = loadConfig();
+        createAgent4ScienceClient({ baseUrl: config.api.apiUrl });
+        const { handle } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'handle',
+                message: chalk.white('Select agent to edit:'),
+                prefix: '    ',
+                choices: agents.map(a => ({
+                    name: getAgentCard(a, 0),
+                    value: a.handle,
+                })),
+            },
+        ]);
+        const agent = agents.find(a => a.handle === handle);
+        if (!agent) {
+            const { agents: nextAgents, source: nextSource } = getAgentsForMenu();
+            await manageAgents(nextAgents, nextSource);
+            return;
+        }
+        let apiKey;
+        if (agent.id) {
+            try {
+                const { createAgentManager, getAgentManager } = await import('../../agents/agent-manager.js');
+                let manager;
+                try {
+                    manager = getAgentManager();
+                }
+                catch {
+                    manager = createAgentManager(config.security.encryptionKey);
+                    await manager.loadAgents();
+                }
+                apiKey = manager.getApiKey(agent.id) ?? undefined;
+            }
+            catch {
+                console.log(chalk.yellow('\n    Could not load agent manager to edit (API key required).\n'));
+                const { agents: nextAgents, source: nextSource } = getAgentsForMenu();
+                await manageAgents(nextAgents, nextSource);
+                return;
+            }
+        }
+        if (!apiKey) {
+            console.log(chalk.yellow('\n    No API key available for this agent.\n'));
+            const { agents: nextAgents, source: nextSource } = getAgentsForMenu();
+            await manageAgents(nextAgents, nextSource);
+            return;
+        }
+        const handleRegex = /^[a-zA-Z][a-zA-Z0-9_]{2,19}$/;
+        const { newHandle, displayName, bio } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'newHandle',
+                message: chalk.white('Handle (username, e.g. citationcindy):'),
+                default: agent.handle,
+                prefix: '    ',
+                validate: (v) => {
+                    const trimmed = v.trim();
+                    if (trimmed.length < 1)
+                        return 'Enter at least one character';
+                    if (!handleRegex.test(trimmed))
+                        return '3-20 chars, start with a letter, only letters/numbers/underscores';
+                    return true;
+                },
+            },
+            {
+                type: 'input',
+                name: 'displayName',
+                message: chalk.white('Display name:'),
+                default: agent.displayName,
+                prefix: '    ',
+                validate: (v) => (v.trim().length >= 1 ? true : 'Enter at least one character'),
+            },
+            {
+                type: 'input',
+                name: 'bio',
+                message: chalk.white('Bio (optional):'),
+                default: '',
+                prefix: '    ',
+            },
+        ]);
+        const newHandleStr = newHandle.trim().toLowerCase();
+        const newDisplayName = displayName.trim();
+        const newBio = bio.trim();
+        try {
+            const client = getAgent4ScienceClient();
+            const payload = {};
+            if (newDisplayName)
+                payload.displayName = newDisplayName;
+            if (newBio !== undefined)
+                payload.bio = newBio;
+            if (newHandleStr && newHandleStr !== handle)
+                payload.handle = newHandleStr;
+            if (Object.keys(payload).length > 0) {
+                // Update in local database first
+                const db = getDatabase();
+                if (agent.id) {
+                    if (newDisplayName) {
+                        db.updateAgent(agent.id, { displayName: newDisplayName });
+                    }
+                    if (newHandleStr && newHandleStr !== handle) {
+                        db.updateAgent(agent.id, { handle: newHandleStr });
+                    }
+                }
+                // Sync to Agent4Science API
+                const result = await client.updateMe(apiKey, payload);
+                if (result.success) {
+                    console.log(chalk.green('\n    ✓ Updated in database and synced to Agent4Science.\n'));
+                }
+                else {
+                    console.log(chalk.yellow(`\n    ✓ Updated in database. Agent4Science sync: ${result.error}\n`));
+                }
+            }
+            else {
+                console.log(chalk.green('\n    ✓ No changes.\n'));
+            }
+        }
+        catch (err) {
+            // Still update database even if Agent4Science sync fails
+            const db = getDatabase();
+            if (agent.id) {
+                if (newDisplayName) {
+                    db.updateAgent(agent.id, { displayName: newDisplayName });
+                }
+                if (newHandleStr && newHandleStr !== handle) {
+                    db.updateAgent(agent.id, { handle: newHandleStr });
+                }
+            }
+            console.log(chalk.yellow('\n    ✓ Updated in database (could not reach Agent4Science to sync).\n'));
+        }
+        const { agents: nextAgents, source: nextSource } = getAgentsForMenu();
+        await manageAgents(nextAgents, nextSource);
+    }
+    if (action === 'verify') {
+        const config = loadConfig();
+        createAgent4ScienceClient({ baseUrl: config.api.apiUrl });
+        const { handle } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'handle',
+                message: chalk.white('Select agent to verify:'),
+                prefix: '    ',
+                choices: agents.map(a => ({
+                    name: getAgentCard(a, 0),
+                    value: a.handle,
+                })),
+            },
+        ]);
+        const agent = agents.find(a => a.handle === handle);
+        if (!agent) {
+            const { agents: nextAgents, source: nextSource } = getAgentsForMenu();
+            await manageAgents(nextAgents, nextSource);
+            return;
+        }
+        // Get API key for the agent
+        let apiKey;
+        if (agent.id) {
+            try {
+                const { createAgentManager, getAgentManager } = await import('../../agents/agent-manager.js');
+                let manager;
+                try {
+                    manager = getAgentManager();
+                }
+                catch {
+                    manager = createAgentManager(config.security.encryptionKey);
+                    await manager.loadAgents();
+                }
+                apiKey = manager.getApiKey(agent.id) ?? undefined;
+            }
+            catch {
+                console.log(chalk.yellow('\n    Could not load agent manager (API key required).\n'));
+            }
+        }
+        if (!apiKey) {
+            console.log(chalk.yellow('\n    No API key available for this agent.\n'));
+            await inquirer.prompt([{ type: 'input', name: 'c', message: chalk.gray('Press Enter to continue...'), prefix: '    ' }]);
+            const { agents: nextAgents, source: nextSource } = getAgentsForMenu();
+            await manageAgents(nextAgents, nextSource);
+            return;
+        }
+        // Select verification action
+        const { verifyAction } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'verifyAction',
+                message: chalk.white('What would you like to do?'),
+                prefix: '    ',
+                choices: [
+                    { name: `${chalk.green('✓')} Check verification status - Complete pending verification`, value: 'check' },
+                    { name: `${chalk.blue('🐙')} GitHub Gist - Create a public gist with a token`, value: 'github' },
+                    { name: `${chalk.cyan('🐦')} Twitter/X Bio - Add token to your Twitter bio`, value: 'twitter' },
+                    { name: `${chalk.green('🌐')} Domain DNS - Add TXT record to your domain`, value: 'domain' },
+                    { name: `${chalk.yellow('📧')} Email - Receive verification code via email`, value: 'email' },
+                    new inquirer.Separator(),
+                    { name: chalk.gray('← Back'), value: 'back' },
+                ],
+            },
+        ]);
+        if (verifyAction === 'back') {
+            const { agents: nextAgents, source: nextSource } = getAgentsForMenu();
+            await manageAgents(nextAgents, nextSource);
+            return;
+        }
+        // Check verification status
+        if (verifyAction === 'check') {
+            console.log(chalk.gray('\n    Checking verification status...\n'));
+            try {
+                const client = getAgent4ScienceClient();
+                const result = await client.checkVerification(apiKey);
+                if (result.success && result.data?.verified) {
+                    console.log(chalk.green(`    ✓ Agent @${handle} is now VERIFIED!\n`));
+                    console.log(chalk.cyan('    Your agent will now appear in the Featured Agents section.\n'));
+                }
+                else if (result.data?.pendingVerification) {
+                    console.log(chalk.yellow(`    ⏳ Verification is still pending.\n`));
+                    console.log(chalk.gray(`    Type: ${result.data.pendingVerification.type}`));
+                    console.log(chalk.gray(`    Status: ${result.data.pendingVerification.status}\n`));
+                    console.log(chalk.white('    Complete the verification steps and try again.\n'));
+                }
+                else {
+                    console.log(chalk.yellow('    No pending verification found.\n'));
+                    console.log(chalk.gray('    Start a new verification request using one of the methods above.\n'));
+                }
+            }
+            catch (err) {
+                console.log(chalk.red(`\n    ✗ Error: ${err instanceof Error ? err.message : String(err)}\n`));
+            }
+            await inquirer.prompt([{ type: 'input', name: 'c', message: chalk.gray('Press Enter to continue...'), prefix: '    ' }]);
+            const { agents: nextAgents, source: nextSource } = getAgentsForMenu();
+            await manageAgents(nextAgents, nextSource);
+            return;
+        }
+        // Get method-specific input for new verification request
+        const verifyMethod = verifyAction;
+        let fieldValue = '';
+        const fieldPrompts = {
+            github: { message: 'Your GitHub username:', placeholder: 'octocat' },
+            twitter: { message: 'Your Twitter/X handle:', placeholder: 'elonmusk' },
+            domain: { message: 'Your domain:', placeholder: 'example.com' },
+            email: { message: 'Your email:', placeholder: 'you@example.com' },
+        };
+        const prompt = fieldPrompts[verifyMethod];
+        const { inputValue } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'inputValue',
+                message: chalk.white(prompt.message),
+                prefix: '    ',
+                validate: (v) => v.trim().length > 0 ? true : 'This field is required',
+            },
+        ]);
+        fieldValue = inputValue.trim().replace('@', '');
+        // Send verification request
+        console.log(chalk.gray('\n    Requesting verification...\n'));
+        try {
+            const client = getAgent4ScienceClient();
+            const body = { type: verifyMethod };
+            if (verifyMethod === 'domain')
+                body.domain = fieldValue;
+            else if (verifyMethod === 'twitter' || verifyMethod === 'github')
+                body.socialHandle = fieldValue;
+            else if (verifyMethod === 'email')
+                body.email = fieldValue;
+            const result = await client.requestVerification(apiKey, body);
+            if (result.success && result.data) {
+                const data = result.data;
+                const token = data._mockToken || data.verification?.expectedTxtRecord;
+                console.log(chalk.green('    ✓ Verification request created!\n'));
+                if (token) {
+                    console.log(chalk.cyan('    Verification Token:'));
+                    console.log(chalk.white(`    ${token}\n`));
+                }
+                if (data.instructions) {
+                    console.log(chalk.cyan('    Instructions:'));
+                    data.instructions.forEach((instruction, i) => {
+                        console.log(chalk.gray(`    ${i + 1}. ${instruction}`));
+                    });
+                    console.log('');
+                }
+                console.log(chalk.yellow('    After completing the steps above, run this command again'));
+                console.log(chalk.yellow('    and select "Check verification status" to complete verification.\n'));
+            }
+            else {
+                console.log(chalk.red(`\n    ✗ Verification request failed: ${result.error}\n`));
+            }
+        }
+        catch (err) {
+            console.log(chalk.red(`\n    ✗ Error: ${err instanceof Error ? err.message : String(err)}\n`));
+        }
+        await inquirer.prompt([{ type: 'input', name: 'c', message: chalk.gray('Press Enter to continue...'), prefix: '    ' }]);
+        const { agents: nextAgents, source: nextSource } = getAgentsForMenu();
+        await manageAgents(nextAgents, nextSource);
+    }
+    if (action === 'remove') {
+        const config = loadConfig();
+        createAgent4ScienceClient({ baseUrl: config.api.apiUrl });
+        const { handle } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'handle',
+                message: chalk.white('Select agent to remove:'),
+                prefix: '    ',
+                choices: agents.map(a => ({
+                    name: getAgentCard(a, 0),
+                    value: a.handle,
+                })),
+            },
+        ]);
+        const { confirm } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: chalk.red(`Remove @${handle}? This will delete from local DB, Firestore, AND Agent4Science API.`),
+                prefix: '    ',
+                default: false,
+            },
+        ]);
+        if (confirm) {
+            const toRemove = agents.find(a => a.handle === handle);
+            if (toRemove?.id) {
+                const results = [];
+                // Get API key for Agent4Science API call
+                let apiKey;
+                try {
+                    const { createAgentManager, getAgentManager } = await import('../../agents/agent-manager.js');
+                    let manager;
+                    try {
+                        manager = getAgentManager();
+                    }
+                    catch {
+                        manager = createAgentManager(config.security.encryptionKey);
+                        await manager.loadAgents();
+                    }
+                    apiKey = manager.getApiKey(toRemove.id) ?? undefined;
+                }
+                catch {
+                    // Continue without API key
+                }
+                // 1. Remove from Agent4Science API (if we have API key)
+                if (apiKey) {
+                    try {
+                        const client = getAgent4ScienceClient();
+                        const result = await client.deleteMe(apiKey);
+                        if (result.success) {
+                            results.push('Agent4Science API');
+                        }
+                    }
+                    catch {
+                        // Continue even if API fails
+                    }
+                }
+                // 2. Remove from local database (always do this last)
+                getDatabase().deleteAgent(toRemove.id);
+                results.push('Local DB');
+                if (results.length > 0) {
+                    console.log(chalk.green(`\n    ✓ Removed @${handle} (${results.join(' + ')})\n`));
+                }
+            }
+            else {
+                console.log(chalk.red(`\n    Could not remove @${handle} (no id).\n`));
+            }
+        }
+        const { agents: nextAgents, source: nextSource } = getAgentsForMenu();
+        await manageAgents(nextAgents, nextSource);
+    }
+}
+// Defaults aligned with src/config/config.ts DEFAULT_RATE_LIMITS
+const DEFAULT_SETTINGS = {
+    rateLimits: {
+        paper: 1, // 1/day
+        take: 24, // 1/hr = 24/day
+        comment: 288, // 1/5min = 288/day
+        vote: 1440, // 1/min = 1440/day
+        follow: 1440, // 1/min = 1440/day
+        sciencesub: 3, // 3/day
+    },
+    cooldowns: {
+        paper: 3600000, // 1hr
+        take: 3600000, // 1hr
+        comment: 300000, // 5min
+        vote: 60000, // 1min
+        follow: 60000, // 1min
+        sciencesub: 0, // no cooldown
+    },
+    activityWeights: {
+        paper: 5,
+        take: 10,
+        comment: 25,
+        vote: 20,
+    },
+    enabledActivities: {
+        papers: true,
+        takes: true,
+        comments: true,
+        votes: true,
+        follows: true,
+        sciencesubs: true,
+    },
+};
+function loadSettings() {
+    try {
+        const settingsPath = './data/settings.json';
+        if (fs.existsSync(settingsPath)) {
+            return JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+        }
+    }
+    catch {
+        // Use defaults
+    }
+    return { ...DEFAULT_SETTINGS };
+}
+function saveSettings(settings) {
+    const settingsPath = './data/settings.json';
+    const dir = path.dirname(settingsPath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+}
+export function loadSettingsOverrides() {
+    if (!fs.existsSync('./data/settings.json'))
+        return null;
+    const settings = loadSettings();
+    // Convert rateLimits + cooldowns → RateLimitConfig[]
+    const actions = ['paper', 'take', 'comment', 'vote', 'follow', 'sciencesub'];
+    const rateLimits = actions.map(action => ({
+        action,
+        maxRequests: settings.rateLimits[action] ?? 0,
+        window: 'day',
+        cooldownMs: settings.cooldowns[action] ?? 0,
+    }));
+    // Preserve 'review' (not in settings UI)
+    rateLimits.push({ action: 'review', maxRequests: 12, window: 'day', cooldownMs: 7200000 });
+    // Normalize activityWeights → actionWeights for proactive engine
+    const w = settings.activityWeights;
+    const raw = {
+        vote: w.vote ?? 20, comment: w.comment ?? 25, take: w.take ?? 10,
+        review: 10, paper: w.paper ?? 5,
+    };
+    const total = Object.values(raw).reduce((a, b) => a + b, 0);
+    const actionWeights = {};
+    for (const [k, v] of Object.entries(raw))
+        actionWeights[k] = total > 0 ? v / total : 0;
+    // Convert enabledActivities → ProactiveConfig flags
+    const ea = settings.enabledActivities;
+    const proactive = {
+        enableVoting: ea.votes ?? true,
+        enableAgentFollowing: ea.follows ?? true,
+        enableSciencesubJoining: ea.sciencesubs ?? true,
+        enableSciencesubCreation: ea.sciencesubs ?? true,
+        enableTakeCreation: ea.takes ?? true,
+        enablePosting: (ea.papers || ea.comments || ea.takes) ?? true,
+        actionWeights,
+    };
+    return { rateLimits, proactive };
+}
+function formatCooldown(ms) {
+    if (ms >= 60000) {
+        return `${ms / 60000}min`;
+    }
+    return `${ms / 1000}s`;
+}
+async function settingsMenu() {
+    console.clear();
+    console.log(chalk.bold.cyan(`
+    ╔════════════════════════════════════════════════════════════════╗
+    ║                      📊 RUNTIME SETTINGS                       ║
+    ║                                                                ║
+    ║     ${chalk.gray('Fine-tune your agents\' behavior and activity levels')}        ║
+    ╚════════════════════════════════════════════════════════════════╝
+  `));
+    const settings = loadSettings();
+    // Show current rate limits as a visual dashboard
+    console.log(chalk.bold('    📈 Rate Limits (per agent, per day):\n'));
+    const actions = ['paper', 'take', 'comment', 'vote', 'follow', 'sciencesub'];
+    const icons = {
+        paper: '📄',
+        take: '📝',
+        comment: '💬',
+        vote: '⬆️',
+        follow: '👤',
+        sciencesub: '🏠',
+    };
+    for (const action of actions) {
+        const limit = settings.rateLimits[action] || 0;
+        const cooldown = settings.cooldowns[action] || 0;
+        const bar = '█'.repeat(Math.min(limit / 10, 20)).padEnd(20, '░');
+        console.log(`    ${icons[action]} ${chalk.cyan(action.padEnd(10))} ${chalk.green(bar)} ${chalk.white(String(limit).padStart(3))}/${chalk.gray('day')} ${chalk.gray(`(${formatCooldown(cooldown)} cooldown)`)}`);
+    }
+    // Show activity weights
+    console.log('\n' + chalk.bold('    🎲 Activity Weights (probability distribution):\n'));
+    const weights = settings.activityWeights || DEFAULT_SETTINGS.activityWeights;
+    const totalWeight = Object.values(weights).reduce((a, b) => a + b, 0);
+    for (const [activity, weight] of Object.entries(weights)) {
+        const pct = Math.round((weight / totalWeight) * 100);
+        const bar = '▓'.repeat(Math.round(pct / 5)).padEnd(20, '░');
+        console.log(`    ${icons[activity] || '•'} ${chalk.cyan(activity.padEnd(10))} ${chalk.yellow(bar)} ${chalk.white(String(pct).padStart(2))}%`);
+    }
+    // Show enabled activities
+    console.log('\n' + chalk.bold('    ✅ Enabled Activities:\n'));
+    const enabled = settings.enabledActivities || DEFAULT_SETTINGS.enabledActivities;
+    const activityList = Object.entries(enabled).map(([name, isEnabled]) => {
+        const icon = isEnabled ? chalk.green('●') : chalk.gray('○');
+        return `${icon} ${name}`;
+    });
+    console.log('    ' + activityList.join('  '));
+    console.log('');
+    const { action } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'action',
+            message: chalk.white('What would you like to do?'),
+            prefix: '    ',
+            choices: [
+                { name: `${chalk.yellow('⚡')} ${chalk.bold('Engagement Presets')} ${chalk.gray('- Quick setup with cost estimates')}`, value: 'presets' },
+                new inquirer.Separator(),
+                { name: `${chalk.green('📈')} ${chalk.bold('Adjust Rate Limits')} ${chalk.gray('- Change daily action limits')}`, value: 'limits' },
+                { name: `${chalk.yellow('⏱')}  ${chalk.bold('Adjust Cooldowns')} ${chalk.gray('- Change time between actions')}`, value: 'cooldowns' },
+                { name: `${chalk.blue('🎲')} ${chalk.bold('Activity Weights')} ${chalk.gray('- Control action probability')}`, value: 'weights' },
+                { name: `${chalk.cyan('✅')} ${chalk.bold('Toggle Activities')} ${chalk.gray('- Enable/disable action types')}`, value: 'toggles' },
+                new inquirer.Separator(),
+                { name: `${chalk.magenta('🔄')} ${chalk.bold('Reset to Defaults')} ${chalk.gray('- Restore recommended settings')}`, value: 'reset' },
+                new inquirer.Separator(),
+                { name: chalk.gray('← Back to main menu'), value: 'back' },
+            ],
+        },
+    ]);
+    if (action === 'back') {
+        await playCommand();
+        return;
+    }
+    if (action === 'presets') {
+        await engagementPresetsMenu(settings);
+        return;
+    }
+    if (action === 'reset') {
+        saveSettings({ ...DEFAULT_SETTINGS });
+        console.log(chalk.green('\n    ✓ Settings reset to defaults\n'));
+        await inquirer.prompt([{ type: 'input', name: 'c', message: chalk.gray('Press Enter to continue...'), prefix: '    ' }]);
+        await settingsMenu();
+        return;
+    }
+    if (action === 'limits') {
+        await adjustRateLimits(settings);
+        return;
+    }
+    if (action === 'cooldowns') {
+        await adjustCooldowns(settings);
+        return;
+    }
+    if (action === 'weights') {
+        await adjustActivityWeights(settings);
+        return;
+    }
+    if (action === 'toggles') {
+        await toggleActivities(settings);
+        return;
+    }
+}
+const ENGAGEMENT_PRESETS = {
+    conservative: {
+        name: '🐢 Conservative',
+        description: 'Slow and steady. Minimal LLM costs, organic feel.',
+        rateLimits: { paper: 2, take: 10, comment: 50, vote: 100, follow: 20, sciencesub: 1 },
+        cooldowns: { paper: 600000, take: 60000, comment: 30000, vote: 5000, follow: 10000, sciencesub: 0 },
+    },
+    moderate: {
+        name: '🚶 Moderate',
+        description: 'Balanced activity. Good engagement without breaking the bank.',
+        rateLimits: { paper: 5, take: 30, comment: 150, vote: 300, follow: 50, sciencesub: 2 },
+        cooldowns: { paper: 300000, take: 30000, comment: 10000, vote: 2000, follow: 5000, sciencesub: 0 },
+    },
+    aggressive: {
+        name: '🏃 Aggressive',
+        description: 'High activity. Fast engagement, noticeable LLM costs.',
+        rateLimits: { paper: 20, take: 100, comment: 500, vote: 1000, follow: 200, sciencesub: 5 },
+        cooldowns: { paper: 60000, take: 10000, comment: 3000, vote: 500, follow: 2000, sciencesub: 0 },
+    },
+    insane: {
+        name: '🚀 INSANE',
+        description: 'Maximum engagement. Votes and comments explode.',
+        rateLimits: { paper: 50, take: 200, comment: 1000, vote: 5000, follow: 500, sciencesub: 10 },
+        cooldowns: { paper: 30000, take: 2000, comment: 500, vote: 100, follow: 500, sciencesub: 0 },
+    },
+};
+async function engagementPresetsMenu(settings) {
+    console.clear();
+    console.log(chalk.bold.cyan(`
+    ╔════════════════════════════════════════════════════════════════╗
+    ║              ⚡ ENGAGEMENT PRESETS & COST CALCULATOR           ║
+    ╚════════════════════════════════════════════════════════════════╝
+  `));
+    // Count agents
+    const db = getDatabase();
+    const agentCount = db.getAllAgents().length || 1;
+    console.log(chalk.gray(`    You have ${chalk.white(agentCount)} agent(s).\n`));
+    // Show preset comparison table
+    console.log(chalk.bold('    📊 PRESET COMPARISON:\n'));
+    console.log(chalk.gray('    ┌─────────────────┬──────────┬──────────┬──────────┬──────────┬──────────┐'));
+    console.log(chalk.gray('    │ Preset          │ Papers   │ Takes    │ Comments │ Votes    │ Follows  │'));
+    console.log(chalk.gray('    ├─────────────────┼──────────┼──────────┼──────────┼──────────┼──────────┤'));
+    for (const [key, preset] of Object.entries(ENGAGEMENT_PRESETS)) {
+        const r = preset.rateLimits;
+        const color = key === 'conservative' ? chalk.green : key === 'moderate' ? chalk.yellow : key === 'aggressive' ? chalk.red : chalk.magenta;
+        console.log(chalk.gray('    │ ') + color(preset.name.padEnd(15)) + chalk.gray(' │ ') +
+            chalk.white(String(r.paper).padStart(8)) + chalk.gray(' │ ') +
+            chalk.white(String(r.take).padStart(8)) + chalk.gray(' │ ') +
+            chalk.white(String(r.comment).padStart(8)) + chalk.gray(' │ ') +
+            chalk.white(String(r.vote).padStart(8)) + chalk.gray(' │ ') +
+            chalk.white(String(r.follow).padStart(8)) + chalk.gray(' │'));
+    }
+    console.log(chalk.gray('    └─────────────────┴──────────┴──────────┴──────────┴──────────┴──────────┘'));
+    console.log('');
+    const { selectedPreset } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'selectedPreset',
+            message: chalk.white('Select engagement level:'),
+            prefix: '    ',
+            choices: [
+                ...Object.entries(ENGAGEMENT_PRESETS).map(([key, preset]) => ({
+                    name: `${preset.name.padEnd(18)} ${chalk.gray(preset.description.slice(0, 50))}`,
+                    value: key,
+                })),
+                new inquirer.Separator(),
+                { name: chalk.gray('← Back to settings'), value: 'back' },
+            ],
+            pageSize: 8,
+        },
+    ]);
+    if (selectedPreset === 'back') {
+        await settingsMenu();
+        return;
+    }
+    const preset = ENGAGEMENT_PRESETS[selectedPreset];
+    // Confirm application
+    console.log('\n' + chalk.bold(`    📋 ${preset.name} PRESET DETAILS:\n`));
+    console.log(chalk.white('    Rate Limits (per agent/day):'));
+    console.log(chalk.gray(`      Papers: ${preset.rateLimits.paper} | Takes: ${preset.rateLimits.take} | Comments: ${preset.rateLimits.comment}`));
+    console.log(chalk.gray(`      Votes: ${preset.rateLimits.vote} | Follows: ${preset.rateLimits.follow} | Sciencesubs: ${preset.rateLimits.sciencesub}\n`));
+    const { confirm } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: chalk.white(`Apply ${preset.name} preset?`),
+            prefix: '    ',
+            default: true,
+        },
+    ]);
+    if (confirm) {
+        // Apply the preset to settings
+        const newSettings = {
+            ...settings,
+            rateLimits: { ...preset.rateLimits },
+            cooldowns: { ...preset.cooldowns },
+        };
+        saveSettings(newSettings);
+        console.log(chalk.green(`\n    ✓ Applied ${preset.name} preset!\n`));
+    }
+    await inquirer.prompt([{ type: 'input', name: 'c', message: chalk.gray('Press Enter to continue...'), prefix: '    ' }]);
+    await settingsMenu();
+}
+async function adjustRateLimits(settings) {
+    console.clear();
+    console.log(chalk.bold.cyan('\n    📈 ADJUST RATE LIMITS\n'));
+    console.log(chalk.gray('    Higher limits = more actions, but may trigger platform rate limits\n'));
+    const { selectedAction } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'selectedAction',
+            message: chalk.white('Select action type to adjust:'),
+            prefix: '    ',
+            choices: [
+                { name: `📄 Papers     ${chalk.gray(`(current: ${settings.rateLimits.paper}/day)`)}`, value: 'paper' },
+                { name: `📝 Takes      ${chalk.gray(`(current: ${settings.rateLimits.take}/day)`)}`, value: 'take' },
+                { name: `💬 Comments   ${chalk.gray(`(current: ${settings.rateLimits.comment}/day)`)}`, value: 'comment' },
+                { name: `⬆️  Votes      ${chalk.gray(`(current: ${settings.rateLimits.vote}/day)`)}`, value: 'vote' },
+                { name: `👤 Follows    ${chalk.gray(`(current: ${settings.rateLimits.follow}/day)`)}`, value: 'follow' },
+                { name: `🏠 Sciencesubs ${chalk.gray(`(current: ${settings.rateLimits.sciencesub}/day)`)}`, value: 'sciencesub' },
+                new inquirer.Separator(),
+                { name: chalk.gray('← Back'), value: 'back' },
+            ],
+        },
+    ]);
+    if (selectedAction === 'back') {
+        await settingsMenu();
+        return;
+    }
+    const maxLimits = {
+        paper: 10,
+        take: 30,
+        comment: 150,
+        vote: 500,
+        follow: 100,
+        sciencesub: 50,
+    };
+    const { newLimit } = await inquirer.prompt([
+        {
+            type: 'number',
+            name: 'newLimit',
+            message: chalk.white(`New daily limit for ${selectedAction} (1-${maxLimits[selectedAction]}):`),
+            prefix: '    ',
+            default: settings.rateLimits[selectedAction],
+            validate: (val) => {
+                if (val < 1)
+                    return 'Must be at least 1';
+                if (val > maxLimits[selectedAction])
+                    return `Maximum is ${maxLimits[selectedAction]}`;
+                return true;
+            },
+        },
+    ]);
+    settings.rateLimits[selectedAction] = newLimit;
+    saveSettings(settings);
+    console.log(chalk.green(`\n    ✓ ${selectedAction} limit set to ${newLimit}/day\n`));
+    await inquirer.prompt([{ type: 'input', name: 'c', message: chalk.gray('Press Enter to continue...'), prefix: '    ' }]);
+    await settingsMenu();
+}
+async function adjustCooldowns(settings) {
+    console.clear();
+    console.log(chalk.bold.cyan('\n    ⏱ ADJUST COOLDOWNS\n'));
+    console.log(chalk.gray('    Cooldown = minimum time between actions of the same type\n'));
+    const { selectedAction } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'selectedAction',
+            message: chalk.white('Select action type to adjust:'),
+            prefix: '    ',
+            choices: [
+                { name: `📄 Papers     ${chalk.gray(`(current: ${formatCooldown(settings.cooldowns.paper)})`)}`, value: 'paper' },
+                { name: `📝 Takes      ${chalk.gray(`(current: ${formatCooldown(settings.cooldowns.take)})`)}`, value: 'take' },
+                { name: `💬 Comments   ${chalk.gray(`(current: ${formatCooldown(settings.cooldowns.comment)})`)}`, value: 'comment' },
+                { name: `⬆️  Votes      ${chalk.gray(`(current: ${formatCooldown(settings.cooldowns.vote)})`)}`, value: 'vote' },
+                { name: `👤 Follows    ${chalk.gray(`(current: ${formatCooldown(settings.cooldowns.follow)})`)}`, value: 'follow' },
+                { name: `🏠 Sciencesubs ${chalk.gray(`(current: ${formatCooldown(settings.cooldowns.sciencesub)})`)}`, value: 'sciencesub' },
+                new inquirer.Separator(),
+                { name: chalk.gray('← Back'), value: 'back' },
+            ],
+        },
+    ]);
+    if (selectedAction === 'back') {
+        await settingsMenu();
+        return;
+    }
+    const cooldownPresets = [
+        { name: '5 seconds', value: 5000 },
+        { name: '10 seconds', value: 10000 },
+        { name: '30 seconds', value: 30000 },
+        { name: '1 minute', value: 60000 },
+        { name: '5 minutes', value: 300000 },
+        { name: '10 minutes', value: 600000 },
+    ];
+    const { newCooldown } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'newCooldown',
+            message: chalk.white(`Select cooldown for ${selectedAction}:`),
+            prefix: '    ',
+            choices: cooldownPresets,
+            default: settings.cooldowns[selectedAction],
+        },
+    ]);
+    settings.cooldowns[selectedAction] = newCooldown;
+    saveSettings(settings);
+    console.log(chalk.green(`\n    ✓ ${selectedAction} cooldown set to ${formatCooldown(newCooldown)}\n`));
+    await inquirer.prompt([{ type: 'input', name: 'c', message: chalk.gray('Press Enter to continue...'), prefix: '    ' }]);
+    await settingsMenu();
+}
+async function adjustActivityWeights(settings) {
+    console.clear();
+    console.log(chalk.bold.cyan('\n    🎲 ACTIVITY WEIGHTS\n'));
+    console.log(chalk.gray('    Control how often each activity type occurs (higher = more frequent)\n'));
+    const weights = settings.activityWeights || DEFAULT_SETTINGS.activityWeights;
+    const totalWeight = Object.values(weights).reduce((a, b) => a + b, 0);
+    // Show current distribution
+    console.log(chalk.bold('    Current Distribution:\n'));
+    const weightIcons = {
+        paper: '📄', take: '📝', comment: '💬', vote: '⬆️',
+    };
+    for (const [activity, weight] of Object.entries(weights)) {
+        const pct = Math.round((weight / totalWeight) * 100);
+        const bar = '▓'.repeat(Math.round(pct / 5)).padEnd(20, '░');
+        console.log(`    ${weightIcons[activity] || '•'} ${chalk.cyan(activity.padEnd(10))} ${chalk.yellow(bar)} ${chalk.white(String(pct).padStart(2))}% ${chalk.gray(`(weight: ${weight})`)}`);
+    }
+    console.log('');
+    const { selectedActivity } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'selectedActivity',
+            message: chalk.white('Select activity to adjust:'),
+            prefix: '    ',
+            choices: [
+                ...Object.keys(weights).map(a => ({
+                    name: `${weightIcons[a] || '•'} ${a.padEnd(12)} ${chalk.gray(`(current: ${weights[a]})`)}`,
+                    value: a,
+                })),
+                new inquirer.Separator(),
+                { name: chalk.yellow('⚡ Quick: Boost engagement (comments, votes)'), value: '__boost_engagement__' },
+                { name: chalk.blue('📚 Quick: Boost research (papers, takes)'), value: '__boost_research__' },
+                new inquirer.Separator(),
+                { name: chalk.gray('← Back'), value: 'back' },
+            ],
+        },
+    ]);
+    if (selectedActivity === 'back') {
+        await settingsMenu();
+        return;
+    }
+    // Quick presets
+    if (selectedActivity === '__boost_engagement__') {
+        settings.activityWeights = { paper: 3, take: 5, comment: 30, vote: 25 };
+        saveSettings(settings);
+        console.log(chalk.green('\n    ✓ Engagement mode activated! More comments and votes\n'));
+        await inquirer.prompt([{ type: 'input', name: 'c', message: chalk.gray('Press Enter to continue...'), prefix: '    ' }]);
+        await settingsMenu();
+        return;
+    }
+    if (selectedActivity === '__boost_research__') {
+        settings.activityWeights = { paper: 20, take: 25, comment: 15, vote: 10 };
+        saveSettings(settings);
+        console.log(chalk.green('\n    ✓ Research mode activated! More papers and takes\n'));
+        await inquirer.prompt([{ type: 'input', name: 'c', message: chalk.gray('Press Enter to continue...'), prefix: '    ' }]);
+        await settingsMenu();
+        return;
+    }
+    const { newWeight } = await inquirer.prompt([
+        {
+            type: 'number',
+            name: 'newWeight',
+            message: chalk.white(`New weight for ${selectedActivity} (1-50):`),
+            prefix: '    ',
+            default: weights[selectedActivity],
+            validate: (val) => {
+                if (val < 1)
+                    return 'Must be at least 1';
+                if (val > 50)
+                    return 'Maximum is 50';
+                return true;
+            },
+        },
+    ]);
+    settings.activityWeights[selectedActivity] = newWeight;
+    saveSettings(settings);
+    const newTotal = Object.values(settings.activityWeights).reduce((a, b) => a + b, 0);
+    const newPct = Math.round((newWeight / newTotal) * 100);
+    console.log(chalk.green(`\n    ✓ ${selectedActivity} weight set to ${newWeight} (${newPct}% of total)\n`));
+    await inquirer.prompt([{ type: 'input', name: 'c', message: chalk.gray('Press Enter to continue...'), prefix: '    ' }]);
+    await adjustActivityWeights(settings);
+}
+async function toggleActivities(settings) {
+    console.clear();
+    console.log(chalk.bold.cyan('\n    ✅ TOGGLE ACTIVITIES\n'));
+    console.log(chalk.gray('    Enable or disable specific activity types\n'));
+    const enabled = settings.enabledActivities || DEFAULT_SETTINGS.enabledActivities;
+    const activityDescriptions = {
+        papers: 'Publish new research papers',
+        takes: 'Write takes on papers',
+        comments: 'Comment on papers and takes',
+        votes: 'Upvote/downvote content',
+        follows: 'Follow other agents',
+        sciencesubs: 'Join sciencesub communities',
+    };
+    const activityIcons = {
+        papers: '📄', takes: '📝', comments: '💬',
+        votes: '⬆️', follows: '👤', sciencesubs: '🏠',
+    };
+    const { selectedActivities } = await inquirer.prompt([
+        {
+            type: 'checkbox',
+            name: 'selectedActivities',
+            message: chalk.white('Select activities to enable (Space to toggle):'),
+            prefix: '    ',
+            choices: [
+                ...Object.entries(enabled).map(([name, isEnabled]) => ({
+                    name: `${activityIcons[name] || '•'} ${chalk.bold(name.padEnd(20))} ${chalk.gray(activityDescriptions[name] || '')}`,
+                    value: name,
+                    checked: isEnabled,
+                })),
+                new inquirer.Separator(),
+                { name: chalk.green('✨ Enable ALL activities'), value: '__enable_all__' },
+                { name: chalk.red('🔇 Minimal mode (comments only)'), value: '__minimal__' },
+            ],
+        },
+    ]);
+    // Handle presets
+    if (selectedActivities.includes('__enable_all__')) {
+        for (const key of Object.keys(enabled)) {
+            settings.enabledActivities[key] = true;
+        }
+        saveSettings(settings);
+        console.log(chalk.green('\n    ✓ All activities enabled!\n'));
+    }
+    else if (selectedActivities.includes('__minimal__')) {
+        for (const key of Object.keys(enabled)) {
+            settings.enabledActivities[key] = key === 'comments';
+        }
+        saveSettings(settings);
+        console.log(chalk.yellow('\n    ✓ Minimal mode: Only comments enabled\n'));
+    }
+    else {
+        // Apply selections
+        for (const key of Object.keys(enabled)) {
+            settings.enabledActivities[key] = selectedActivities.includes(key);
+        }
+        saveSettings(settings);
+        const enabledCount = selectedActivities.filter((a) => !a.startsWith('__')).length;
+        console.log(chalk.green(`\n    ✓ ${enabledCount} activities enabled\n`));
+    }
+    await inquirer.prompt([{ type: 'input', name: 'c', message: chalk.gray('Press Enter to continue...'), prefix: '    ' }]);
+    await settingsMenu();
+}
+function showAgentDetails(agent) {
+    const icon = VOICE_ICONS[agent.persona.voice] || '🤖';
+    const colorFn = VOICE_COLORS[agent.persona.voice] || chalk.white;
+    const spiceBar = '🌶️'.repeat(agent.persona.spiceLevel) + '⬜'.repeat(10 - agent.persona.spiceLevel);
+    const createdAt = agent.createdAt ? new Date(agent.createdAt).toLocaleDateString() : '—';
+    const apiKeyLine = agent.apiKey ? (agent.apiKey.slice(0, 20) + '...') : '—';
+    console.log(chalk.cyan(`
+    ╭────────────────────────────────────────────────────────╮
+    │                                                        │
+    │   ${icon} ${colorFn(`@${agent.handle}`.padEnd(50))}│
+    │   ${chalk.gray(agent.displayName.padEnd(53))}│
+    │                                                        │
+    │   ${chalk.cyan('Voice:')}        ${agent.persona.voice.padEnd(41)}│
+    │   ${chalk.cyan('Epistemics:')}   ${(agent.persona.epistemics ?? '—').padEnd(41)}│
+    │   ${chalk.cyan('Spice Level:')}  ${spiceBar}     │
+    │                                                        │
+    │   ${chalk.cyan('Topics:')}                                              │
+    │   ${chalk.gray((agent.persona.preferredTopics || []).join(', ').slice(0, 50).padEnd(53))}│
+    │                                                        │
+    │   ${chalk.cyan('Catchphrases:')}                                        │
+    │   ${chalk.gray((agent.persona.catchphrases?.[0] || 'None').slice(0, 50).padEnd(53))}│
+    │                                                        │
+    │   ${chalk.cyan('Created:')} ${chalk.gray(createdAt.padEnd(44))}│
+    │   ${chalk.cyan('API Key:')}  ${chalk.gray(apiKeyLine.padEnd(44))}│
+    │                                                        │
+    ╰────────────────────────────────────────────────────────╯
+  `));
+}
+//# sourceMappingURL=play.js.map