@zhive/cli 0.6.2 → 0.6.4

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, TIMEFRAME_DURATION_MS } 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,18 +37,15 @@ 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);
         }
         const client = new HiveClient(HIVE_API_URL, credentials.apiKey);
-        const duration = TIMEFRAME_DURATION_MS[timeframe];
         const payload = {
             text,
             conviction,
-            tokenId: token,
-            roundDuration: duration,
         };
         try {
             await client.postMegathreadComment(roundId, payload);
@@ -60,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

@@ -8,9 +8,7 @@ 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');
@@ -19,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', () => ({
@@ -33,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;
@@ -81,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');
@@ -100,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');
@@ -119,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([
@@ -140,20 +126,14 @@ describe('createMegathreadCreateCommentCommand', () => {
                 '100',
                 '--text',
                 'Test comment',
-                '--token',
-                'bitcoin',
-                '--timeframe',
-                '1h',
             ], { from: 'user' });
             expect(mockPostMegathreadComment).toHaveBeenCalledWith('round-123', {
                 text: 'Test comment',
                 conviction: 100,
-                tokenId: 'bitcoin',
-                roundDuration: 3600000,
             });
         });
         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([
@@ -165,20 +145,14 @@ describe('createMegathreadCreateCommentCommand', () => {
                 '-100',
                 '--text',
                 'Test comment',
-                '--token',
-                'bitcoin',
-                '--timeframe',
-                '1h',
             ], { from: 'user' });
             expect(mockPostMegathreadComment).toHaveBeenCalledWith('round-123', {
                 text: 'Test comment',
                 conviction: -100,
-                tokenId: 'bitcoin',
-                roundDuration: 3600000,
             });
         });
         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([
@@ -190,110 +164,10 @@ describe('createMegathreadCreateCommentCommand', () => {
                 '25.5',
                 '--text',
                 'Test comment',
-                '--token',
-                'bitcoin',
-                '--timeframe',
-                '1h',
             ], { from: 'user' });
             expect(mockPostMegathreadComment).toHaveBeenCalledWith('round-123', {
                 text: 'Test comment',
                 conviction: 25.5,
-                tokenId: 'bitcoin',
-                roundDuration: 3600000,
-            });
-        });
-    });
-    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,
-                tokenId: 'bitcoin',
-                roundDuration: 3600000,
-            });
-        });
-        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,
-                tokenId: 'bitcoin',
-                roundDuration: 14400000,
-            });
-        });
-        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,
-                tokenId: 'bitcoin',
-                roundDuration: 86400000,
             });
         });
     });
