@zhive/cli 0.5.4 → 0.6.0

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/{agent → services/agent}/analysis.js

@@ -1,10 +1,10 @@
 import { generateText, Output, ToolLoopAgent } from 'ai';
 import { z } from 'zod';
-import { buildAnalystPrompt, buildMegathreadPrompt } from './prompt.js';
-import { loadMemory, saveMemory, getMemoryLineCount, MEMORY_SOFT_LIMIT } from '@hive-org/sdk';
-import { buildMemoryExtractionPrompt } from './memory-prompt.js';
+import { buildAnalystPrompt, buildMegathreadPrompt } from './prompts/prompt.js';
+import { loadMemory, saveMemory, getMemoryLineCount, MEMORY_SOFT_LIMIT, } from '@hive-org/sdk';
+import { buildMemoryExtractionPrompt } from './prompts/memory-prompt.js';
 import { stripCodeFences } from './helpers.js';
-import { getModel } from './model.js';
+import { getModel } from './helpers/model.js';
 // ─── Cache Helpers ─────────────────────────────────
 function cacheableSystem(content) {
     const message = {
@@ -146,7 +146,7 @@ export async function extractAndSaveMemory(sessionMessages) {
         const model = await getModel();
         const { text } = await generateText({
             model,
-            messages: [cacheableSystem(prompt.system), { role: 'user', content: prompt.prompt }],
+            prompt,
         });
         const cleaned = stripCodeFences(text);
         await saveMemory(cleaned);

package/dist/{load-agent-env.js → services/agent/env.js}

@@ -1,5 +1,5 @@
 import { readFileSync } from 'fs';
-import { AI_PROVIDER_ENV_VARS } from './ai-providers.js';
+import { AI_PROVIDER_ENV_VARS } from '../ai-providers.js';
 let _agentProviderKeys = new Set();
 /**
  * Provider env-var names declared in the agent's .env file.

package/dist/{agent → services/agent/helpers}/model.js

@@ -1,5 +1,5 @@
-import { AI_PROVIDERS } from '../ai-providers.js';
-import { getAgentProviderKeys } from '../load-agent-env.js';
+import { AI_PROVIDERS } from '../../ai-providers.js';
+import { getAgentProviderKeys } from '../env.js';
 const PROVIDERS = [
     {
         label: 'Anthropic',

package/dist/{agent → services/agent/prompts}/memory-prompt.js

@@ -1,9 +1,25 @@
 export function buildMemoryExtractionPrompt(context) {
     const { currentMemory, sessionMessages, lineCount } = context;
-    // ── System (static — cached by providers) ──
-    const system = `You are an AI trading agent's memory system. Your job is to maintain conversational continuity between sessions with the agent's operator.
+    let sessionSection = '';
+    if (sessionMessages.length > 0) {
+        const listed = sessionMessages
+            .map((m) => `${m.role === 'user' ? 'Operator' : 'Agent'}: ${m.content}`)
+            .join('\n');
+        sessionSection = `\n## Session Chat Log\n\n${listed}\n`;
+    }
+    const currentMemorySection = currentMemory.trim().length > 0
+        ? `\n## Current MEMORY.md\n\n\`\`\`markdown\n${currentMemory}\n\`\`\`\n`
+        : '\n## Current MEMORY.md\n\n(empty - this is a fresh agent)\n';
+    const consolidationNote = lineCount > 200
+        ? `\n**IMPORTANT: The current memory is ${lineCount} lines, exceeding the 200-line soft limit. Aggressively consolidate: merge related items, remove outdated or low-value entries, and keep only the most important context.**\n`
+        : '';
+    const prompt = `You are an AI trading agent's memory system. Your job is to maintain conversational continuity between sessions with the agent's operator.
+${currentMemorySection}${consolidationNote}
+## Session Activity
+${sessionSection}
+## Instructions
 
-Review the session data and update the agent's MEMORY.md file. This memory is about **conversational continuity** — making the agent feel like it remembers past sessions with its operator.
+Review the session chat log above and update the agent's MEMORY.md file. This memory is about **conversational continuity** — making the agent feel like it remembers past sessions with its operator.
 
 Focus on extracting:
 1. **Topics discussed** — what subjects came up in conversation (e.g., "we talked about ETH gas fees", "operator asked about macro outlook")
@@ -25,23 +41,5 @@ Follow these rules:
 6. **Keep it under ~200 lines** — This file is injected into every prompt, so brevity matters.
 
 Output the complete updated MEMORY.md content. Start with \`# Memory\` as the top-level header. Output ONLY the markdown content, no code fences or explanation.`;
-    // ── Prompt (dynamic — changes every call) ──
-    let sessionSection = '';
-    if (sessionMessages.length > 0) {
-        const listed = sessionMessages
-            .map((m) => `${m.role === 'user' ? 'Operator' : 'Agent'}: ${m.content}`)
-            .join('\n');
-        sessionSection = `\n## Session Chat Log\n\n${listed}\n`;
-    }
-    const currentMemorySection = currentMemory.trim().length > 0
-        ? `\n## Current MEMORY.md\n\n\`\`\`markdown\n${currentMemory}\n\`\`\`\n`
-        : '\n## Current MEMORY.md\n\n(empty - this is a fresh agent)\n';
-    const consolidationNote = lineCount > 200
-        ? `\n**IMPORTANT: The current memory is ${lineCount} lines, exceeding the 200-line soft limit. Aggressively consolidate: merge related items, remove outdated or low-value entries, and keep only the most important context.**\n`
-        : '';
-    const prompt = `${currentMemorySection}${consolidationNote}
-## Session Activity
-${sessionSection}
-Update the MEMORY.md based on the session activity above.`;
-    return { system, prompt };
+    return prompt;
 }