@zhive/cli 0.5.5 → 0.6.1

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

@@ -0,0 +1,206 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { fileURLToPath } from 'node:url';
+import * as path from 'node:path';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const FIXTURES_DIR = path.join(__dirname, '../../../../__fixtures__/mock-hive');
+vi.mock('../../../shared/config/constant.js', () => ({
+    getHiveDir: vi.fn(() => FIXTURES_DIR),
+    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' }],
+}));
+vi.mock('@zhive/sdk', async () => {
+    const actual = await vi.importActual('@zhive/sdk');
+    return {
+        ...actual,
+        HiveClient: vi.fn().mockImplementation(() => ({
+            getUnpredictedRounds: vi.fn(),
+        })),
+        loadCredentials: vi.fn(),
+        TIMEFRAME_DURATION_MS: {
+            H1: 3600000,
+            H4: 14400000,
+            H24: 86400000,
+        },
+        Timeframe: {
+            H1: 'H1',
+            H4: 'H4',
+            H24: 'H24',
+        },
+    };
+});
+import { HiveClient, loadCredentials } from '@zhive/sdk';
+import { createMegathreadListCommand } from './list.js';
+const MockHiveClient = HiveClient;
+const mockLoadCredentials = loadCredentials;
+function createMockActiveRound(overrides = {}) {
+    return {
+        roundId: 'round-123',
+        projectId: 'bitcoin',
+        durationMs: 3600000,
+        ...overrides,
+    };
+}
+describe('createMegathreadListCommand', () => {
+    let consoleLogSpy;
+    let consoleErrorSpy;
+    let processExitSpy;
+    let consoleOutput;
+    let consoleErrorOutput;
+    let mockGetUnpredictedRounds;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        consoleOutput = [];
+        consoleErrorOutput = [];
+        consoleLogSpy = vi.spyOn(console, 'log').mockImplementation((...args) => {
+            consoleOutput.push(args.join(' '));
+        });
+        consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation((...args) => {
+            consoleErrorOutput.push(args.join(' '));
+        });
+        processExitSpy = vi
+            .spyOn(process, 'exit')
+            .mockImplementation((code) => {
+            throw new Error(`process.exit(${code})`);
+        });
+        mockGetUnpredictedRounds = vi.fn();
+        MockHiveClient.mockImplementation(() => ({
+            getUnpredictedRounds: mockGetUnpredictedRounds,
+        }));
+    });
+    afterEach(() => {
+        consoleLogSpy.mockRestore();
+        consoleErrorSpy.mockRestore();
+        processExitSpy.mockRestore();
+    });
+    describe('timeframe validation', () => {
+        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');
+        });
+        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');
+        });
+        it('accepts valid timeframe values', async () => {
+            mockLoadCredentials.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' });
+            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' });
+            mockGetUnpredictedRounds.mockResolvedValue([]);
+            const command = createMegathreadListCommand();
+            await command.parseAsync(['--agent', 'test-agent'], { from: 'user' });
+            expect(mockGetUnpredictedRounds).toHaveBeenCalledWith(undefined);
+        });
+    });
+    describe('agent validation', () => {
+        it('shows error when agent not found and lists available agents', async () => {
+            const command = createMegathreadListCommand();
+            await expect(command.parseAsync(['--agent', 'non-existent'], { from: 'user' })).rejects.toThrow('process.exit(1)');
+            expect(consoleErrorOutput.join('\n')).toContain('Agent "non-existent" not found');
+            expect(consoleErrorOutput.join('\n')).toContain('Available agents:');
+            expect(consoleErrorOutput.join('\n')).toContain('test-agent');
+            expect(consoleErrorOutput.join('\n')).toContain('empty-agent');
+            expect(consoleErrorOutput.join('\n')).toContain('agent-no-skills');
+        });
+    });
+    describe('credentials validation', () => {
+        it('shows error when credentials are missing', async () => {
+            mockLoadCredentials.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 });
+            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');
+        });
+    });
+    describe('rounds display', () => {
+        it('shows message when no unpredicted rounds available', async () => {
+            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockGetUnpredictedRounds.mockResolvedValue([]);
+            const command = createMegathreadListCommand();
+            await command.parseAsync(['--agent', 'test-agent'], { from: 'user' });
+            const output = consoleOutput.join('\n');
+            expect(output).toContain('Unpredicted Rounds for test-agent');
+            expect(output).toContain('No unpredicted rounds available');
+        });
+        it('displays rounds in table format', async () => {
+            const mockRounds = [
+                createMockActiveRound({ roundId: 'round-1', projectId: 'bitcoin', durationMs: 3600000 }),
+                createMockActiveRound({ roundId: 'round-2', projectId: 'ethereum', durationMs: 14400000 }),
+            ];
+            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockGetUnpredictedRounds.mockResolvedValue(mockRounds);
+            const command = createMegathreadListCommand();
+            await command.parseAsync(['--agent', 'test-agent'], { from: 'user' });
+            const output = consoleOutput.join('\n');
+            expect(output).toContain('Unpredicted Rounds for test-agent');
+            expect(output).toContain('Round ID');
+            expect(output).toContain('Token');
+            expect(output).toContain('Timeframe');
+            expect(output).toContain('round-1');
+            expect(output).toContain('bitcoin');
+            expect(output).toContain('round-2');
+            expect(output).toContain('ethereum');
+            expect(output).toContain('Total: 2 round(s)');
+        });
+        it('shows fallback duration when timeframe not recognized', async () => {
+            const mockRounds = [
+                createMockActiveRound({ roundId: 'round-1', projectId: 'bitcoin', durationMs: 7200000 }),
+            ];
+            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockGetUnpredictedRounds.mockResolvedValue(mockRounds);
+            const command = createMegathreadListCommand();
+            await command.parseAsync(['--agent', 'test-agent'], { from: 'user' });
+            const output = consoleOutput.join('\n');
+            expect(output).toContain('7200000ms');
+        });
+    });
+    describe('API error handling', () => {
+        it('shows error when API call fails', async () => {
+            mockLoadCredentials.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)');
+            expect(consoleErrorOutput.join('\n')).toContain('Failed to fetch unpredicted rounds');
+            expect(consoleErrorOutput.join('\n')).toContain('Network error');
+        });
+        it('handles non-Error exceptions', async () => {
+            mockLoadCredentials.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)');
+            expect(consoleErrorOutput.join('\n')).toContain('Failed to fetch unpredicted rounds');
+            expect(consoleErrorOutput.join('\n')).toContain('String error');
+        });
+    });
+    describe('works with different fixture agents', () => {
+        it('works with empty-agent', async () => {
+            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockGetUnpredictedRounds.mockResolvedValue([]);
+            const command = createMegathreadListCommand();
+            await command.parseAsync(['--agent', 'empty-agent'], { from: 'user' });
+            const output = consoleOutput.join('\n');
+            expect(output).toContain('Unpredicted Rounds for empty-agent');
+        });
+    });
+});

