@zhive/cli 0.6.1 → 0.6.3

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

@@ -4,37 +4,14 @@ import { HiveClient } 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 { printZodError } from '../../shared/ validation.js';
 const CreateCommentOptionsSchema = z.object({
     agent: z.string().min(1),
     round: z.string().min(1),
-    conviction: z.string().transform((val, ctx) => {
-        const num = parseFloat(val);
-        if (isNaN(num)) {
-            ctx.addIssue({ code: z.ZodIssueCode.custom, message: `Must be a number. Got: ${val}` });
-            return z.NEVER;
-        }
-        if (num < -100 || num > 100) {
-            ctx.addIssue({
-                code: 'custom',
-                message: `Must be between -100 and 100. Got: ${val}`,
-            });
-            return z.NEVER;
-        }
-        return num;
-    }),
+    conviction: z.coerce.number().min(-100).max(100),
     text: z.string().min(1),
     token: z.string().min(1),
-    duration: z.string().transform((val, ctx) => {
-        const num = parseInt(val, 10);
-        if (isNaN(num) || num <= 0) {
-            ctx.addIssue({
-                code: 'custom',
-                message: `Must be a positive number. Got: ${val}`,
-            });
-            return z.NEVER;
-        }
-        return num;
-    }),
+    timeframe: z.enum(['1h', '4h', '24h']),
 });
 export function createMegathreadCreateCommentCommand() {
     return new Command('create-comment')
@@ -44,17 +21,14 @@ export function createMegathreadCreateCommentCommand() {
         .requiredOption('--conviction <number>', 'Conviction score (-100 to 100)')
         .requiredOption('--text <text>', 'Comment text')
         .requiredOption('--token <tokenId>', 'Token/project ID')
-        .requiredOption('--duration <ms>', 'Round duration in milliseconds')
+        .requiredOption('--timeframe <tf>', 'Timeframe (1h, 4h, 24h)')
         .action(async (options) => {
         const parseResult = CreateCommentOptionsSchema.safeParse(options);
         if (!parseResult.success) {
-            const errors = parseResult.error.issues
-                .map((e) => `${e.path.join('.')}: ${e.message}`)
-                .join(', ');
-            console.error(styled.red(`${symbols.cross} Validation error: ${errors}`));
+            printZodError(parseResult);
             process.exit(1);
         }
-        const { agent: agentName, round: roundId, conviction, text, token, duration, } = parseResult.data;
+        const { agent: agentName, round: roundId, conviction, text, token, timeframe, } = parseResult.data;
         const agentConfig = await findAgentByName(agentName);
         if (!agentConfig) {
             const agents = await scanAgents();
@@ -76,8 +50,6 @@ export function createMegathreadCreateCommentCommand() {
         const payload = {
             text,
             conviction,
-            tokenId: token,
-            roundDuration: duration,
         };
         try {
             await client.postMegathreadComment(roundId, payload);

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');
@@ -83,11 +81,11 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Test comment',
                 '--token',
                 'bitcoin',
-                '--duration',
-                '3600000',
+                '--timeframe',
+                '1h',
             ], { from: 'user' })).rejects.toThrow('process.exit(1)');
-            expect(consoleErrorOutput.join('\n')).toContain('conviction: Must be between -100 and 100');
-            expect(consoleErrorOutput.join('\n')).toContain('Got: 150');
+            expect(consoleErrorOutput.join('\n')).toContain('conviction');
+            expect(consoleErrorOutput.join('\n')).toContain('100');
         });
         it('shows error when conviction is too low', async () => {
             const command = createMegathreadCreateCommentCommand();
@@ -102,11 +100,11 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Test comment',
                 '--token',
                 'bitcoin',
-                '--duration',
-                '3600000',
+                '--timeframe',
+                '1h',
             ], { from: 'user' })).rejects.toThrow('process.exit(1)');
-            expect(consoleErrorOutput.join('\n')).toContain('conviction: Must be between -100 and 100');
-            expect(consoleErrorOutput.join('\n')).toContain('Got: -150');
+            expect(consoleErrorOutput.join('\n')).toContain('conviction');
+            expect(consoleErrorOutput.join('\n')).toContain('-100');
         });
         it('shows error when conviction is not a number', async () => {
             const command = createMegathreadCreateCommentCommand();
@@ -121,11 +119,11 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Test comment',
                 '--token',
                 'bitcoin',
-                '--duration',
-                '3600000',
+                '--timeframe',
+                '1h',
             ], { from: 'user' })).rejects.toThrow('process.exit(1)');
