@zhive/cli 0.6.3 → 0.6.4

package/dist/CLAUDE.md

@@ -0,0 +1,7 @@
+<claude-mem-context>
+# Recent Activity
+
+<!-- This section is auto-generated by claude-mem. Edit content outside the tags. -->
+
+*No recent activity*
+</claude-mem-context>

package/dist/backtest/CLAUDE.md

@@ -0,0 +1,7 @@
+<claude-mem-context>
+# Recent Activity
+
+<!-- This section is auto-generated by claude-mem. Edit content outside the tags. -->
+
+*No recent activity*
+</claude-mem-context>

package/dist/cli.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { createRequire } from 'module';
+import { createCreateCommand } from './commands/create/commands/index.js';
+import { createListCommand } from './commands/list/commands/index.js';
+import { createStartCommand } from './commands/start/commands/index.js';
+import { createStartAllCommand } from './commands/start-all/commands/index.js';
+import { createRunCommand } from './commands/run/commands/index.js';
+import { createMigrateTemplatesCommand } from './commands/migrate-templates/commands/index.js';
+const require = createRequire(import.meta.url);
+const packageJson = require('../package.json');
+const program = new Command();
+program.name('@zhive/cli').version(packageJson.version);
+program.addCommand(createCreateCommand());
+program.addCommand(createListCommand());
+program.addCommand(createStartCommand());
+program.addCommand(createStartAllCommand());
+program.addCommand(createRunCommand());
+program.addCommand(createMigrateTemplatesCommand());
+program.parse(process.argv);

package/dist/commands/agent/commands/profile.js

@@ -1,6 +1,7 @@
 import { Command } from 'commander';
+import { findAgentByName, scanAgents } from '../../../shared/config/agent.js';
 import { styled, symbols } from '../../shared/theme.js';
-import { findAgentByName, loadAgentCredentials, scanAgents } from '../../../shared/config/agent.js';
+import { loadConfig } from '@zhive/sdk';
 export const createAgentProfileCommand = () => {
     return new Command('profile')
         .description('Display agent profile information')
@@ -18,7 +19,7 @@ export const createAgentProfileCommand = () => {
             }
             process.exit(1);
         }
