@zhive/cli 0.5.0

package/dist/shared/agent/agent-runtime.js

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

package/dist/shared/agent/analysis.js

@@ -0,0 +1,171 @@
+import { getMemoryLineCount, loadMemory, MEMORY_SOFT_LIMIT, saveMemory, } from '@zhive/sdk';
+import * as ai from 'ai';
+import { z } from 'zod';
+import { getModel } from '../config/ai-providers.js';
+import { buildMemoryExtractionPrompt } from './prompts/memory-prompt.js';
+import { extractErrorMessage, stripCodeFences } from './utils.js';
+import { wrapAISDK } from 'langsmith/experimental/vercel';
+import { buildScreenPrompt } from './prompts/prompt.js';
+import { buildMegathreadInputPrompt, buildMegathreadSystemPrompt, } from './prompts/megathread.js';
+import { clearSubagentUsage, getSubagentUsage, } from './tools/index.js';
+const { ToolLoopAgent, generateText, Output } = wrapAISDK(ai);
+// ─── Cache Helpers ─────────────────────────────────
+function cacheableSystem(content) {
+    const message = {
+        role: 'system',
+        content,
+        providerOptions: {
+            anthropic: { cacheControl: { type: 'ephemeral' } },
+        },
+    };
+    return message;
+}
+// ─── Screen Schema (Quick Engage Check) ─────────────
+const screenSchema = z.object({
+    engage: z.boolean().describe('true if this round matches your expertise and is worth analyzing'),
+    reason: z.string().describe('One sentence explaining why you will or will not engage'),
+});
+// ─── Prediction Schema ──────────────────────────────
+const megathreadPredictionSchema = z.object({
+    summary: z
+        .string()
+        .min(1)
+        .max(2000)
+        .nullable()
+        .describe('Your CT-style take on this project. Short, punchy, in character. Think tweet, not essay. null if skipping.'),
+    conviction: z
+        .number()
+        .nullable()
+        .describe('Predicted percent price change over the conviction window described in your instructions, up to two decimal places. Use the FULL range based on catalyst strength: routine ±0.1-1.0, moderate ±1.5-5.0, strong ±5.0-12.0, extreme ±12.0-25.0. Negative for bearish. NEVER use 0 — always commit to a directional lean, even if small (e.g. ±0.1). null if skipping. VARY your predictions — do NOT default to the same number repeatedly.'),
+});
+function buildUsage(res) {
+    const toolCalls = res.steps.flatMap((s) => s.toolCalls);
+    const toolNames = toolCalls.map((tc) => tc.toolName);
+    const toolResults = res.steps
+        .flatMap((s) => s.toolResults)
+        .map((tr) => ({
+        toolName: tr.toolName,
+        result: String(tr.output),
+    }));
+    const usage = {
+        inputTokens: res.totalUsage.inputTokens ?? 0,
+        outputTokens: res.totalUsage.outputTokens ?? 0,
+        cacheReadTokens: res.totalUsage.inputTokenDetails?.cacheReadTokens ?? 0,
+        cacheWriteTokens: res.totalUsage.inputTokenDetails?.cacheWriteTokens ?? 0,
+        toolCalls: toolCalls.length,
+        toolNames,
+        toolResults,
+    };
+    return usage;
+}
+// ─── Quick Screen (Cheap Engage Check) ──────────────
+export async function screenMegathreadRound(projectId, strategyContent) {
+    try {
+        const { system, prompt } = buildScreenPrompt(strategyContent, {
+            projectId,
+        });
+        const model = await getModel();
+        const res = await generateText({
+            model,
+            messages: [cacheableSystem(system), { role: 'user', content: prompt }],
+            experimental_output: Output.object({ schema: screenSchema }),
+        });
+        const usage = {
+            inputTokens: res.usage?.inputTokens ?? 0,
+            outputTokens: res.usage?.outputTokens ?? 0,
+            cacheReadTokens: res.usage?.inputTokenDetails?.cacheReadTokens ?? 0,
+            cacheWriteTokens: res.usage?.inputTokenDetails?.cacheWriteTokens ?? 0,
+            toolCalls: 0,
+            toolNames: [],
+            toolResults: [],
+        };
+        const output = res.experimental_output;
+        if (!output) {
+            return { engage: true, reason: 'screen parse failed — defaulting to engage', usage };
+        }
+        return { engage: output.engage, reason: output.reason, usage };
+    }
+    catch (err) {
+        const emptyUsage = {
+            inputTokens: 0,
+            outputTokens: 0,
+            cacheReadTokens: 0,
+            cacheWriteTokens: 0,
+            toolCalls: 0,
+            toolNames: [],
+            toolResults: [],
+        };
+        return { engage: true, reason: 'screen error — defaulting to engage', usage: emptyUsage };
+    }
+}
+// ─── Megathread Round Analysis ──────────────────────
+export async function processMegathreadRound({ projectId, durationMs, recentComments, agentRuntime, priceAtStart, currentTime, currentPrice, }) {
+    const promptOptions = {
+        projectId,
+        durationMs,
+        priceAtStart,
+        currentPrice,
+        recentPosts: recentComments,
+        currentTime: currentTime ?? new Date(),
+    };
+    const systemPrompt = buildMegathreadSystemPrompt(agentRuntime);
+    const prompt = buildMegathreadInputPrompt(agentRuntime, promptOptions);
+    // ── Clear subagent usage tracking ──
+    clearSubagentUsage();
+    const agent = new ToolLoopAgent({
+        model: agentRuntime.model,
+        instructions: cacheableSystem(systemPrompt),
+        output: Output.object({ schema: megathreadPredictionSchema }),
+        tools: agentRuntime.tools,
+    });
+    const res = await agent.generate({ prompt });
+    // ── Build usage with subagent tracking ──
+    const usage = buildUsage(res);
+    const subagentUsage = getSubagentUsage();
+    if (subagentUsage.length > 0) {
+        usage.subagentUsage = subagentUsage;
+        // Aggregate subagent tokens into total
+        for (const sub of subagentUsage) {
+            usage.inputTokens += sub.inputTokens;
+            usage.outputTokens += sub.outputTokens;
+            usage.cacheReadTokens += sub.cacheReadTokens;
+            usage.cacheWriteTokens += sub.cacheWriteTokens;
+        }
+    }
+    const { output } = res;
+    if (!output) {
+        return { skip: true, summary: '', conviction: 0, usage };
+    }
+    const prediction = output;
+    const summary = prediction.summary ?? '';
+    const conviction = prediction.conviction ?? 0;
+    return { skip: false, summary, conviction, usage };
+}
+// ─── Memory Extraction ──────────────────────────────
+export async function extractAndSaveMemory(sessionMessages) {
+    const currentMemory = await loadMemory();
+    const lineCount = getMemoryLineCount(currentMemory);
+    if (sessionMessages.length === 0 && lineCount <= MEMORY_SOFT_LIMIT) {
+        return null;
+    }
+    const prompt = buildMemoryExtractionPrompt({
+        currentMemory,
+        sessionMessages,
+        lineCount,
+    });
+    try {
+        const model = await getModel();
+        const { text } = await generateText({
+            model,
+            messages: [cacheableSystem(prompt.system), { role: 'user', content: prompt.prompt }],
+        });
+        const cleaned = stripCodeFences(text);
+        await saveMemory(cleaned);
+        return cleaned;
+    }
+    catch (err) {
+        const raw = extractErrorMessage(err);
+        console.error(`[Memory] Failed to extract memory: ${raw.slice(0, 200)}`);
+        return null;
+    }
+}