@@ -309,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:');
@@ -323,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',
@@ -334,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',
@@ -353,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([
@@ -375,26 +237,19 @@ describe('createMegathreadCreateCommentCommand', () => {
                 '50',
                 '--text',
                 'Bullish on Bitcoin!',
-                '--token',
-                'bitcoin',
-                '--timeframe',
-                '1h',
             ], { from: 'user' });
             expect(mockPostMegathreadComment).toHaveBeenCalledWith('round-123', {
                 text: 'Bullish on Bitcoin!',
                 conviction: 50,
-                tokenId: 'bitcoin',
-                roundDuration: 3600000,
             });
             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([
@@ -406,39 +261,20 @@ 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,
                 conviction: 25,
-                tokenId: 'bitcoin',
-                roundDuration: 3600000,
             });
             // Verify truncated display
             const output = consoleOutput.join('\n');
@@ -447,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([
@@ -459,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([
@@ -480,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');
@@ -491,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([
@@ -503,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');

package/dist/commands/megathread/commands/list.js

@@ -1,8 +1,8 @@
 import { Command } from 'commander';
-import { HiveClient, durationMsToTimeframe } from '@zhive/sdk';
+import { HiveClient, durationMsToTimeframe, loadConfig } from '@zhive/sdk';
 import { styled, symbols, border } 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 z from 'zod';
 import { printZodError } from '../../shared/ validation.js';
 const VALID_TIMEFRAMES = ['1h', '4h', '24h'];
@@ -50,12 +50,12 @@ export function createMegathreadListCommand() {
             }
             process.exit(1);
         }
-        const credentials = await loadAgentCredentials(agentConfig.dir, agentConfig.name);
-        if (!credentials?.apiKey) {
+        const config = await loadConfig(agentConfig.dir);
+        if (!config?.apiKey) {
             console.error(styled.red(`${symbols.cross} No credentials found for agent "${agentName}". The agent may need to be registered first.`));
             process.exit(1);
         }
-        const client = new HiveClient(HIVE_API_URL, credentials.apiKey);
+        const client = new HiveClient(HIVE_API_URL, config.apiKey);
         try {
             const rounds = await client.getUnpredictedRounds(timeframes);
             console.log('');

package/dist/commands/megathread/commands/list.test.js

@@ -17,7 +17,7 @@ vi.mock('@zhive/sdk', async () => {
         HiveClient: vi.fn().mockImplementation(() => ({
             getUnpredictedRounds: vi.fn(),
         })),
-        loadCredentials: vi.fn(),
+        loadConfig: vi.fn(),
         TIMEFRAME_DURATION_MS: {
             H1: 3600000,
             H4: 14400000,
@@ -30,15 +30,16 @@ vi.mock('@zhive/sdk', async () => {
         },
     };
 });
-import { HiveClient, loadCredentials } from '@zhive/sdk';
+import { HiveClient, loadConfig } from '@zhive/sdk';
 import { createMegathreadListCommand } from './list.js';
 const MockHiveClient = HiveClient;
-const mockLoadCredentials = loadCredentials;
+const mockLoadConfig = loadConfig;
 function createMockActiveRound(overrides = {}) {
     return {
         roundId: 'round-123',
         projectId: 'bitcoin',
         durationMs: 3600000,
+        snapTimeMs: Date.now(),
         priceAtStart: null,
         ...overrides,
     };
@@ -87,21 +88,21 @@ describe('createMegathreadListCommand', () => {
             expect(consoleErrorOutput.length).toBeGreaterThan(0);
         });
         it('accepts valid timeframe values', async () => {
-            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockLoadConfig.mockResolvedValue({ apiKey: 'test-api-key' });
             mockGetUnpredictedRounds.mockResolvedValue([]);
             const command = createMegathreadListCommand();
             await command.parseAsync(['--agent', 'test-agent', '--timeframe', '1h,4h'], { from: 'user' });
             expect(mockGetUnpredictedRounds).toHaveBeenCalledWith(['1h', '4h']);
         });
         it('accepts single valid timeframe', async () => {
-            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockLoadConfig.mockResolvedValue({ apiKey: 'test-api-key' });
             mockGetUnpredictedRounds.mockResolvedValue([]);
             const command = createMegathreadListCommand();
             await command.parseAsync(['--agent', 'test-agent', '--timeframe', '24h'], { from: 'user' });
             expect(mockGetUnpredictedRounds).toHaveBeenCalledWith(['24h']);
         });
         it('passes undefined when no timeframe filter specified', async () => {
-            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockLoadConfig.mockResolvedValue({ apiKey: 'test-api-key' });
             mockGetUnpredictedRounds.mockResolvedValue([]);
             const command = createMegathreadListCommand();
             await command.parseAsync(['--agent', 'test-agent'], { from: 'user' });
@@ -121,13 +122,13 @@ describe('createMegathreadListCommand', () => {
     });
     describe('credentials validation', () => {
         it('shows error when credentials are missing', async () => {
-            mockLoadCredentials.mockResolvedValue(null);
+            mockLoadConfig.mockResolvedValue(null);
             const command = createMegathreadListCommand();
             await expect(command.parseAsync(['--agent', 'test-agent'], { 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 = createMegathreadListCommand();
             await expect(command.parseAsync(['--agent', 'test-agent'], { from: 'user' })).rejects.toThrow('process.exit(1)');
             expect(consoleErrorOutput.join('\n')).toContain('No credentials found');
@@ -135,7 +136,7 @@ describe('createMegathreadListCommand', () => {
     });
     describe('rounds display', () => {
         it('shows message when no unpredicted rounds available', async () => {
-            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockLoadConfig.mockResolvedValue({ apiKey: 'test-api-key' });
             mockGetUnpredictedRounds.mockResolvedValue([]);
             const command = createMegathreadListCommand();
             await command.parseAsync(['--agent', 'test-agent'], { from: 'user' });
@@ -148,7 +149,7 @@ describe('createMegathreadListCommand', () => {
                 createMockActiveRound({ roundId: 'round-1', projectId: 'bitcoin', durationMs: 3600000 }),
                 createMockActiveRound({ roundId: 'round-2', projectId: 'ethereum', durationMs: 14400000 }),
             ];
-            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockLoadConfig.mockResolvedValue({ apiKey: 'test-api-key' });
             mockGetUnpredictedRounds.mockResolvedValue(mockRounds);
             const command = createMegathreadListCommand();
             await command.parseAsync(['--agent', 'test-agent'], { from: 'user' });
@@ -167,7 +168,7 @@ describe('createMegathreadListCommand', () => {
             const mockRounds = [
                 createMockActiveRound({ roundId: 'round-1', projectId: 'bitcoin', durationMs: 7200000 }),
             ];
-            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockLoadConfig.mockResolvedValue({ apiKey: 'test-api-key' });
             mockGetUnpredictedRounds.mockResolvedValue(mockRounds);
             const command = createMegathreadListCommand();
             await command.parseAsync(['--agent', 'test-agent'], { from: 'user' });
@@ -177,7 +178,7 @@ describe('createMegathreadListCommand', () => {
     });
     describe('API error handling', () => {
         it('shows error when API call fails', async () => {
-            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockLoadConfig.mockResolvedValue({ apiKey: 'test-api-key' });
             mockGetUnpredictedRounds.mockRejectedValue(new Error('Network error'));
             const command = createMegathreadListCommand();
             await expect(command.parseAsync(['--agent', 'test-agent'], { from: 'user' })).rejects.toThrow('process.exit(1)');
@@ -185,7 +186,7 @@ describe('createMegathreadListCommand', () => {
             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' });
             mockGetUnpredictedRounds.mockRejectedValue('String error');
             const command = createMegathreadListCommand();
             await expect(command.parseAsync(['--agent', 'test-agent'], { from: 'user' })).rejects.toThrow('process.exit(1)');
@@ -195,7 +196,7 @@ describe('createMegathreadListCommand', () => {
     });
     describe('works with different fixture agents', () => {
         it('works with empty-agent', async () => {
-            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockLoadConfig.mockResolvedValue({ apiKey: 'test-api-key' });
             mockGetUnpredictedRounds.mockResolvedValue([]);
             const command = createMegathreadListCommand();
             await command.parseAsync(['--agent', 'empty-agent'], { from: 'user' });

package/dist/commands/start/commands/prediction.js

@@ -1,4 +1,4 @@
-import { credentialsPath, loadCredentials } from '@zhive/sdk';
+import { loadConfig } from '@zhive/sdk';
 import { HIVE_API_URL } from '../../../shared/config/constant.js';
 import { extractErrorMessage } from '../../../shared/agent/utils.js';
 import { styled } from '../../shared/theme.js';
@@ -29,8 +29,7 @@ export function formatPredictions(predictions) {
         const conviction = `${sign}${pred.conviction.toFixed(1)}%`;
         const outcome = getOutcomeStr(pred);
         const date = new Date(pred.created_at).toLocaleDateString();
-        const roundStart = pred.round_id.split('@Z')[0];
-        const durationMs = new Date(pred.resolved_at).getTime() - new Date(roundStart).getTime();
+        const durationMs = pred.duration_ms ?? 0;
         const duration = { 3600000: '1h', 14400000: '4h', 86400000: '24h' }[durationMs] || '??';
         return { name: pred.project_id, duration, conviction, outcome, date };
     });
@@ -51,13 +50,12 @@ function getOutcomeStr(pred) {
         return `[WIN] +${pred.honey.toFixed(2)} Honey`;
     }
     if (pred.wax > 0) {
-        return `[WIN] +${pred.wax.toFixed(2)} Wax`;
+        return `[LOSS] +${pred.wax.toFixed(2)} Wax`;
     }
     return '[LOSS]';
 }
 export async function predictionSlashCommand(agentName, callbacks) {
-    const filePath = credentialsPath(agentName);
-    const credentials = await loadCredentials(filePath);
+    const credentials = await loadConfig();
     if (!credentials?.apiKey) {
         callbacks.onError?.('Agent not registered yet. Wait for agent to start.');
         return;

package/dist/commands/start/hooks/useChat.js

@@ -7,7 +7,6 @@ import { fetchRulesTool } from '../../../shared/agent/tools/fetch-rules.js';
 import { extractErrorMessage } from '../../../shared/agent/utils.js';
 import { loadAgentConfig } from '../../../shared/config/agent.js';
 import { getModel } from '../../../shared/config/ai-providers.js';
-import { backtestSlashCommand } from '../commands/backtest.js';
 import { predictionSlashCommand } from '../commands/prediction.js';
 import { skillsSlashCommand } from '../commands/skills.js';
 import { SLASH_COMMANDS } from '../services/command-registry.js';
@@ -73,46 +72,46 @@ export function useChat(agentName) {
                     const memoryOutput = memoryRef.current || 'No memory stored yet.';
                     addChatActivity({ type: 'chat-agent', text: memoryOutput });
                 },
-                '/backtest': async () => {
-                    const config = {
-                        agentPath: process.cwd(),
-                        soulContent: soulContentRef.current,
-                        strategyContent: strategyContentRef.current,
-                        agentName: agentName,
-                    };
-                    await backtestSlashCommand(parts.slice(1), config, {
-                        onFetchStart: (numThreads) => {
-                            addChatActivity({
-                                type: 'chat-agent',
-                                text: `Fetching ${numThreads} resolved threads...`,
-                            });
-                        },
-                        onFetchError: (error) => {
-                            addChatActivity({
-                                type: 'chat-agent',
-                                text: `API fetch failed (${error}), falling back to default dataset...`,
-                            });
-                            addChatActivity({
-                                type: 'chat-agent',
-                                text: 'Starting backtest against default dataset...',
-                            });
-                        },
-                        onThreadStart: (index, total, thread) => {
-                            addChatActivity({
-                                type: 'chat-agent',
-                                text: `Processing ${index + 1}/${total}: ${thread.project_name}...`,
-                            });
-                        },
-                        onBacktestSuccess: (report) => {
-                            addChatActivity({ type: 'chat-agent', text: report });
-                            sessionMessagesRef.current.push({ role: 'assistant', content: report });
-                        },
-                        onBacktestError: (err) => {
-                            const errMessage = extractErrorMessage(err);
-                            addChatActivity({ type: 'chat-error', text: `Backtest failed: ${errMessage}` });
-                        },
-                    });
-                },
+                // '/backtest': async () => {
+                //   const config: RunnerConfig = {
+                //     agentPath: process.cwd(),
+                //     soulContent: soulContentRef.current,
+                //     strategyContent: strategyContentRef.current,
+                //     agentName: agentName,
+                //   };
+                //   await backtestSlashCommand(parts.slice(1), config, {
+                //     onFetchStart: (numThreads) => {
+                //       addChatActivity({
+                //         type: 'chat-agent',
+                //         text: `Fetching ${numThreads} resolved threads...`,
+                //       });
+                //     },
+                //     onFetchError: (error: string) => {
+                //       addChatActivity({
+                //         type: 'chat-agent',
+                //         text: `API fetch failed (${error}), falling back to default dataset...`,
+                //       });
+                //       addChatActivity({
+                //         type: 'chat-agent',
+                //         text: 'Starting backtest against default dataset...',
+                //       });
+                //     },
+                //     onThreadStart: (index, total, thread) => {
+                //       addChatActivity({
+                //         type: 'chat-agent',
+                //         text: `Processing ${index + 1}/${total}: ${thread.project_name}...`,
+                //       });
+                //     },
+                //     onBacktestSuccess: (report: string) => {
+                //       addChatActivity({ type: 'chat-agent', text: report });
+                //       sessionMessagesRef.current.push({ role: 'assistant', content: report });
+                //     },
+                //     onBacktestError: (err: unknown) => {
+                //       const errMessage = extractErrorMessage(err);
+                //       addChatActivity({ type: 'chat-error', text: `Backtest failed: ${errMessage}` });
+                //     },
+                //   });
+                // },
                 '/prediction': async () => {
                     await predictionSlashCommand(agentName, {
                         onFetchStart: () => {

package/dist/commands/start/hooks/utils.js

@@ -43,7 +43,7 @@ const megathreadPostedActivityFormatter = {
         return `[${sign}${item.conviction.toFixed(2)}%] "${item.summary}"`;
     },
     getDetail(item) {
-        return item.id.split('@')[0];
+        return item.timestamp.toISOString();
     },
     format(item) {
         const lines = [];
@@ -61,7 +61,7 @@ const megathreadErrorActivityFormatter = {
         return item.errorMessage;
     },
     getDetail(item) {
-        return item.id.split('@')[0];
+        return item.timestamp.toISOString();
     },
     format(item) {
         const pad = ' '.repeat(13);
@@ -74,7 +74,7 @@ const megathreadActivityFormatter = {
         return `${projectTag} \u00B7 ${item.timeframe} round`;
     },
     getDetail(item) {
-        return item.id.split('@')[0];
+        return item.timestamp.toISOString();
     },
     format(item) {
         const mainLine = ` ${time(item)}${chalk.hex(colors.controversial)(symbols.hive)} ${chalk.hex(colors.controversial)(this.getText(item))}`;

package/dist/commands/start/services/command-registry.js

@@ -3,7 +3,7 @@ export const SLASH_COMMANDS = [
     { name: '/help', description: 'Show available commands' },
     { name: '/clear', description: 'Clear chat history' },
     { name: '/memory', description: 'Show current memory state' },
-    { name: '/backtest', description: 'Run agent against test set (/backtest <num> fetches from API)' },
+    // { name: '/backtest', description: 'Run agent against test set (/backtest <num> fetches from API)' },
     { name: '/prediction', description: 'Show your last 10 resolved predictions' },
 ];
 export function filterCommands(prefix) {

package/dist/index.js

@@ -9,6 +9,7 @@ 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';
+import { createDoctorCommand } from './commands/doctor/commands/index.js';
 const require = createRequire(import.meta.url);
 const packageJson = require('../package.json');
 const program = new Command();
@@ -21,6 +22,7 @@ program.addCommand(createStartCommand());
 program.addCommand(createStartAllCommand());
 program.addCommand(createRunCommand());
 program.addCommand(createMigrateTemplatesCommand());
+program.addCommand(createDoctorCommand());
 // Show help with exit code 0 when no arguments provided
 const args = process.argv.slice(2);
 if (args.length === 0) {

package/dist/shared/agent/handler.js

@@ -33,7 +33,7 @@ async function run({ round, runtime, reporter, recentComments, }) {
     const timeframe = calculateTimeframe(round);
     reporter.onRoundStart(round, timeframe);
     // ── Fetch prices ──────────────────────────────
-    const roundStartTimestamp = round.roundId.split('@Z')[0];
+    const roundStartTimestamp = new Date(round.snapTimeMs).toISOString();
     const { priceAtStart, currentPrice } = await fetchRoundPrices(round.projectId, roundStartTimestamp);
     if (priceAtStart !== undefined) {
         reporter.onPriceInfo(priceAtStart, currentPrice);
@@ -87,8 +87,6 @@ export function createMegathreadRoundBatchHandler(getAgent, runtime, reporter) {
             await agent.postMegathreadComment(round.roundId, {
                 text: data.summary,
                 conviction: data.conviction,
-                tokenId: round.projectId,
-                roundDuration: round.durationMs,
             });
             const timeframe = calculateTimeframe(round);
             reporter.onPosted(round, data.conviction, data.summary, timeframe, data.usage);
@@ -113,8 +111,6 @@ export function createMegathreadRoundHandler(getAgent, runtime, reporter) {
             await agent.postMegathreadComment(round.roundId, {
                 text: result.summary,
                 conviction: result.conviction,
-                tokenId: round.projectId,
-                roundDuration: round.durationMs,
             });
             const timeframe = calculateTimeframe(round);
             reporter.onPosted(round, result.conviction, result.summary, timeframe, result.usage);

package/dist/shared/config/agent.js

@@ -1,4 +1,3 @@
-import { loadCredentials, } from '@zhive/sdk';
 import axios from 'axios';
 import fsExtra from 'fs-extra';
 import * as fs from 'fs/promises';
@@ -183,13 +182,3 @@ export async function findAgentByName(name) {
     }
     return agent;
 }
-export function getCredentialsPath(agentDir, agentName) {
-    const sanitized = agentName.replace(/[^a-zA-Z0-9-_]/g, '-');
-    const credPath = path.join(agentDir, `hive-${sanitized}.json`);
-    return credPath;
-}
-export async function loadAgentCredentials(agentDir, agentName) {
-    const credPath = getCredentialsPath(agentDir, agentName);
-    const credentials = await loadCredentials(credPath);
-    return credentials;
-}

package/dist/shared/config/agent.test.js

@@ -14,42 +14,11 @@ vi.mock('./ai-providers.js', () => ({
     ],
 }));
 vi.mock('@zhive/sdk', () => ({
-    loadCredentials: vi.fn(),
+    loadConfig: vi.fn(),
 }));
-import { loadCredentials } from '@zhive/sdk';
-import { findAgentByName, getCredentialsPath, loadAgentCredentials, scanAgents, } from './agent.js';
-const mockLoadCredentials = loadCredentials;
-describe('getCredentialsPath', () => {
-    it('constructs correct path with simple agent name', () => {
-        const result = getCredentialsPath('/mock/.zhive/agents/my-agent', 'my-agent');
-        expect(result).toBe('/mock/.zhive/agents/my-agent/hive-my-agent.json');
-    });
-    it('sanitizes special characters in agent name', () => {
-        const result = getCredentialsPath('/mock/.zhive/agents/my-agent', 'my@agent!test');
-        expect(result).toBe('/mock/.zhive/agents/my-agent/hive-my-agent-test.json');
-    });
-    it('allows underscores and hyphens in agent name', () => {
-        const result = getCredentialsPath('/mock/.zhive/agents/test_agent', 'test_agent-v2');
-        expect(result).toBe('/mock/.zhive/agents/test_agent/hive-test_agent-v2.json');
-    });
-});
-describe('loadAgentCredentials', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('delegates to loadCredentials with correct path', async () => {
-        const mockCredentials = { apiKey: 'test-api-key' };
-        mockLoadCredentials.mockResolvedValue(mockCredentials);
-        const result = await loadAgentCredentials('/mock/.zhive/agents/test-agent', 'test-agent');
-        expect(mockLoadCredentials).toHaveBeenCalledWith('/mock/.zhive/agents/test-agent/hive-test-agent.json');
-        expect(result).toEqual(mockCredentials);
-    });
-    it('returns null when loadCredentials returns null', async () => {
-        mockLoadCredentials.mockResolvedValue(null);
-        const result = await loadAgentCredentials('/mock/.zhive/agents/test-agent', 'test-agent');
-        expect(result).toBeNull();
-    });
-});
+import { loadConfig } from '@zhive/sdk';
+import { findAgentByName, scanAgents } from './agent.js';
+const mockLoadConfig = loadConfig;
 describe('scanAgents', () => {
     beforeEach(() => {
         vi.clearAllMocks();

package/dist/shared/config/constant.js

@@ -9,8 +9,8 @@ export function getHiveDir() {
     const pathToCheck = [
         path.join(homeDir, '.zhive'),
         path.join(homeDir, '.hive'), // legacy hive dir
-        path.join(homeDir, '.openclaw', '.hive'),
-        path.join(homeDir, '.openclaw', 'workspace', '.hive'),
+        path.join(homeDir, '.openclaw', '.zhive'),
+        path.join(homeDir, '.openclaw', 'workspace', '.zhive'),
     ];
     for (const p of pathToCheck) {
         if (fs.existsSync(p)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhive/cli",
-  "version": "0.6.2",
+  "version": "0.6.4",
   "description": "CLI for bootstrapping zHive AI Agents",
   "type": "module",
   "main": "dist/index.js",
@@ -31,7 +31,7 @@
     "@ai-sdk/openai": "^3.0.25",
     "@ai-sdk/xai": "^3.0.0",
     "@openrouter/ai-sdk-provider": "^0.4.0",
-    "@zhive/sdk": "^0.5.4",
+    "@zhive/sdk": "^0.5.6",
     "ai": "^6.0.71",
     "axios": "^1.6.0",
     "chalk": "^5.3.0",