-            expect(consoleErrorOutput.join('\n')).toContain('conviction: Must be a number');
-            expect(consoleErrorOutput.join('\n')).toContain('Got: abc');
+            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' });
@@ -142,14 +140,12 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Test comment',
                 '--token',
                 'bitcoin',
-                '--duration',
-                '3600000',
+                '--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 () => {
@@ -167,14 +163,12 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Test comment',
                 '--token',
                 'bitcoin',
-                '--duration',
-                '3600000',
+                '--timeframe',
+                '1h',
             ], { from: 'user' });
             expect(mockPostMegathreadComment).toHaveBeenCalledWith('round-123', {
                 text: 'Test comment',
                 conviction: -100,
-                tokenId: 'bitcoin',
-                roundDuration: 3600000,
             });
         });
         it('accepts decimal conviction values', async () => {
@@ -192,19 +186,17 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Test comment',
                 '--token',
                 'bitcoin',
-                '--duration',
-                '3600000',
+                '--timeframe',
+                '1h',
             ], { from: 'user' });
             expect(mockPostMegathreadComment).toHaveBeenCalledWith('round-123', {
                 text: 'Test comment',
                 conviction: 25.5,
-                tokenId: 'bitcoin',
-                roundDuration: 3600000,
             });
         });
     });
-    describe('duration validation', () => {
-        it('shows error when duration is negative', async () => {
+    describe('timeframe validation', () => {
+        it('shows error for invalid timeframe value', async () => {
             const command = createMegathreadCreateCommentCommand();
             await expect(command.parseAsync([
                 '--agent',
@@ -217,15 +209,15 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Test comment',
                 '--token',
                 'bitcoin',
-                '--duration',
-                '-1',
+                '--timeframe',
+                '2h',
             ], { from: 'user' })).rejects.toThrow('process.exit(1)');
-            expect(consoleErrorOutput.join('\n')).toContain('duration: Must be a positive number');
-            expect(consoleErrorOutput.join('\n')).toContain('Got: -1');
         });
-        it('shows error when duration is zero', async () => {
+        it('accepts 1h timeframe', async () => {
+            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockPostMegathreadComment.mockResolvedValue(undefined);
             const command = createMegathreadCreateCommentCommand();
-            await expect(command.parseAsync([
+            await command.parseAsync([
                 '--agent',
                 'test-agent',
                 '--round',
@@ -236,15 +228,19 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Test comment',
                 '--token',
                 'bitcoin',
-                '--duration',
-                '0',
-            ], { from: 'user' })).rejects.toThrow('process.exit(1)');
-            expect(consoleErrorOutput.join('\n')).toContain('duration: Must be a positive number');
-            expect(consoleErrorOutput.join('\n')).toContain('Got: 0');
+                '--timeframe',
+                '1h',
+            ], { from: 'user' });
+            expect(mockPostMegathreadComment).toHaveBeenCalledWith('round-123', {
+                text: 'Test comment',
+                conviction: 50,
+            });
         });
-        it('shows error when duration is not a number', async () => {
+        it('accepts 4h timeframe', async () => {
+            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockPostMegathreadComment.mockResolvedValue(undefined);
             const command = createMegathreadCreateCommentCommand();
-            await expect(command.parseAsync([
+            await command.parseAsync([
                 '--agent',
                 'test-agent',
                 '--round',
@@ -255,11 +251,36 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Test comment',
                 '--token',
                 'bitcoin',
-                '--duration',
-                'abc',
-            ], { from: 'user' })).rejects.toThrow('process.exit(1)');
-            expect(consoleErrorOutput.join('\n')).toContain('duration: Must be a positive number');
-            expect(consoleErrorOutput.join('\n')).toContain('Got: abc');
+                '--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', () => {
@@ -276,8 +297,8 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Test comment',
                 '--token',
                 'bitcoin',
-                '--duration',
-                '3600000',
+                '--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:');
@@ -301,8 +322,8 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Test comment',
                 '--token',
                 'bitcoin',
-                '--duration',
-                '3600000',
+                '--timeframe',
+                '1h',
             ], { from: 'user' })).rejects.toThrow('process.exit(1)');
             expect(consoleErrorOutput.join('\n')).toContain('No credentials found for agent "test-agent"');
         });
@@ -320,8 +341,8 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Test comment',
                 '--token',
                 'bitcoin',
-                '--duration',
-                '3600000',
+                '--timeframe',
+                '1h',
             ], { from: 'user' })).rejects.toThrow('process.exit(1)');
             expect(consoleErrorOutput.join('\n')).toContain('No credentials found');
         });
@@ -342,14 +363,12 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Bullish on Bitcoin!',
                 '--token',
                 'bitcoin',
-                '--duration',
-                '3600000',
+                '--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');
@@ -373,8 +392,8 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Bearish outlook',
                 '--token',
                 'ethereum',
-                '--duration',
-                '14400000',
+                '--timeframe',
+                '4h',
             ], { from: 'user' });
             const output = consoleOutput.join('\n');
             expect(output).toContain('-30.0%');
@@ -395,15 +414,13 @@ describe('createMegathreadCreateCommentCommand', () => {
                 longText,
                 '--token',
                 'bitcoin',
-                '--duration',
-                '3600000',
+                '--timeframe',
+                '1h',
             ], { 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');
@@ -426,8 +443,8 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Test comment',
                 '--token',
                 'bitcoin',
-                '--duration',
-                '3600000',
+                '--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');
@@ -447,8 +464,8 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Test comment',
                 '--token',
                 'bitcoin',
-                '--duration',
-                '3600000',
+                '--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');
@@ -470,8 +487,8 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Test comment',
                 '--token',
                 'bitcoin',
-                '--duration',
-                '3600000',
+                '--timeframe',
+                '1h',
             ], { from: 'user' });
             const output = consoleOutput.join('\n');
             expect(output).toContain('Comment posted successfully');

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

