@zhive/cli 0.6.1 → 0.6.2

package/dist/CLAUDE.md

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

package/dist/backtest/CLAUDE.md

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

package/dist/cli.js

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

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

@@ -1,40 +1,17 @@
 import { Command } from 'commander';
 import { z } from 'zod';
-import { HiveClient } from '@zhive/sdk';
+import { HiveClient, TIMEFRAME_DURATION_MS } 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();
@@ -73,6 +47,7 @@ export function createMegathreadCreateCommentCommand() {
             process.exit(1);
         }
         const client = new HiveClient(HIVE_API_URL, credentials.apiKey);
+        const duration = TIMEFRAME_DURATION_MS[timeframe];
         const payload = {
             text,
             conviction,

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

@@ -83,11 +83,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 +102,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 +121,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,8 +142,8 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Test comment',
                 '--token',
                 'bitcoin',
-                '--duration',
-                '3600000',
+                '--timeframe',
+                '1h',
             ], { from: 'user' });
             expect(mockPostMegathreadComment).toHaveBeenCalledWith('round-123', {
                 text: 'Test comment',
@@ -167,8 +167,8 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Test comment',
                 '--token',
                 'bitcoin',
-                '--duration',
-                '3600000',
+                '--timeframe',
+                '1h',
             ], { from: 'user' });
             expect(mockPostMegathreadComment).toHaveBeenCalledWith('round-123', {
                 text: 'Test comment',
@@ -192,8 +192,8 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Test comment',
                 '--token',
                 'bitcoin',
-                '--duration',
-                '3600000',
+                '--timeframe',
+                '1h',
             ], { from: 'user' });
             expect(mockPostMegathreadComment).toHaveBeenCalledWith('round-123', {
                 text: 'Test comment',
@@ -203,8 +203,8 @@ describe('createMegathreadCreateCommentCommand', () => {
             });
         });
     });
-    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 +217,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 +236,21 @@ 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,
+                tokenId: 'bitcoin',
+                roundDuration: 3600000,
+            });
         });
-        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 +261,40 @@ 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,
+                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,
+            });
         });
     });
     describe('agent validation', () => {
@@ -276,8 +311,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 +336,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 +355,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,8 +377,8 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Bullish on Bitcoin!',
                 '--token',
                 'bitcoin',
-                '--duration',
-                '3600000',
+                '--timeframe',
+                '1h',
             ], { from: 'user' });
             expect(mockPostMegathreadComment).toHaveBeenCalledWith('round-123', {
                 text: 'Bullish on Bitcoin!',
@@ -373,8 +408,8 @@ describe('createMegathreadCreateCommentCommand', () => {
                 'Bearish outlook',
                 '--token',
                 'ethereum',
-                '--duration',
-                '14400000',
+                '--timeframe',
+                '4h',
             ], { from: 'user' });
             const output = consoleOutput.join('\n');
             expect(output).toContain('-30.0%');
@@ -395,8 +430,8 @@ describe('createMegathreadCreateCommentCommand', () => {
                 longText,
                 '--token',
                 'bitcoin',
-                '--duration',
-                '3600000',
+                '--timeframe',
+                '1h',
             ], { from: 'user' });
             // Verify full text was sent to API
             expect(mockPostMegathreadComment).toHaveBeenCalledWith('round-123', {
@@ -426,8 +461,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 +482,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 +505,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,7 @@ function createMockActiveRound(overrides = {}) {
         roundId: 'round-123',
         projectId: 'bitcoin',
         durationMs: 3600000,
+        priceAtStart: null,
         ...overrides,
     };
 }
@@ -78,13 +79,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/{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;
 }