package/dist/shared/agent/helpers.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/agent/prompts/chat-prompt.js

@@ -0,0 +1,60 @@
+function extractSections(content) {
+    const sections = content
+        .split('\n')
+        .filter((line) => line.trim().startsWith('## '))
+        .map((line) => line.trim().replace(/^## /, ''));
+    return sections;
+}
+export function buildChatPrompt(soulContent, strategyContent, context) {
+    // ── System (static per agent session — cached by providers) ──
+    const system = `You are an AI trading agent having a conversation with your operator. Stay in character.
+
+Your personality:
+---
+${soulContent}
+---
+
+Your trading strategy:
+---
+${strategyContent}
+---
+
+## Editing Your Files
+
+You have a tool called "editSection" that can update sections of your SOUL.md and STRATEGY.md.
+
+Rules:
+1. When the user asks to change your personality or strategy, FIRST propose the change — show them what the new section content would look like.
+2. Only call editSection AFTER the user explicitly confirms ("yes", "do it", "looks good").
+3. Never call the tool speculatively.
+4. After applying, confirm briefly in character.
+
+SOUL.md sections: ${extractSections(soulContent).join(', ')}
+STRATEGY.md sections: ${extractSections(strategyContent).join(', ')}
+
+## Game Rules
+
+You have a tool called "fetchRules" that fetches the official Hive game rules. Call it when the user asks about rules, scoring, honey, wax, streaks, or how the platform works. Summarize the rules in your own voice — don't dump the raw markdown.
+
+Respond in character. Be helpful about your decisions and reasoning when asked, but maintain your personality voice. Keep responses concise (1-4 sentences unless a detailed explanation is specifically requested). When proposing edits, you may use longer responses to show the full preview.`;
+    // ── Prompt (dynamic per chat message) ──
+    let predictionsSection = '';
+    if (context.recentPredictions.length > 0) {
+        const listed = context.recentPredictions.map((p) => `- ${p}`).join('\n');
+        predictionsSection = `\n## Recent Predictions\n\n${listed}\n`;
+    }
+    let memorySection = '';
+    if (context.memory.trim().length > 0) {
+        memorySection = `\n## Past Conversations\n\nThings you remember from previous sessions with your operator:\n${context.memory}\n`;
+    }
+    let sessionSection = '';
+    if (context.sessionMessages.length > 0) {
+        const listed = context.sessionMessages
+            .map((m) => `${m.role === 'user' ? 'User' : 'You'}: ${m.content}`)
+            .join('\n');
+        sessionSection = `\n## This Session's Conversation\n\n${listed}\n`;
+    }
+    const userPrompt = `${memorySection}${predictionsSection}${sessionSection}
+The operator says: "${context.userMessage}"`;
+    return { system, prompt: userPrompt };
+}

package/dist/shared/agent/prompts/megathread.js

@@ -0,0 +1,202 @@
+function humanDuration(ms) {
+    const hours = ms / 3_600_000;
+    if (hours >= 24) {
+        const days = Math.round(hours / 24);
+        return days === 1 ? '1 day' : `${days} days`;
+    }
+    if (hours >= 1) {
+        const rounded = Math.round(hours);
+        return rounded === 1 ? '1 hour' : `${rounded} hours`;
+    }
+    const minutes = Math.round(ms / 60_000);
+    return minutes === 1 ? '1 minute' : `${minutes} minutes`;
+}
+function formatSkillList(skillRegistry) {
+    if (skillRegistry.size === 0) {
+        return '';
+    }
+    const entries = Array.from(skillRegistry.values()).map((s) => {
+        const lines = [`***${s.id}***`, s.metadata.description];
+        if (s.metadata.compatibility) {
+            lines.push(`**Compatibility:** ${s.metadata.compatibility}`);
+        }
+        const entry = lines.join('\n');
+        return entry;
+    });
+    const output = `${entries.join('\n')}`;
+    return output;
+}
+export function buildMegathreadSystemPrompt(runtime) {
+    let skillsSection = '';
+    if (runtime.skills.size > 0) {
+        skillsSection = `
+## Skill System
+You have access to specialized skills that can perform analysis for you. Each skill runs as a subagent with its own expertise.
+
+## Available Skills
+
+${formatSkillList(runtime.skills)}
+
+**How to Use Skills:**
+
+Use the \`executeSkill\` tool to delegate a task to a specialized subagent:
+
+\`\`\`
+executeSkill({
+  skillId: "ta",              // Skill with the expertise you need
+  task: "Analyze RSI and MACD for BTC. Is momentum bullish or bearish?",
+  context: "Current price: $65,000"  // Optional extra context
+})
+\`\`\`
+
+The subagent will use its expertise to complete YOUR task. You control what the subagent does — the skill provides the knowledge, you provide the instructions.`;
+    }
+    const system = `You are an agent who will be participated in price prediction game. You will be given a context called megathread round.  Each round has a project, a duration, and a round-start baseline price. Your conviction = predicted total percent 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
+
+## How you make prediction
+
+${runtime.config.strategyContent}
+---
+
+## How you write response
+
+You ARE this person. Reference your life, relationships, and background naturally when relevant. Be self-aware of who you are.
+
+Here's who you are:
+
+${runtime.config.soulContent}
+
+Your opinions, pet peeves, and example posts in SOUL.md are your personality anchors.
+Rotate through them naturally - don't use the same opinion or quirk in consecutive posts.
+Your example posts set the quality bar and tone target. Match their energy, not their exact words.
+
+Write like an anonymous poster on 4chan, reddit, or crypto twitter. Not an analyst. Not an AI. A real person shitposting with conviction.
+
+Think about how people actually talk in these spaces:
+- They don't explain themselves. They just say it.
+- They're blunt, sarcastic, dismissive, funny, or dead serious. Sometimes all at once.
+- They use slang naturally: ngl, tbh, copium, ngmi, imo, idk, lmao, kek, based, cope, etc.
+- They mock bad takes. They clown on people. They flex when they're right.
+- They type fast and don't proofread. Lowercase, fragments, run-ons, whatever.
+- They react to vibes, not just data.
+- Sometimes the whole post is just one word. Sometimes it's a question. Sometimes it's a meme reference.
+- Sometimes they say something completely unrelated to the market data. A random life story, a personal anecdote, a non-sequitur. The conviction still comes through but the post itself doesn't explain why. Not every post needs to reference the data directly.
+
+Rules:
+- Pick ONE angle. Don't try to cover everything you found.
+- You do NOT need to explain your reasoning. Sometimes just say something in character and let the conviction number speak for itself.
+- ~20% of the time, your post can be totally unrelated to the market data. A life detail, a random thought, a flex, a non-sequitur. You still give a conviction number but the post doesn't explain it. People who know, know.
+- ~15% of the time, go ultra-short: 1-6 words. "lol." / "called it" / "nah" / "cope" / "$BTC" / "anon was right"
+- The rest: 1-3 sentences max. Shitpost energy, not essay energy.
+- Vary your format. Rotate between: raw reaction, hot take, question, mockery, dismissal, ticker-only, sarcasm, flexing a past call, random life update, non-sequitur with conviction.
+- No two consecutive posts should have the same structure or opening pattern.
+- Don't stack multiple indicators ("RSI oversold, MACD flattening, volume spiking"). Pick one if relevant, or skip indicators entirely and just give your read.
+- Show conviction through tone, not by listing evidence.
+- Never use em dashes. Use periods, commas, or just start a new sentence.
+- No exclamation marks unless your personality is genuinely hype. Even then, max one.
+- Never start with "Looking at" or "Based on"
+- Never use the phrase "the real X is Y" - find a different way to make the point.
+---
+${skillsSection}
+---
+
+## 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.`;
+    return system;
+}
+export function buildMegathreadInputPrompt(runtime, options) {
+    const { projectId, durationMs, priceAtStart, currentPrice, recentPosts } = options;
+    const timeframe = humanDuration(durationMs);
+    let recentPostsSection = '';
+    if (recentPosts && recentPosts.length > 0) {
+        const listed = recentPosts.map((p) => `- "${p}"`).join('\n');
+        recentPostsSection = `
+## Anti-repetition
+
+Your recent posts (do NOT repeat these structures, phrases, or opening patterns):
+${listed}
+
+If you catch yourself writing something that sounds like any of the above - stop and take a completely different angle.
+`;
+    }
+    let memorySection = '';
+    if (runtime.memory.trim().length > 0) {
+        memorySection = `
+## Agent Memory
+
+Your persistent learnings from past sessions:
+${runtime.memory}`;
+    }
+    const now = options?.currentTime ?? new Date();
+    const roundStartMs = Math.floor(now.getTime() / durationMs) * durationMs;
+    const timeRemainingMs = Math.max(0, roundStartMs + durationMs - now.getTime());
+    const timeRemaining = humanDuration(timeRemainingMs);
+    const nowIso = new Date().toISOString();
+    const hasBothPrices = priceAtStart !== undefined && currentPrice !== undefined;
+    let currentChangeStr = '';
+    if (hasBothPrices) {
+        const changePercent = ((currentPrice - priceAtStart) / priceAtStart) * 100;
+        const sign = changePercent >= 0 ? '+' : '';
+        currentChangeStr = `${sign}${changePercent.toFixed(2)}%`;
+    }
+    let priceContextLines = '';
+    if (hasBothPrices) {
+        priceContextLines = `- Round-start price: $${priceAtStart} (scoring baseline)
+- Current price: $${currentPrice} (${currentChangeStr} from round start)`;
+    }
+    else if (priceAtStart !== undefined) {
+        priceContextLines = `- Round-start price: $${priceAtStart} (scoring baseline)`;
+    }
+    // ── Scoring & conviction lines ──
+    let scoringLine;
+    let convictionLine;
+    if (priceAtStart !== undefined) {
+        scoringLine = `You are predicting the TOTAL % price change from the round-start price ($${priceAtStart}) by the end of this ${timeframe} round (~${timeRemaining} remaining). This is NOT the change during the remaining time — it's where the price will be relative to $${priceAtStart} when the round ends.`;
+        const example = hasBothPrices
+            ? ` The price is currently ${currentChangeStr} from baseline — if you think it stays there, predict ${currentChangeStr.replace('+', '')}.`
+            : '';
+        convictionLine = `Conviction: predicted TOTAL % price change from $${priceAtStart} by the end of this ${timeframe} round (~${timeRemaining} left), up to one decimal. Positive = up, negative = down. 0 = neutral.${example}`;
+    }
+    else {
+        scoringLine = `You are predicting the % price change for ${projectId} over this ${timeframe} round (~${timeRemaining} remaining).`;
+        convictionLine = `Conviction: predicted % price change for ${projectId} for the remainder of this ${timeframe} round (~${timeRemaining} left), up to one decimal. Positive = up, negative = down. 0 = neutral.`;
+    }
+    // ── Task description ──
+    const taskBaseline = priceAtStart !== undefined ? `$${priceAtStart}` : 'the start price';
+    const thesisHint = priceAtStart !== undefined
+        ? ` Your conviction = where you think the price will be relative to $${priceAtStart} when the round ends, NOT how much it will move in the remaining time.`
+        : ` Your conviction should reflect what's realistic in the ~${timeRemaining} remaining.`;
+    const userPrompt = `## Context
+
+- Project: ${projectId}
+- Current time: ${nowIso}
+- Round duration: ${timeframe}
+- Time remaining: ~${timeRemaining}
+${priceContextLines ? priceContextLines + '\n' : ''}
+## Your task
+
+This is a **megathread round** for ${projectId}. Form your price conviction for where ${projectId} will be relative to ${taskBaseline} by end of this ${timeframe} round (~${timeRemaining} left).${thesisHint}
+
+${scoringLine}
+${recentPostsSection}${memorySection}
+Give your take in character and a conviction number.
+${convictionLine}`;
+    return userPrompt;
+}

package/dist/shared/agent/prompts/memory-prompt.js

@@ -0,0 +1,47 @@
+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.
+
+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.
+
+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")
+2. **Operator interests and concerns** — what the operator cares about, recurring themes, questions they've raised
+3. **Ongoing conversational threads** — topics that span multiple sessions or feel unresolved
+4. **Operator preferences** — how they like to interact, what they find useful or annoying
+
+Do NOT save:
+- Market predictions, signal analysis, or trading insights — a separate results-based learning system will handle those in the future
+- Raw price data or signal summaries
+- Routine prediction outcomes
+
+Follow these rules:
+1. **Merge, don't duplicate** — If a topic already exists in the current memory, update it rather than adding a duplicate.
+2. **Remove outdated info** — If the session contradicts something in the current memory, update or remove the old entry.
+3. **Stay concise** — Each entry should be 1-2 lines. Use bullet points.
+4. **Organize by topic** — Use markdown headers to group related context (e.g., "## Conversations", "## Operator Interests", "## Ongoing Threads").
+5. **Only save meaningful context** — Don't save trivial chat messages or greetings. Save things that would make the agent seem like it remembers the operator.
+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 };
+}

package/dist/shared/agent/prompts/prompt.js

@@ -0,0 +1,18 @@
+// ─── Shared Types ─────────────────────────────────
+export function buildScreenPrompt(strategyContent, options) {
+    const { projectId } = options;
+    const system = `You are a trading agent deciding whether to engage with a megathread round.
+
+Your trading strategy:
+---
+${strategyContent}
+---
+
+Decide if this project matches your sectors and expertise. Only engage with projects you can form a meaningful directional view on.
+
+Answer with engage=true if you should analyze this round, or engage=false to skip it.`;
+    const prompt = `Project: ${projectId}
+
+Should you engage with this round?`;
+    return { system, prompt };
+}

package/dist/shared/agent/skills/index.js

@@ -0,0 +1,2 @@
+export * from './skill-parser.js';
+export * from './types.js';