@@ -1,47 +1,43 @@
 import { Command } from 'commander';
-import { HiveClient, TIMEFRAME_DURATION_MS, Timeframe } from '@zhive/sdk';
+import { HiveClient, durationMsToTimeframe } 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 z from 'zod';
+import { printZodError } from '../../shared/ validation.js';
 const VALID_TIMEFRAMES = ['1h', '4h', '24h'];
-const DURATION_MS_TO_TIMEFRAME = {
-    [TIMEFRAME_DURATION_MS[Timeframe.H1]]: Timeframe.H1,
-    [TIMEFRAME_DURATION_MS[Timeframe.H4]]: Timeframe.H4,
-    [TIMEFRAME_DURATION_MS[Timeframe.H24]]: Timeframe.H24,
-};
-function durationMsToTimeframe(durationMs) {
-    const result = DURATION_MS_TO_TIMEFRAME[durationMs];
-    return result;
-}
-function parseTimeframes(raw) {
-    const parts = raw.split(',').map((t) => t.trim());
-    const invalid = parts.filter((t) => !VALID_TIMEFRAMES.includes(t));
-    if (invalid.length > 0) {
-        return null;
-    }
-    const parsed = parts;
-    return parsed;
-}
+const ListMegathreadOptionsSchema = z.object({
+    agent: z.string(),
+    timeframe: z
+        .string()
+        .optional()
+        .transform((val, ctx) => {
+        if (!val)
+            return undefined;
+        const parsed = val.split(',').map((t) => t.trim());
+        const invalidParts = parsed.filter((t) => !VALID_TIMEFRAMES.includes(t));
+        if (invalidParts.length > 0) {
+            ctx.addIssue({
+                code: 'custom',
+                message: `Invalid. valid values are [${VALID_TIMEFRAMES.join(', ')}]`,
+            });
+            return z.NEVER;
+        }
+        return parsed;
+    }),
+});
 export function createMegathreadListCommand() {
     const program = new Command('list')
         .description('List unpredicted megathread rounds of an agent')
         .requiredOption('--agent <name>', 'Agent name')
         .option('--timeframe <timeframes>', 'Filter by timeframes (comma-separated: 1h,4h,24h)')
         .action(async (options) => {
-        const { agent: agentName, timeframe: timeframeOption } = options;
-        let timeframes;
-        if (timeframeOption) {
-            const parsed = parseTimeframes(timeframeOption);
-            if (parsed === null) {
-                const invalidParts = timeframeOption
-                    .split(',')
-                    .map((t) => t.trim())
-                    .filter((t) => !VALID_TIMEFRAMES.includes(t));
-                console.error(styled.red(`${symbols.cross} Invalid timeframes: ${invalidParts.join(', ')}. Valid values: 1h, 4h, 24h`));
-                process.exit(1);
-            }
-            timeframes = parsed;
+        const parseResult = ListMegathreadOptionsSchema.safeParse(options);
+        if (!parseResult.success) {
+            printZodError(parseResult);
+            process.exit(1);
         }
+        const { agent: agentName, timeframe: timeframes } = parseResult.data;
         const agentConfig = await findAgentByName(agentName);
         if (!agentConfig) {
             const agents = await scanAgents();
@@ -70,11 +66,11 @@ export function createMegathreadListCommand() {
                 console.log('');
                 return;
             }
-            const headers = ['Round ID', 'Token', 'Timeframe'];
+            const headers = ['Round ID', 'Token', 'Timeframe', 'PriceAtStart'];
             const rows = rounds.map((r) => {
                 const tf = durationMsToTimeframe(r.durationMs);
                 const timeframeStr = tf ?? `${r.durationMs}ms`;
-                return [r.roundId, r.projectId, timeframeStr];
+                return [r.roundId, r.projectId, timeframeStr, r.priceAtStart];
             });
             const colWidths = headers.map((h, i) => {
                 const dataMax = Math.max(...rows.map((row) => String(row[i]).length));

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

@@ -39,6 +39,8 @@ function createMockActiveRound(overrides = {}) {
         roundId: 'round-123',
         projectId: 'bitcoin',
         durationMs: 3600000,
+        snapTimeMs: Date.now(),
+        priceAtStart: null,
         ...overrides,
     };
 }
@@ -78,13 +80,12 @@ describe('createMegathreadListCommand', () => {
         it('shows error for invalid timeframe value', async () => {
             const command = createMegathreadListCommand();
             await expect(command.parseAsync(['--agent', 'test-agent', '--timeframe', '2h'], { from: 'user' })).rejects.toThrow('process.exit(1)');
-            expect(consoleErrorOutput.join('\n')).toContain('Invalid timeframes: 2h');
-            expect(consoleErrorOutput.join('\n')).toContain('Valid values: 1h, 4h, 24h');
+            expect(consoleErrorOutput.length).toBeGreaterThan(0);
         });
         it('shows error for multiple invalid timeframes', async () => {
             const command = createMegathreadListCommand();
             await expect(command.parseAsync(['--agent', 'test-agent', '--timeframe', '2h,5h'], { from: 'user' })).rejects.toThrow('process.exit(1)');
-            expect(consoleErrorOutput.join('\n')).toContain('Invalid timeframes: 2h, 5h');
+            expect(consoleErrorOutput.length).toBeGreaterThan(0);
         });
         it('accepts valid timeframe values', async () => {
             mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });

package/dist/commands/shared/ validation.js

@@ -0,0 +1,5 @@
+import { styled, symbols } from './theme.js';
+export const printZodError = (result) => {
+    const errors = result.error.issues.map((e) => `${e.path.join('.')}: ${e.message}`).join(', ');
+    console.error(styled.red(`${symbols.cross} Validation error: ${errors}`));
+};

package/dist/commands/start/commands/prediction.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 };
     });

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/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/constant.js

@@ -6,12 +6,16 @@ export const HIVE_FRONTEND_URL = 'https://www.zhive.ai';
 export function getHiveDir() {
     const homeDir = os.homedir();
     const zhiveDir = path.join(homeDir, '.zhive');
-    const legacyDir = path.join(homeDir, '.hive');
-    if (fs.existsSync(zhiveDir)) {
-        return zhiveDir;
-    }
-    if (fs.existsSync(legacyDir)) {
-        return legacyDir;
+    const pathToCheck = [
+        path.join(homeDir, '.zhive'),
+        path.join(homeDir, '.hive'), // legacy hive dir
+        path.join(homeDir, '.openclaw', '.zhive'),
+        path.join(homeDir, '.openclaw', 'workspace', '.zhive'),
+    ];
+    for (const p of pathToCheck) {
+        if (fs.existsSync(p)) {
+            return p;
+        }
     }
     return zhiveDir;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhive/cli",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "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.3",
+    "@zhive/sdk": "^0.5.5",
     "ai": "^6.0.71",
     "axios": "^1.6.0",
     "chalk": "^5.3.0",