package/dist/commands/migrate-templates/commands/index.js

@@ -1,9 +1,14 @@
+import { Command } from 'commander';
 import { render } from 'ink';
 import React from 'react';
 import { showWelcome } from '../../shared/welcome.js';
 import { MigrateApp } from '../ui/MigrateApp.js';
-export const migrateTemplateCommand = async () => {
-    await showWelcome();
-    const { waitUntilExit } = render(React.createElement(MigrateApp));
-    await waitUntilExit();
+export const createMigrateTemplatesCommand = () => {
+    return new Command('migrate-templates')
+        .description('Migrate old-style agents')
+        .action(async () => {
+        await showWelcome();
+        const { waitUntilExit } = render(React.createElement(MigrateApp));
+        await waitUntilExit();
+    });
 };

package/dist/commands/run/commands/index.js

@@ -1,17 +1,22 @@
+import { Command } from 'commander';
 import { access } from 'fs/promises';
 import { join } from 'path';
 import { runHeadless } from '../run-headless.js';
 import { loadAgentEnv } from '../../../shared/config/env-loader.js';
-export const runCommand = async () => {
-    // Headless agent run — no TUI, just console output.
-    // Used by start-all to spawn agents as child processes.
-    const isAgentDir = await access(join(process.cwd(), 'SOUL.md'))
-        .then(() => true)
-        .catch(() => false);
-    if (!isAgentDir) {
-        console.error('Error: "run" must be called from an agent directory (with SOUL.md)');
-        process.exit(1);
-    }
-    await loadAgentEnv();
-    await runHeadless();
+export const createRunCommand = () => {
+    return new Command('run')
+        .description('Run agent headless (no TUI, used by start-all)')
+        .action(async () => {
+        // Headless agent run — no TUI, just console output.
+        // Used by start-all to spawn agents as child processes.
+        const isAgentDir = await access(join(process.cwd(), 'SOUL.md'))
+            .then(() => true)
+            .catch(() => false);
+        if (!isAgentDir) {
+            console.error('Error: "run" must be called from an agent directory (with SOUL.md)');
+            process.exit(1);
+        }
+        await loadAgentEnv();
+        await runHeadless();
+    });
 };

package/dist/commands/run/run-headless.js

@@ -1,8 +1,9 @@
 import { HiveAgent } from '@zhive/sdk';
-import { initializeAgentRuntime, createMegathreadRoundHandler, } from '../../shared/agent/agent-runtime.js';
 import { HIVE_API_URL, HIVE_FRONTEND_URL } from '../../shared/config/constant.js';
 import { resolveModelInfo } from '../../shared/config/ai-providers.js';
 import { formatTokenCount, formatTokenUsage } from '../../shared/agent/utils.js';
+import { initializeAgentRuntime } from '../../shared/agent/runtime.js';
+import { createMegathreadRoundHandler } from '../../shared/agent/handler.js';
 function formatUsageLine(usage) {
     const { input, output, tools } = formatTokenUsage(usage);
     const toolSuffix = tools !== null ? ` \u00b7 ${tools}` : '';

package/dist/commands/start/commands/index.js

@@ -1,3 +1,4 @@
+import { Command } from 'commander';
 import { render } from 'ink';
 import React from 'react';
 import { App } from '../ui/app.js';
@@ -6,43 +7,47 @@ import { showHoneycombBoot } from '../ui/HoneycombBoot.js';
 import chalk from 'chalk';
 import { symbols } from '../../shared/theme.js';
 import { loadAgentEnv } from '../../../shared/config/env-loader.js';
-export const startCommand = async () => {
-    // Detect if cwd is an agent directory (has SOUL.md).
-    // When called via agent's "npm start", cwd is the agent dir.
-    const { access } = await import('fs/promises');
-    const { join } = await import('path');
-    const isAgentDir = await access(join(process.cwd(), 'SOUL.md'))
-        .then(() => true)
-        .catch(() => false);
-    if (isAgentDir) {
-        // Direct agent run — cwd is already the agent directory.
-        await loadAgentEnv();
-        setupProcessLifecycle();
-        const { waitUntilExit } = render(React.createElement(App));
-        await waitUntilExit();
-    }
-    else {
-        // Interactive agent selection
-        let selectedAgent = null;
-        const { waitUntilExit: waitForSelect } = render(React.createElement(SelectAgentApp, {
-            onSelect: (agent) => {
-                selectedAgent = agent;
-            },
-        }));
-        await waitForSelect();
-        if (selectedAgent) {
-            const picked = selectedAgent;
-            await showHoneycombBoot(picked.name);
-            // Clear screen + scrollback so boot animation and agent picker
-            // don't appear when scrolling up in the agent TUI.
-            process.stdout.write('\x1b[2J\x1b[3J\x1b[H');
-            process.chdir(picked.dir);
+export const createStartCommand = () => {
+    return new Command('start')
+        .description('Start an agent (auto-detects agent dir)')
+        .action(async () => {
+        // Detect if cwd is an agent directory (has SOUL.md).
+        // When called via agent's "npm start", cwd is the agent dir.
+        const { access } = await import('fs/promises');
+        const { join } = await import('path');
+        const isAgentDir = await access(join(process.cwd(), 'SOUL.md'))
+            .then(() => true)
+            .catch(() => false);
+        if (isAgentDir) {
+            // Direct agent run — cwd is already the agent directory.
             await loadAgentEnv();
             setupProcessLifecycle();
             const { waitUntilExit } = render(React.createElement(App));
             await waitUntilExit();
         }
-    }
+        else {
+            // Interactive agent selection
+            let selectedAgent = null;
+            const { waitUntilExit: waitForSelect } = render(React.createElement(SelectAgentApp, {
+                onSelect: (agent) => {
+                    selectedAgent = agent;
+                },
+            }));
+            await waitForSelect();
+            if (selectedAgent) {
+                const picked = selectedAgent;
+                await showHoneycombBoot(picked.name);
+                // Clear screen + scrollback so boot animation and agent picker
+                // don't appear when scrolling up in the agent TUI.
+                process.stdout.write('\x1b[2J\x1b[3J\x1b[H');
+                process.chdir(picked.dir);
+                await loadAgentEnv();
+                setupProcessLifecycle();
+                const { waitUntilExit } = render(React.createElement(App));
+                await waitUntilExit();
+            }
+        }
+    });
 };
 const exitImmediately = (exitCode = 0) => {
     process.exit(exitCode);

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

@@ -1,11 +1,12 @@
 import { HiveAgent } from '@zhive/sdk';
 import { useEffect, useRef, useState } from 'react';
-import { createMegathreadRoundBatchHandler, createMegathreadRoundHandler, initializeAgentRuntime, } from '../../../shared/agent/agent-runtime.js';
 import { extractErrorMessage } from '../../../shared/agent/utils.js';
 import { resolveModelInfo } from '../../../shared/config/ai-providers.js';
 import { fetchBulkStats } from '../../../shared/config/agent.js';
 import { HIVE_API_URL } from '../../../shared/config/constant.js';
 import { usePollActivity } from './usePollActivity.js';
+import { initializeAgentRuntime } from '../../../shared/agent/runtime.js';
+import { createMegathreadRoundBatchHandler, createMegathreadRoundHandler, } from '../../../shared/agent/handler.js';
 const STATS_POLL_INTERVAL_MS = 5 * 60 * 1_000;
 export function useAgent() {
     const [connected, setConnected] = useState(false);

package/dist/commands/start/services/backtest/runner.js

@@ -1,5 +1,5 @@
 import { processMegathreadRound } from '../../../../shared/agent/analysis.js';
-import { initializeAgentRuntime } from '../../../../shared/agent/agent-runtime.js';
+import { initializeAgentRuntime } from '../../../../shared/agent/runtime.js';
 /**
  * Run a backtest against an agent configuration.
  */

package/dist/commands/start-all/commands/index.js

@@ -1,3 +1,4 @@
+import { Command } from 'commander';
 import React from 'react';
 import { render } from 'ink';
 import { showWelcome } from '../../shared/welcome.js';
@@ -5,20 +6,24 @@ import { styled, symbols } from '../../shared/theme.js';
 import { AgentProcessManager } from '../AgentProcessManager.js';
 import { Dashboard } from '../ui/Dashboard.js';
 import { fetchBulkStats, scanAgents, sortAgentsByHoney } from '../../../shared/config/agent.js';
-export async function startAllCommand() {
-    // Run welcome animation and scan agents in parallel
-    const results = await Promise.all([showWelcome(), scanAgents()]);
-    const discovered = results[1];
-    if (discovered.length === 0) {
-        console.log(`\n  ${styled.honey(symbols.hive)} ${styled.red('No agents found in ~/.zhive/agents/')}\n`);
-        console.log(`  ${styled.gray('Create agents with:')} ${styled.white('npx @zhive/cli@latest create')}\n`);
-        return;
-    }
-    const names = discovered.map((a) => a.name);
-    const statsMap = await fetchBulkStats(names);
-    const sortedDiscovered = sortAgentsByHoney(discovered, statsMap);
-    const manager = new AgentProcessManager();
-    manager.spawnAll(sortedDiscovered);
-    const { waitUntilExit } = render(React.createElement(Dashboard, { manager, statsMap }));
-    await waitUntilExit();
-}
+export const createStartAllCommand = () => {
+    return new Command('start-all')
+        .description('Start all agents')
+        .action(async () => {
+        // Run welcome animation and scan agents in parallel
+        const results = await Promise.all([showWelcome(), scanAgents()]);
+        const discovered = results[1];
+        if (discovered.length === 0) {
+            console.log(`\n  ${styled.honey(symbols.hive)} ${styled.red('No agents found in ~/.zhive/agents/')}\n`);
+            console.log(`  ${styled.gray('Create agents with:')} ${styled.white('npx @zhive/cli@latest create')}\n`);
+            return;
+        }
+        const names = discovered.map((a) => a.name);
+        const statsMap = await fetchBulkStats(names);
+        const sortedDiscovered = sortAgentsByHoney(discovered, statsMap);
+        const manager = new AgentProcessManager();
+        manager.spawnAll(sortedDiscovered);
+        const { waitUntilExit } = render(React.createElement(Dashboard, { manager, statsMap }));
+        await waitUntilExit();
+    });
+};

package/dist/index.js

@@ -1,60 +1,29 @@
 #!/usr/bin/env node
+import { Command } from 'commander';
 import { createRequire } from 'module';
-import { createCommand } from './commands/create/commands/index.js';
-import { listCommand } from './commands/list/commands/index.js';
-import { migrateTemplateCommand } from './commands/migrate-templates/commands/index.js';
-import { runCommand } from './commands/run/commands/index.js';
-import { startAllCommand } from './commands/start-all/commands/index.js';
-import { startCommand } from './commands/start/commands/index.js';
+import { createAgentCommand } from './commands/agent/commands/index.js';
+import { createCreateCommand } from './commands/create/commands/index.js';
+import { createListCommand } from './commands/list/commands/index.js';
+import { createMegathreadCommand } from './commands/megathread/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 pkg = require('../package.json');
-const HELP_TEXT = `@zhive/cli v${pkg.version}
-
-Usage:
-  npx @zhive/cli@latest create [agent-name]   Scaffold a new zHive agent
-  npx @zhive/cli@latest list                  List existing agents
-  npx @zhive/cli@latest start                 Start an agent (auto-detects agent dir)
-  npx @zhive/cli@latest start-all             Start all agents
-  npx @zhive/cli@latest run                   Run agent headless (no TUI, used by start-all)
-  npx @zhive/cli@latest migrate-templates     Migrate old-style agents
-  npx @zhive/cli@latest --help                Show this help message
-  npx @zhive/cli@latest --version             Print version
-
-Examples:
-  npx @zhive/cli@latest create alpha   Creates ~/.zhive/agents/alpha/
-  npx @zhive/cli@latest create         Interactive setup
-  npx @zhive/cli@latest list           Show all agents
-  npx @zhive/cli@latest start          Pick an agent and run it
-  npx @zhive/cli@latest start-all      Launch all agents as child processes`;
-const command = process.argv[2];
-if (command === '--version' || command === '-v') {
-    console.log(pkg.version);
-    process.exit(0);
-}
-if (!command || command === '--help' || command === '-h') {
-    console.log(HELP_TEXT);
-    process.exit(0);
-}
-if (command === 'list') {
-    await listCommand();
-}
-else if (command === 'start-all') {
-    await startAllCommand();
-}
-else if (command === 'create') {
-    await createCommand(process.argv);
-}
-else if (command === 'migrate-templates') {
-    await migrateTemplateCommand();
-}
-else if (command === 'run') {
-    await runCommand();
-}
-else if (command === 'start') {
-    await startCommand();
-}
-else {
-    console.error(`Unknown command: ${command}\n`);
-    console.log(HELP_TEXT);
-    process.exit(1);
-}
+const packageJson = require('../package.json');
+const program = new Command();
+program.name('@zhive/cli').version(packageJson.version);
+program.addCommand(createAgentCommand());
+program.addCommand(createCreateCommand());
+program.addCommand(createListCommand());
+program.addCommand(createMegathreadCommand());
+program.addCommand(createStartCommand());
+program.addCommand(createStartAllCommand());
+program.addCommand(createRunCommand());
+program.addCommand(createMigrateTemplatesCommand());
+// Show help with exit code 0 when no arguments provided
+const args = process.argv.slice(2);
+if (args.length === 0) {
+    program.help();
+}
+program.parse(process.argv);

package/dist/shared/agent/handler.js

@@ -0,0 +1,129 @@
+import { processMegathreadRound, screenMegathreadRound, } from './analysis.js';
+import { getMarketClient } from './tools/market/index.js';
+import { extractErrorMessage } from './utils.js';
+export const fetchPrice = async (projectId, timestamp) => {
+    const client = getMarketClient();
+    const response = await client.getPrice(projectId, timestamp);
+    return response.price ?? undefined;
+};
+export async function fetchRoundPrices(projectId, roundTimestamp, currentTime) {
+    let priceAtStart;
+    let currentPrice;
+    try {
+        const client = getMarketClient();
+        [priceAtStart, currentPrice] = await Promise.all([
+            fetchPrice(projectId, roundTimestamp),
+            fetchPrice(projectId, currentTime ?? new Date().toISOString()),
+        ]);
+    }
+    catch {
+        // Price fetch failed — both stay undefined
+    }
+    return {
+        priceAtStart,
+        currentPrice,
+    };
+}
+const calculateTimeframe = (round) => {
+    const hours = Math.round(round.durationMs / 3_600_000);
+    const timeframe = hours >= 1 ? `${hours}h` : `${Math.round(round.durationMs / 60_000)}m`;
+    return timeframe;
+};
+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 { priceAtStart, currentPrice } = await fetchRoundPrices(round.projectId, roundStartTimestamp);
+    if (priceAtStart !== undefined) {
+        reporter.onPriceInfo(priceAtStart, currentPrice);
+    }
+    // ── Quick screen (cheap engage check) ───────
+    const screenResult = await screenMegathreadRound(round.projectId, runtime.config.strategyContent);
+    if (!screenResult.engage) {
+        reporter.onScreenResult?.(round, screenResult);
+        return { skip: true, usage: screenResult.usage, screenResult };
+    }
+    reporter.onResearching(round.projectId);
+    // ── Run analysis ──────────────────────────────
+    const result = await processMegathreadRound({
+        projectId: round.projectId,
+        durationMs: round.durationMs,
+        recentComments,
+        agentRuntime: runtime,
+        priceAtStart,
+        currentPrice,
+    });
+    reporter.onToolsUsed(result.usage.toolNames, result.usage.toolCalls);
+    if (result.skip) {
+        reporter.onSkipped(round, result.usage);
+    }
+    return result;
+}
+export function createMegathreadRoundBatchHandler(getAgent, runtime, reporter) {
+    const handler = async (rounds) => {
+        const agent = getAgent();
+        const promises = [];
+        // report item in order that it is polled to prevent out-of-order write to stdout
+        for (const round of rounds) {
+            promises.push(run({ round, runtime, reporter, recentComments: agent.recentComments }));
+        }
+        const results = await Promise.allSettled(promises);
+        for (let i = 0; i < results.length; i++) {
+            const round = rounds[i];
+            const result = results[i];
+            if (result.status === 'rejected') {
+                const raw = extractErrorMessage(result.reason);
+                const message = raw.length > 120 ? raw.slice(0, 120) + '\u2026' : raw;
+                reporter.onError(round, message);
+                continue;
+            }
+            const data = result.value;
+            if (data.skip) {
+                continue;
+            }
+            // TODO: we can optimized this by create method to commit this in batch in hive sdk.
+            // postMegathreadComment cannot be run concurrently so we need to call it one by one.
+            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);
+        }
+    };
+    return handler;
+}
+export function createMegathreadRoundHandler(getAgent, runtime, reporter) {
+    const handler = async (round) => {
+        const agent = getAgent();
+        try {
+            const result = await run({
+                round,
+                reporter,
+                recentComments: agent.recentComments,
+                runtime,
+            });
+            if (result.skip) {
+                return;
+            }
+            // ── Post comment ──────────────────────────────
+            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);
+        }
+        catch (err) {
+            const raw = extractErrorMessage(err);
+            const message = raw.length > 120 ? raw.slice(0, 120) + '\u2026' : raw;
+            reporter.onError(round, message);
+        }
+    };
+    return handler;
+}