-        const credentials = await loadAgentCredentials(agentConfig.dir, agentConfig.name);
+        const credentials = await loadConfig(agentConfig.dir);
         if (!credentials?.apiKey) {
             console.error(styled.red(`${symbols.cross} No credentials found for agent "${agentName}". The agent may need to be registered first.`));
             process.exit(1);

package/dist/commands/agent/commands/profile.test.js

@@ -8,15 +8,13 @@ vi.mock('../../../shared/config/constant.js', () => ({
     HIVE_API_URL: 'http://localhost:6969',
 }));
 vi.mock('../../../shared/config/ai-providers.js', () => ({
-    AI_PROVIDERS: [
-        { label: 'OpenAI', package: '@ai-sdk/openai', envVar: 'OPENAI_API_KEY' },
-    ],
+    AI_PROVIDERS: [{ label: 'OpenAI', package: '@ai-sdk/openai', envVar: 'OPENAI_API_KEY' }],
 }));
 vi.mock('@zhive/sdk', async () => {
     const actual = await vi.importActual('@zhive/sdk');
     return {
         ...actual,
-        loadCredentials: vi.fn(),
+        loadConfig: vi.fn(),
     };
 });
 vi.mock('../../shared/theme.js', () => ({
@@ -34,9 +32,9 @@ vi.mock('../../shared/theme.js', () => ({
         hive: '⬡',
     },
 }));
-import { loadCredentials } from '@zhive/sdk';
+import { loadConfig } from '@zhive/sdk';
 import { createAgentProfileCommand } from './profile.js';
-const mockLoadCredentials = loadCredentials;
+const mockLoadConfig = loadConfig;
 describe('createAgentProfileCommand', () => {
     let consoleLogSpy;
     let consoleErrorSpy;
@@ -74,20 +72,20 @@ describe('createAgentProfileCommand', () => {
         expect(consoleErrorOutput.join('\n')).toContain('agent-no-skills');
     });
     it('shows error when credentials are missing', async () => {
-        mockLoadCredentials.mockResolvedValue(null);
+        mockLoadConfig.mockResolvedValue(null);
         const command = createAgentProfileCommand();
         await expect(command.parseAsync(['test-agent'], { from: 'user' })).rejects.toThrow('process.exit(1)');
         expect(consoleErrorOutput.join('\n')).toContain('No credentials found for agent "test-agent"');
         expect(consoleErrorOutput.join('\n')).toContain('may need to be registered first');
     });
     it('shows error when credentials have no API key', async () => {
-        mockLoadCredentials.mockResolvedValue({ apiKey: null });
+        mockLoadConfig.mockResolvedValue({ apiKey: null });
         const command = createAgentProfileCommand();
         await expect(command.parseAsync(['test-agent'], { from: 'user' })).rejects.toThrow('process.exit(1)');
         expect(consoleErrorOutput.join('\n')).toContain('No credentials found');
     });
     it('displays profile from local config', async () => {
-        mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+        mockLoadConfig.mockResolvedValue({ apiKey: 'test-api-key' });
         const command = createAgentProfileCommand();
         await command.parseAsync(['test-agent'], { from: 'user' });
         const output = consoleOutput.join('\n');
@@ -100,7 +98,7 @@ describe('createAgentProfileCommand', () => {
         expect(output).toContain('https://example.com/avatar.png');
     });
     it('displays profile settings section', async () => {
-        mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+        mockLoadConfig.mockResolvedValue({ apiKey: 'test-api-key' });
         const command = createAgentProfileCommand();
         await command.parseAsync(['test-agent'], { from: 'user' });
         const output = consoleOutput.join('\n');
@@ -113,7 +111,7 @@ describe('createAgentProfileCommand', () => {
         expect(output).toContain('defi, gaming');
     });
     it('handles agent with empty sectors', async () => {
-        mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+        mockLoadConfig.mockResolvedValue({ apiKey: 'test-api-key' });
         const command = createAgentProfileCommand();
         await command.parseAsync(['empty-agent'], { from: 'user' });
         const output = consoleOutput.join('\n');
@@ -126,7 +124,7 @@ describe('createAgentProfileCommand', () => {
         expect(sectorsLine).toContain('-');
     });
     it('works with different fixture agents', async () => {
-        mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+        mockLoadConfig.mockResolvedValue({ apiKey: 'test-api-key' });
         const command = createAgentProfileCommand();
         await command.parseAsync(['agent-no-skills'], { from: 'user' });
         const output = consoleOutput.join('\n');

package/dist/commands/doctor/commands/index.js

@@ -0,0 +1,93 @@
+import { Command } from 'commander';
+import path from 'path';
+import fsExtra from 'fs-extra';
+import { HiveClient, loadConfig } from '@zhive/sdk';
+import { styled, symbols } from '../../shared/theme.js';
+import { getHiveDir, HIVE_API_URL } from '../../../shared/config/constant.js';
+import { loadAgentConfig } from '../../../shared/config/agent.js';
+async function checkAgent(agentDir, dirName) {
+    const result = {
+        dirName,
+        dirPath: agentDir,
+        name: null,
+        configError: null,
+        registrationStatus: 'skipped',
+    };
+    let configLoaded = false;
+    try {
+        const config = await loadAgentConfig(agentDir);
+        result.name = config.name;
+        configLoaded = true;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        result.configError = message;
+    }
+    if (!configLoaded) {
+        return result;
+    }
+    const credentials = await loadConfig(agentDir);
+    if (!credentials?.apiKey) {
+        result.registrationStatus = 'no-api-key';
+        return result;
+    }
+    try {
+        const client = new HiveClient(HIVE_API_URL, credentials.apiKey);
+        await client.getMe();
+        result.registrationStatus = 'registered';
+    }
+    catch {
+        result.registrationStatus = 'not-registered';
+    }
+    return result;
+}
+function printResult(result) {
+    const displayName = result.name ?? result.dirName;
+    console.log(`  ${styled.whiteBold(`Agent: ${displayName}`)}`);
+    console.log(`  ${styled.gray('Path:')}  ${result.dirPath}`);
+    if (result.configError !== null) {
+        console.log(`  ${styled.red(`${symbols.cross} Config error: ${result.configError}`)}`);
+        console.log(`  ${styled.gray('- Registration: skipped (config failed)')}`);
+    }
+    else {
+        console.log(`  ${styled.green(`${symbols.check} Config loaded successfully`)}`);
+        switch (result.registrationStatus) {
+            case 'registered':
+                console.log(`  ${styled.green(`${symbols.check} Registered`)}`);
+                break;
+            case 'not-registered':
+                console.log(`  ${styled.red(`${symbols.cross} Not registered`)}`);
+                break;
+            case 'no-api-key':
+                console.log(`  ${styled.honey(`${symbols.diamond} No API key found`)}`);
+                break;
+        }
+    }
+    console.log('');
+}
+export const createDoctorCommand = () => {
+    return new Command('doctor').description('Check health of all local agents').action(async () => {
+        const agentsDir = path.join(getHiveDir(), 'agents');
+        const exists = await fsExtra.pathExists(agentsDir);
+        if (!exists) {
+            console.log('');
+            console.log(styled.red(`${symbols.cross} No agents directory found. Create an agent with: npx @zhive/cli@latest create`));
+            return;
+        }
+        const entries = await fsExtra.readdir(agentsDir, { withFileTypes: true });
+        const directories = entries.filter((entry) => entry.isDirectory());
+        if (directories.length === 0) {
+            console.log('');
+            console.log(styled.red(`${symbols.cross} No agents found. Create one with: npx @zhive/cli@latest create`));
+            return;
+        }
+        console.log('');
+        console.log(styled.honeyBold(`${symbols.hive} Agent Health Check`));
+        console.log('');
+        for (const entry of directories) {
+            const agentDir = path.join(agentsDir, entry.name);
+            const checkResult = await checkAgent(agentDir, entry.name);
+            printResult(checkResult);
+        }
+    });
+};

package/dist/commands/megathread/commands/create-comment.js

@@ -1,17 +1,15 @@
 import { Command } from 'commander';
 import { z } from 'zod';
-import { HiveClient } from '@zhive/sdk';
+import { HiveClient, loadConfig } from '@zhive/sdk';
 import { styled, symbols } from '../../shared/theme.js';
 import { HIVE_API_URL } from '../../../shared/config/constant.js';
-import { findAgentByName, loadAgentCredentials, scanAgents } from '../../../shared/config/agent.js';
+import { findAgentByName, scanAgents } from '../../../shared/config/agent.js';
 import { printZodError } from '../../shared/ validation.js';
 const CreateCommentOptionsSchema = z.object({
     agent: z.string().min(1),
     round: z.string().min(1),
     conviction: z.coerce.number().min(-100).max(100),
     text: z.string().min(1),
-    token: z.string().min(1),
-    timeframe: z.enum(['1h', '4h', '24h']),
 });
 export function createMegathreadCreateCommentCommand() {
     return new Command('create-comment')
@@ -20,15 +18,13 @@ export function createMegathreadCreateCommentCommand() {
         .requiredOption('--round <roundId>', 'Round ID to comment on')
         .requiredOption('--conviction <number>', 'Conviction score (-100 to 100)')
         .requiredOption('--text <text>', 'Comment text')
-        .requiredOption('--token <tokenId>', 'Token/project ID')
-        .requiredOption('--timeframe <tf>', 'Timeframe (1h, 4h, 24h)')
         .action(async (options) => {
         const parseResult = CreateCommentOptionsSchema.safeParse(options);
         if (!parseResult.success) {
             printZodError(parseResult);
             process.exit(1);
         }
-        const { agent: agentName, round: roundId, conviction, text, token, timeframe, } = parseResult.data;
+        const { agent: agentName, round: roundId, conviction, text } = parseResult.data;
         const agentConfig = await findAgentByName(agentName);
         if (!agentConfig) {
             const agents = await scanAgents();
@@ -41,7 +37,7 @@ export function createMegathreadCreateCommentCommand() {
             }
             process.exit(1);
         }
-        const credentials = await loadAgentCredentials(agentConfig.dir, agentConfig.name);
+        const credentials = await loadConfig(agentConfig.dir);
         if (!credentials?.apiKey) {
             console.error(styled.red(`${symbols.cross} No credentials found for agent "${agentName}". The agent may need to be registered first.`));
             process.exit(1);
@@ -57,7 +53,6 @@ export function createMegathreadCreateCommentCommand() {
             console.log(styled.green(`${symbols.check} Comment posted successfully!`));
             console.log('');
             console.log(`  ${styled.gray('Round:')}      ${roundId}`);
-            console.log(`  ${styled.gray('Token:')}      ${token}`);
             console.log(`  ${styled.gray('Conviction:')} ${conviction >= 0 ? '+' : ''}${conviction.toFixed(1)}%`);
             console.log(`  ${styled.gray('Text:')}       ${text.length > 50 ? text.slice(0, 50) + '...' : text}`);
             console.log('');

package/dist/commands/megathread/commands/create-comment.test.js

@@ -17,7 +17,7 @@ vi.mock('@zhive/sdk', async () => {
         HiveClient: vi.fn().mockImplementation(() => ({
             postMegathreadComment: vi.fn(),
         })),
-        loadCredentials: vi.fn(),
+        loadConfig: vi.fn(),
     };
 });
 vi.mock('../../shared/theme.js', () => ({
@@ -31,10 +31,10 @@ vi.mock('../../shared/theme.js', () => ({
         check: '✓',
     },
 }));
-import { HiveClient, loadCredentials } from '@zhive/sdk';
+import { HiveClient, loadConfig } from '@zhive/sdk';
 import { createMegathreadCreateCommentCommand } from './create-comment.js';
 const MockHiveClient = HiveClient;
-const mockLoadCredentials = loadCredentials;
+const mockLoadConfig = loadConfig;
 describe('createMegathreadCreateCommentCommand', () => {
     let consoleLogSpy;
     let consoleErrorSpy;
@@ -79,10 +79,6 @@ describe('createMegathreadCreateCommentCommand', () => {
                 '150',
                 '--text',
                 'Test comment',
-                '--token',
-                'bitcoin',
-                '--timeframe',
-                '1h',
             ], { from: 'user' })).rejects.toThrow('process.exit(1)');
             expect(consoleErrorOutput.join('\n')).toContain('conviction');
             expect(consoleErrorOutput.join('\n')).toContain('100');
@@ -98,10 +94,6 @@ describe('createMegathreadCreateCommentCommand', () => {
                 '-150',
                 '--text',
                 'Test comment',
-                '--token',
-                'bitcoin',
-                '--timeframe',
-                '1h',
             ], { from: 'user' })).rejects.toThrow('process.exit(1)');
             expect(consoleErrorOutput.join('\n')).toContain('conviction');
             expect(consoleErrorOutput.join('\n')).toContain('-100');
@@ -117,16 +109,12 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'abc',
                 '--text',
                 'Test comment',
-                '--token',
-                'bitcoin',
-                '--timeframe',
-                '1h',
             ], { from: 'user' })).rejects.toThrow('process.exit(1)');
             expect(consoleErrorOutput.join('\n')).toContain('conviction');
             expect(consoleErrorOutput.join('\n')).toContain('number');
         });
         it('accepts valid conviction at upper boundary', async () => {
-            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockLoadConfig.mockResolvedValue({ apiKey: 'test-api-key' });
             mockPostMegathreadComment.mockResolvedValue(undefined);
             const command = createMegathreadCreateCommentCommand();
             await command.parseAsync([
@@ -138,10 +126,6 @@ describe('createMegathreadCreateCommentCommand', () => {
                 '100',
                 '--text',
                 'Test comment',
-                '--token',
-                'bitcoin',
-                '--timeframe',
-                '1h',
             ], { from: 'user' });
             expect(mockPostMegathreadComment).toHaveBeenCalledWith('round-123', {
                 text: 'Test comment',
@@ -149,7 +133,7 @@ describe('createMegathreadCreateCommentCommand', () => {
             });
         });
         it('accepts valid conviction at lower boundary', async () => {
-            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockLoadConfig.mockResolvedValue({ apiKey: 'test-api-key' });
             mockPostMegathreadComment.mockResolvedValue(undefined);
             const command = createMegathreadCreateCommentCommand();
             await command.parseAsync([
@@ -161,10 +145,6 @@ describe('createMegathreadCreateCommentCommand', () => {
                 '-100',
                 '--text',
                 'Test comment',
-                '--token',
-                'bitcoin',
-                '--timeframe',
-                '1h',
             ], { from: 'user' });
             expect(mockPostMegathreadComment).toHaveBeenCalledWith('round-123', {
                 text: 'Test comment',
@@ -172,7 +152,7 @@ describe('createMegathreadCreateCommentCommand', () => {
             });
         });
         it('accepts decimal conviction values', async () => {
-            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockLoadConfig.mockResolvedValue({ apiKey: 'test-api-key' });
             mockPostMegathreadComment.mockResolvedValue(undefined);
             const command = createMegathreadCreateCommentCommand();
             await command.parseAsync([
@@ -184,10 +164,6 @@ describe('createMegathreadCreateCommentCommand', () => {
                 '25.5',
                 '--text',
                 'Test comment',
-                '--token',
-                'bitcoin',
-                '--timeframe',
-                '1h',
             ], { from: 'user' });
             expect(mockPostMegathreadComment).toHaveBeenCalledWith('round-123', {
                 text: 'Test comment',
@@ -195,94 +171,6 @@ describe('createMegathreadCreateCommentCommand', () => {
             });
         });
     });
-    describe('timeframe validation', () => {
-        it('shows error for invalid timeframe value', async () => {
-            const command = createMegathreadCreateCommentCommand();
-            await expect(command.parseAsync([
-                '--agent',
-                'test-agent',
-                '--round',
-                'round-123',
-                '--conviction',
-                '50',
-                '--text',
-                'Test comment',
-                '--token',
-                'bitcoin',
-                '--timeframe',
-                '2h',
-            ], { from: 'user' })).rejects.toThrow('process.exit(1)');
-        });
-        it('accepts 1h timeframe', async () => {
-            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
-            mockPostMegathreadComment.mockResolvedValue(undefined);
-            const command = createMegathreadCreateCommentCommand();
-            await command.parseAsync([
-                '--agent',
-                'test-agent',
-                '--round',
-                'round-123',
-                '--conviction',
-                '50',
-                '--text',
-                'Test comment',
-                '--token',
-                'bitcoin',
-                '--timeframe',
-                '1h',
-            ], { from: 'user' });
-            expect(mockPostMegathreadComment).toHaveBeenCalledWith('round-123', {
-                text: 'Test comment',
-                conviction: 50,
-            });
-        });
-        it('accepts 4h timeframe', async () => {
-            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
-            mockPostMegathreadComment.mockResolvedValue(undefined);
-            const command = createMegathreadCreateCommentCommand();
-            await command.parseAsync([
-                '--agent',
-                'test-agent',
-                '--round',
-                'round-123',
-                '--conviction',
-                '50',
-                '--text',
-                'Test comment',
-                '--token',
-                'bitcoin',
-                '--timeframe',
-                '4h',
-            ], { from: 'user' });
-            expect(mockPostMegathreadComment).toHaveBeenCalledWith('round-123', {
-                text: 'Test comment',
-                conviction: 50,
-            });
-        });
-        it('accepts 24h timeframe', async () => {
-            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
-            mockPostMegathreadComment.mockResolvedValue(undefined);
-            const command = createMegathreadCreateCommentCommand();
-            await command.parseAsync([
-                '--agent',
-                'test-agent',
-                '--round',
-                'round-123',
-                '--conviction',
-                '50',
-                '--text',
-                'Test comment',
-                '--token',
-                'bitcoin',
-                '--timeframe',
-                '24h',
-            ], { from: 'user' });
-            expect(mockPostMegathreadComment).toHaveBeenCalledWith('round-123', {
-                text: 'Test comment',
-                conviction: 50,
-            });
-        });
-    });
     describe('agent validation', () => {
         it('shows error when agent not found and lists available agents', async () => {
             const command = createMegathreadCreateCommentCommand();
@@ -295,10 +183,6 @@ describe('createMegathreadCreateCommentCommand', () => {
                 '50',
                 '--text',
                 'Test comment',
-                '--token',
-                'bitcoin',
-                '--timeframe',
-                '1h',
             ], { from: 'user' })).rejects.toThrow('process.exit(1)');
             expect(consoleErrorOutput.join('\n')).toContain('Agent "non-existent" not found');
             expect(consoleErrorOutput.join('\n')).toContain('Available agents:');
@@ -309,7 +193,7 @@ describe('createMegathreadCreateCommentCommand', () => {
     });
     describe('credentials validation', () => {
         it('shows error when credentials are missing', async () => {
-            mockLoadCredentials.mockResolvedValue(null);
+            mockLoadConfig.mockResolvedValue(null);
             const command = createMegathreadCreateCommentCommand();
             await expect(command.parseAsync([
                 '--agent',
@@ -320,15 +204,11 @@ describe('createMegathreadCreateCommentCommand', () => {
                 '50',
                 '--text',
                 'Test comment',
-                '--token',
-                'bitcoin',
-                '--timeframe',
-                '1h',
             ], { from: 'user' })).rejects.toThrow('process.exit(1)');
             expect(consoleErrorOutput.join('\n')).toContain('No credentials found for agent "test-agent"');
         });
         it('shows error when credentials have no API key', async () => {
-            mockLoadCredentials.mockResolvedValue({ apiKey: null });
+            mockLoadConfig.mockResolvedValue({ apiKey: null });
             const command = createMegathreadCreateCommentCommand();
             await expect(command.parseAsync([
                 '--agent',
@@ -339,17 +219,13 @@ describe('createMegathreadCreateCommentCommand', () => {
                 '50',
                 '--text',
                 'Test comment',
-                '--token',
-                'bitcoin',
-                '--timeframe',
-                '1h',
             ], { from: 'user' })).rejects.toThrow('process.exit(1)');
             expect(consoleErrorOutput.join('\n')).toContain('No credentials found');
         });
     });
     describe('successful comment posting', () => {
         it('posts comment and shows success message', async () => {
-            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockLoadConfig.mockResolvedValue({ apiKey: 'test-api-key' });
             mockPostMegathreadComment.mockResolvedValue(undefined);
             const command = createMegathreadCreateCommentCommand();
             await command.parseAsync([
@@ -361,10 +237,6 @@ describe('createMegathreadCreateCommentCommand', () => {
                 '50',
                 '--text',
                 'Bullish on Bitcoin!',
-                '--token',
-                'bitcoin',
-                '--timeframe',
-                '1h',
             ], { from: 'user' });
             expect(mockPostMegathreadComment).toHaveBeenCalledWith('round-123', {
                 text: 'Bullish on Bitcoin!',
@@ -373,12 +245,11 @@ describe('createMegathreadCreateCommentCommand', () => {
             const output = consoleOutput.join('\n');
             expect(output).toContain('Comment posted successfully');
             expect(output).toContain('round-123');
-            expect(output).toContain('bitcoin');
             expect(output).toContain('+50.0%');
             expect(output).toContain('Bullish on Bitcoin!');
         });
         it('formats negative conviction correctly', async () => {
-            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockLoadConfig.mockResolvedValue({ apiKey: 'test-api-key' });
             mockPostMegathreadComment.mockResolvedValue(undefined);
             const command = createMegathreadCreateCommentCommand();
             await command.parseAsync([
@@ -390,33 +261,16 @@ describe('createMegathreadCreateCommentCommand', () => {
                 '-30',
                 '--text',
                 'Bearish outlook',
-                '--token',
-                'ethereum',
-                '--timeframe',
-                '4h',
             ], { from: 'user' });
             const output = consoleOutput.join('\n');
             expect(output).toContain('-30.0%');
         });
         it('truncates long text in success message', async () => {
-            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockLoadConfig.mockResolvedValue({ apiKey: 'test-api-key' });
             mockPostMegathreadComment.mockResolvedValue(undefined);
             const longText = 'A'.repeat(100);
             const command = createMegathreadCreateCommentCommand();
-            await command.parseAsync([
-                '--agent',
-                'test-agent',
-                '--round',
-                'round-123',
-                '--conviction',
-                '25',
-                '--text',
-                longText,
-                '--token',
-                'bitcoin',
-                '--timeframe',
-                '1h',
-            ], { from: 'user' });
+            await command.parseAsync(['--agent', 'test-agent', '--round', 'round-123', '--conviction', '25', '--text', longText], { from: 'user' });
             // Verify full text was sent to API
             expect(mockPostMegathreadComment).toHaveBeenCalledWith('round-123', {
                 text: longText,
@@ -429,7 +283,7 @@ describe('createMegathreadCreateCommentCommand', () => {
     });
     describe('API error handling', () => {
         it('shows error when API call fails', async () => {
-            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockLoadConfig.mockResolvedValue({ apiKey: 'test-api-key' });
             mockPostMegathreadComment.mockRejectedValue(new Error('Network error'));
             const command = createMegathreadCreateCommentCommand();
             await expect(command.parseAsync([
@@ -441,16 +295,12 @@ describe('createMegathreadCreateCommentCommand', () => {
                 '50',
                 '--text',
                 'Test comment',
-                '--token',
-                'bitcoin',
-                '--timeframe',
-                '1h',
             ], { from: 'user' })).rejects.toThrow('process.exit(1)');
             expect(consoleErrorOutput.join('\n')).toContain('Failed to post comment');
             expect(consoleErrorOutput.join('\n')).toContain('Network error');
         });
         it('handles non-Error exceptions', async () => {
-            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockLoadConfig.mockResolvedValue({ apiKey: 'test-api-key' });
             mockPostMegathreadComment.mockRejectedValue('String error');
             const command = createMegathreadCreateCommentCommand();
             await expect(command.parseAsync([
@@ -462,10 +312,6 @@ describe('createMegathreadCreateCommentCommand', () => {
                 '50',
                 '--text',
                 'Test comment',
-                '--token',
-                'bitcoin',
-                '--timeframe',
-                '1h',
             ], { from: 'user' })).rejects.toThrow('process.exit(1)');
             expect(consoleErrorOutput.join('\n')).toContain('Failed to post comment');
             expect(consoleErrorOutput.join('\n')).toContain('String error');
@@ -473,7 +319,7 @@ describe('createMegathreadCreateCommentCommand', () => {
     });
     describe('works with different fixture agents', () => {
         it('works with empty-agent', async () => {
-            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockLoadConfig.mockResolvedValue({ apiKey: 'test-api-key' });
             mockPostMegathreadComment.mockResolvedValue(undefined);
             const command = createMegathreadCreateCommentCommand();
             await command.parseAsync([
@@ -485,10 +331,6 @@ describe('createMegathreadCreateCommentCommand', () => {
                 '50',
                 '--text',
                 'Test comment',
-                '--token',
-                'bitcoin',
-                '--timeframe',
-                '1h',
             ], { from: 'user' });
             const output = consoleOutput.join('\n');
             expect(output).toContain('Comment posted successfully');