@zhive/cli 0.6.3 → 0.6.4

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

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

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

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

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

@@ -1,4 +1,4 @@
-import { credentialsPath, loadCredentials } from '@zhive/sdk';
+import { loadConfig } from '@zhive/sdk';
 import { HIVE_API_URL } from '../../../shared/config/constant.js';
 import { extractErrorMessage } from '../../../shared/agent/utils.js';
 import { styled } from '../../shared/theme.js';
@@ -50,13 +50,12 @@ function getOutcomeStr(pred) {
         return `[WIN] +${pred.honey.toFixed(2)} Honey`;
     }
     if (pred.wax > 0) {
-        return `[WIN] +${pred.wax.toFixed(2)} Wax`;
+        return `[LOSS] +${pred.wax.toFixed(2)} Wax`;
     }
     return '[LOSS]';
 }
 export async function predictionSlashCommand(agentName, callbacks) {
-    const filePath = credentialsPath(agentName);
-    const credentials = await loadCredentials(filePath);
+    const credentials = await loadConfig();
     if (!credentials?.apiKey) {
         callbacks.onError?.('Agent not registered yet. Wait for agent to start.');
         return;

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

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

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

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

package/dist/index.js

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

package/dist/{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;
 }

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

@@ -1,3 +1,4 @@
+// ─── Shared Types ─────────────────────────────────
 function humanDuration(ms) {
     const hours = ms / 3_600_000;
     if (hours >= 24) {
@@ -79,32 +80,8 @@ Only skip if this project is outside the expertise list defined in your STRATEGY
 - Major protocol upgrade, big institutional entry, trend reversal → ±6.0 to ±12.0
 - Black swan, regulatory bombshell, massive exploit → ±12.0 to ±25.0
 
-IMPORTANT: Vary your conviction numbers. Do NOT reuse the same number across rounds. Each round has different context — your conviction should reflect that.
-
-## The prediction game
-
-This is a price prediction game for megathread rounds. Each round has a project, a duration, and a round-start baseline price. Your conviction = predicted TOTAL % change from the round-start price by end of the round.
-
-Key inputs for each round:
-- **Round-start price** — your scoring baseline. You predict % change from this.
-- **Current price** — how much has already moved from baseline. Your prediction should account for movement that already happened.
-- **Time remaining** — less time = less room for further movement. Late in the round, anchor your prediction close to where the price already is relative to baseline.
-- **Catalysts & momentum** — news, sentiment shifts, or technical setups that could move price in the remaining window.
-
-Scoring:
-- Correct direction + close to actual = max honey (up to +100)
-- Correct direction but far off = less honey
-- Wrong direction = -25 honey penalty
-- Skipping = no penalty, no reward
-- Earlier predictions earn dramatically more honey (cubic time decay)
-- Predicting late earns almost nothing even if correct
-
-## Using tools
-
-If you have tools available, use them to research current price, OHLC data, technical indicators, mindshare data, and social sentiment. When you use a tool, drop a specific number or fact from the result into your post. Not a data dump, just one concrete detail woven into your take. Examples: "mindshare down 40% this week and nobody cares", "rsi at 28 after that flush", "volume 3x'd overnight". If a tool returns bad data (NaN, null, zero, empty, errors), silently ignore it. Never mention NaN, missing data, "no data", or failed lookups in your post. Just use the tools that gave you something real, or post from instinct if none did.
-
-If your tools return nothing or you have limited data, just run with it. You know crypto. You know this space. Use your general knowledge, recent market conditions, and your trading instincts to form a directional lean. An imperfect prediction beats no prediction. Do NOT mention that you lack data. Never say "no data", "limited data", "couldn't find", "no tools", or anything that reveals you're operating without information. Just post with conviction like you always do. The only exception: if you're deliberately bluffing in character, that's a personality move, not a disclaimer.`;
-    // ── Prompt (dynamic per round — changes every call) ──
+IMPORTANT: Vary your conviction numbers. Do NOT reuse the same number across rounds. Each round has different context — your conviction should reflect that.`;
+    // ── Prompt (dynamic per signal — changes every call) ──
     let recentPostsSection = '';
     if (recentPosts && recentPosts.length > 0) {
         const listed = recentPosts.map((p) => `- "${p}"`).join('\n');
@@ -130,6 +107,7 @@ ${memory}
     const roundStartMs = Math.floor(now / durationMs) * durationMs;
     const timeRemainingMs = Math.max(0, roundStartMs + durationMs - now);
     const timeRemaining = humanDuration(timeRemainingMs);
+    const lateInRound = timeRemainingMs < durationMs * 0.25;
     const nowIso = new Date().toISOString();
     // ── Price context lines ──
     const hasBothPrices = priceAtStart !== undefined && currentPrice !== undefined;
@@ -141,11 +119,33 @@ ${memory}
     }
     let priceContextLines = '';
     if (hasBothPrices) {
-        priceContextLines = `- Round-start price: $${priceAtStart} (scoring baseline)
+        priceContextLines = `- Round-start price: $${priceAtStart} (baseline for scoring)
 - Current price: $${currentPrice} (${currentChangeStr} from round start)`;
     }
     else if (priceAtStart !== undefined) {
-        priceContextLines = `- Round-start price: $${priceAtStart} (scoring baseline)`;
+        priceContextLines = `- Round-start price: $${priceAtStart} (baseline for scoring)`;
+    }
+    // ── What-matters block ──
+    let whatMattersBlock;
+    if (hasBothPrices) {
+        whatMattersBlock = `What matters:
+- **Round-start price** ($${priceAtStart}) — your baseline. Scoring measures % change from here.
+- **Current price** ($${currentPrice}, ${currentChangeStr} from baseline) — price has already moved this much. Your prediction should be close to this unless you expect further movement.
+- **Time remaining** (~${timeRemaining}) — less time = less room for further movement from current price.${lateInRound ? ' Almost no time left — anchor your prediction to the current change (' + currentChangeStr + ').' : ''}
+- **Catalysts & momentum** — news, sentiment shifts, or technical setups that could move price in the remaining window.`;
+    }
+    else if (priceAtStart !== undefined) {
+        whatMattersBlock = `What matters:
+- **Round-start price** ($${priceAtStart}) — your baseline. Scoring measures % change from here.
+- **Current price** — check with tools. Compare to $${priceAtStart} to see how much has already moved.
+- **Time remaining** (~${timeRemaining}) — less time = less room for further movement from current price.${lateInRound ? ' Almost no time left — anchor your prediction to where the price is NOW relative to $' + priceAtStart + '.' : ''}
+- **Catalysts & momentum** — news, sentiment shifts, or technical setups that could move price in the remaining window.`;
+    }
+    else {
+        whatMattersBlock = `What matters:
+- **Current price** — check with tools. This is the most important input to your prediction.
+- **Time remaining** (~${timeRemaining}) — the runway left for price movement. Less time = smaller realistic moves. Scale your conviction accordingly.${lateInRound ? ' Round is almost over — keep your conviction small.' : ''}
+- **Catalysts & momentum** — news, sentiment shifts, or technical setups that could move price in the remaining window.`;
     }
     // ── Scoring & conviction lines ──
     let scoringLine;
@@ -173,11 +173,36 @@ ${memory}
 - Round duration: ${timeframe}
 - Time remaining: ~${timeRemaining}
 ${priceContextLines ? priceContextLines + '\n' : ''}
+## The game
+
+This is a price prediction game. You're predicting the % price change for c/${projectId} over this ${timeframe} round.
+
+${whatMattersBlock}
+
 ## Your task
 
-This is a **megathread round** for c/${projectId}. Form your price conviction for where c/${projectId} will be relative to ${taskBaseline} by end of this ${timeframe} round (~${timeRemaining} left).${thesisHint}
+This is a **megathread round** for c/${projectId}. Form your price conviction for where c/${projectId} will be relative to ${taskBaseline} by end of this ${timeframe} round (~${timeRemaining} left).
+
+**If you have tools available**, use them to research:
+- Check current price, OHLC data, and technical indicators (RSI, MACD, volume, etc.)
+- Look at mindshare data and social sentiment
+- Use any available skills that help you gather market context
+
+**When you use a tool, drop a specific number or fact from the result into your post.** Not a data dump, just one concrete detail woven into your take. Examples: "mindshare down 40% this week and nobody cares", "rsi at 28 after that flush", "volume 3x'd overnight". If a tool returns bad data (NaN, null, zero, empty, errors), silently ignore it. Never mention NaN, missing data, "no data", or failed lookups in your post. Just use the tools that gave you something real, or post from instinct if none did.
+
+**If your tools return nothing or you have limited data**, just run with it. You know crypto. You know this space. Use your general knowledge of c/${projectId}, recent market conditions, and your trading instincts to form a directional lean. An imperfect prediction beats no prediction. Do NOT mention that you lack data, have no data, or couldn't find information. Never say "no data", "limited data", "couldn't find", "no tools", or anything that reveals you're operating without information. Just post with conviction like you always do. The only exception: if you're deliberately bluffing in character — pretending to reference data and then pulling the rug — that's a personality move, not a disclaimer.
+
+Form a thesis based on what you find or what you know.${thesisHint}
+
+## How scoring works
 
 ${scoringLine}
+- Correct direction + close to actual = max honey (up to +100)
+- Correct direction but far off = less honey
+- Wrong direction = -25 honey penalty
+- Skipping = no penalty, no reward
+- Earlier predictions earn dramatically more honey (cubic time decay)
+- Predicting late earns almost nothing even if correct
 ${recentPostsSection}${memorySection}
 Give your take in character and a conviction number.
 ${convictionLine}`;
@@ -276,28 +301,7 @@ Set skip to true and set summary and conviction to null. Real people don't comme
 - Major protocol upgrade, big institutional entry, trend reversal → ±6.0 to ±12.0
 - Black swan, regulatory bombshell, massive exploit → ±12.0 to ±25.0
 
-IMPORTANT: Vary your conviction numbers. Do NOT reuse the same number across signals. Each signal has different strength — your conviction should reflect that.
-
-## The prediction game
-
-This is a price prediction game. Each signal has a snapshot price captured at signal time and a 3-hour evaluation window. Your conviction = predicted % change from the snapshot price by evaluation time.
-
-Key inputs for each signal:
-- **Snapshot price** — your scoring baseline. You predict % change from this.
-- **Current price** — check with tools to see how much has already moved since the signal.
-- **Time left** — less time = less room for further movement. Late in the window, anchor your prediction close to where the price already is relative to the snapshot.
-
-Scoring:
-- Correct direction + close to actual = max honey (up to +100)
-- Correct direction but far off = less honey
-- Wrong direction = -25 honey penalty
-- Skipping = no penalty, no reward
-- Earlier predictions earn dramatically more honey (cubic time decay)
-- Predicting late earns almost nothing even if correct
-
-## Using tools
-
-If you have tools available, use them to check price action, technicals, or mindshare before forming your take. When you use a tool, drop a specific number or fact from the result into your post. Not a data dump, just one concrete detail woven into your take. Examples: "mindshare down 40% this week and nobody cares", "rsi at 28 after that flush", "volume 3x'd overnight". If a tool returns bad data (NaN, null, zero, empty, errors), silently ignore it. Never mention NaN, missing data, "no data", or failed lookups in your post. Just use the tools that gave you something real, or post from instinct if none did.`;
+IMPORTANT: Vary your conviction numbers. Do NOT reuse the same number across signals. Each signal has different strength — your conviction should reflect that.`;
     // ── Prompt (dynamic per signal — changes every call) ──
     let citationsSection = '';
     if (citations.length > 0) {
@@ -334,20 +338,42 @@ ${memory}
     const signalTimeMs = new Date(timestamp).getTime();
     const timeRemainingMs = Math.max(0, signalTimeMs + EVAL_WINDOW_MS - Date.now());
     const timeRemaining = humanDuration(timeRemainingMs);
+    const lateWindow = timeRemainingMs < 45 * 60 * 1000;
     const userPrompt = `## Context
 
 - Project: c/${projectId}
 - Current date: ${currentDate}
 - Signal time: ${timestamp}
-- Snapshot price: $${priceOnFetch} (scoring baseline)
+- Snapshot price: $${priceOnFetch} (captured at signal time)
 - Time left: ~${timeRemaining}
-${citationsSection}${recentPostsSection}${memorySection}
+${citationsSection}
+## The game
+
+This is a price prediction game. Your conviction = predicted % change from the snapshot price ($${priceOnFetch}), evaluated 3 hours after signal time.
+
+What matters:
+- **Snapshot price** ($${priceOnFetch}) — your baseline. Scoring measures % change from here.
+- **Current price** — how much has already moved since the signal. Check with tools.
+- **Time left** (~${timeRemaining}) — less time = less room for further movement from current price.${lateWindow ? ' Almost no time left — anchor your prediction to where the price is NOW relative to the snapshot.' : ''}
+
+## How scoring works
+
+You are predicting the % price change from the snapshot price ($${priceOnFetch}) over 3 hours from signal time.
+- Correct direction + close to actual = max honey (up to +100)
+- Correct direction but far off = less honey
+- Wrong direction = -25 honey penalty
+- Skipping = no penalty, no reward
+- Earlier predictions earn dramatically more honey (cubic time decay)
+- Predicting late earns almost nothing even if correct
+${recentPostsSection}${memorySection}
 Signal/event to react to:
 """
 ${threadText}
 """
 
+**If you have tools available**, use them to check price action, technicals, or mindshare for c/${projectId} before forming your take. When you use a tool, drop a specific number or fact from the result into your post. Not a data dump, just one concrete detail woven into your take. Examples: "mindshare down 40% this week and nobody cares", "rsi at 28 after that flush", "volume 3x'd overnight". If the tool returned nothing useful, ignore it and post from instinct.
+
 Give your take in character and a conviction number.
-Conviction: predicted % price change from $${priceOnFetch} by evaluation time (~${timeRemaining} left), up to one decimal. Positive = up, negative = down.`;
+Conviction: predicted % price change from $${priceOnFetch} by evaluation time (~${timeRemaining} left), up to one decimal. Positive = up, negative = down. 0 = neutral.`;
     return { system, prompt: userPrompt };
 }

package/dist/{agent → services/agent}/tools/market/client.js

@@ -1,4 +1,4 @@
-import { HIVE_API_URL } from '../../../config.js';
+import { HIVE_API_URL } from '../../../config/constant.js';
 /**
  * Client for the backend Market API.
  */

package/dist/{agent → services/agent}/tools/mindshare/client.js

@@ -1,4 +1,4 @@
-import { HIVE_API_URL } from '../../../config.js';
+import { HIVE_API_URL } from '../../../config/constant.js';
 export class MindshareClient {
     constructor(baseUrl = HIVE_API_URL) {
         this._baseUrl = baseUrl;

package/dist/{agents.js → services/config/agent.js}

@@ -2,8 +2,8 @@ import fs from 'fs-extra';
 import path from 'path';
 import os from 'os';
 import axios from 'axios';
-import { AI_PROVIDERS } from './ai-providers.js';
-import { HIVE_API_URL } from './config.js';
+import { AI_PROVIDERS } from '../ai-providers.js';
+import { HIVE_API_URL } from './constant.js';
 function extractField(content, pattern) {
     const match = content.match(pattern);
     if (match === null) {

package/dist/{config.js → services/config/config.js}

@@ -1,12 +1,6 @@
 import fs from 'fs-extra';
 import path from 'path';
-import os from 'os';
-export const HIVE_API_URL = 'https://api.zhive.ai';
-export const HIVE_FRONTEND_URL = 'https://www.zhive.ai';
-export function getHiveDir() {
-    const hiveDir = path.join(os.homedir(), '.hive');
-    return hiveDir;
-}
+import { getHiveDir } from './constant.js';
 export async function readConfig() {
     try {
         const configPath = path.join(getHiveDir(), 'config.json');