@hive-org/cli 0.0.6 → 0.0.7

package/dist/agent/analysis.js

@@ -0,0 +1,78 @@
+import { generateText, Output } from 'ai';
+import { z } from 'zod';
+import { buildAnalystPrompt } from './prompt.js';
+import { loadMemory, saveMemory, getMemoryLineCount, MEMORY_SOFT_LIMIT } from '@hive-org/sdk';
+import { buildMemoryExtractionPrompt } from './memory-prompt.js';
+import { stripCodeFences } from './helpers.js';
+import { getModel } from './model.js';
+// ─── Prediction Schema ──────────────────────────────
+export const predictionSchema = z.object({
+    skip: z
+        .boolean()
+        .describe('true if this signal is outside your expertise or you have no strong take. false if you want to comment.'),
+    summary: z
+        .string()
+        .min(1)
+        .max(280)
+        .nullable()
+        .describe('Your CT-style take on this signal. Short, punchy, in character. Think tweet, not essay. null if skipping.'),
+    conviction: z
+        .number()
+        .nullable()
+        .describe('Predicted percent price change over the next 3 hours, up to one decimal place. Use the FULL range based on signal strength: tiny signals ±0.1-1.0, moderate ±1.5-5.0, strong ±5.0-12.0, extreme ±12.0-25.0. Negative for bearish. 0 if neutral. null if skipping. VARY your predictions — do NOT default to the same number repeatedly.'),
+});
+// ─── Signal Analysis ────────────────────────────────
+export async function processSignalAndSummarize(thread, recentComments, memory, soulContent, strategyContent) {
+    const promptOptions = {
+        threadText: thread.text,
+        projectId: thread.project_id,
+        timestamp: thread.timestamp,
+        priceOnFetch: thread.price_on_fetch,
+        citations: thread.citations,
+        recentPosts: recentComments,
+        memory,
+    };
+    const prompt = buildAnalystPrompt(soulContent, strategyContent, promptOptions);
+    const model = await getModel();
+    const { output } = await generateText({
+        model,
+        output: Output.object({ schema: predictionSchema }),
+        prompt,
+    });
+    if (!output) {
+        return { skip: true, summary: '', conviction: 0 };
+    }
+    const prediction = output;
+    const skip = prediction.skip ?? false;
+    const summary = prediction.summary ?? '';
+    const conviction = prediction.conviction ?? 0;
+    return { skip, summary, conviction };
+}
+// ─── 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,
+            prompt,
+        });
+        const cleaned = stripCodeFences(text);
+        await saveMemory(cleaned);
+        return cleaned;
+    }
+    catch (err) {
+        const raw = err instanceof Error ? err.message : String(err);
+        console.error(`[Memory] Failed to extract memory: ${raw.slice(0, 200)}`);
+        return null;
+    }
+}

package/dist/agent/app.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import TextInput from 'ink-text-input';
+import { useAgent } from './hooks/useAgent.js';
+import { colors, symbols, border } from './theme.js';
+import { formatTime, convictionColor } from './helpers.js';
+import { Spinner, PollText } from './components/Spinner.js';
+import { AsciiTicker } from './components/AsciiTicker.js';
+import { HoneycombBoot } from './components/HoneycombBoot.js';
+// ─── Main TUI App ────────────────────────────────────
+export function App() {
+    const { phase, connected, agentName, pollActivity, chatActivity, input, chatStreaming, chatBuffer, predictionCount, termWidth, setInput, handleChatSubmit, handleBootComplete, } = useAgent();
+    // When stdin is not a TTY (piped by hive-cli start), skip interactive input
+    const isInteractive = process.stdin.isTTY === true;
+    if (phase === 'booting') {
+        return _jsx(HoneycombBoot, { agentName: agentName, width: termWidth, onComplete: handleBootComplete });
+    }
+    const boxWidth = termWidth;
+    const visiblePollActivity = pollActivity.slice(-10);
+    const visibleChatActivity = chatActivity.slice(-3);
+    const statsText = predictionCount > 0 ? ` ${border.horizontal.repeat(3)} ${predictionCount} predicted` : '';
+    const connectedDisplay = connected ? 'Connected to the Hive' : 'connecting...';
+    const nameDisplay = `${agentName} agent`;
+    const headerFill = Math.max(0, boxWidth - nameDisplay.length - connectedDisplay.length - 12 - statsText.length);
+    return (_jsxs(Box, { flexDirection: "column", width: boxWidth, children: [_jsx(AsciiTicker, { rows: 2, step: predictionCount }), _jsxs(Box, { children: [_jsx(Text, { color: colors.honey, children: `${border.topLeft}${border.horizontal} ${symbols.hive} ` }), _jsxs(Text, { color: "white", bold: true, children: [agentName, " agent"] }), _jsxs(Text, { color: "gray", children: [" ", `${border.horizontal.repeat(3)} `] }), _jsx(Text, { color: connected ? 'green' : 'yellow', children: connected ? 'Connected to the Hive' : 'connecting...' }), statsText && _jsxs(Text, { color: "gray", children: [" ", `${border.horizontal.repeat(3)} `] }), statsText && _jsxs(Text, { color: colors.honey, children: [predictionCount, " predicted"] }), _jsxs(Text, { color: "gray", children: [' ', border.horizontal.repeat(Math.max(0, headerFill)), border.topRight] })] }), _jsxs(Box, { flexDirection: "column", paddingLeft: 1, paddingRight: 1, minHeight: 8, maxHeight: 24, children: [!connected && _jsx(Spinner, { label: "Initiating neural link..." }), visiblePollActivity.map((item, i) => {
+                        const isNewest = i === visiblePollActivity.length - 1 && item.type !== 'analyzing';
+                        return (_jsxs(Box, { flexDirection: "column", children: [item.type === 'online' && (_jsxs(Box, { children: [_jsxs(Text, { color: "gray", dimColor: true, children: [formatTime(item.timestamp), ' '] }), _jsxs(Text, { color: colors.honey, children: [symbols.hive, " "] }), _jsx(PollText, { color: "white", text: item.text, animate: isNewest })] })), item.type === 'signal' && (_jsxs(Box, { children: [_jsxs(Text, { color: "gray", dimColor: true, children: [formatTime(item.timestamp), ' '] }), _jsxs(Text, { color: colors.honey, children: [symbols.hive, " "] }), _jsx(PollText, { color: "cyan", text: item.text, animate: isNewest })] })), item.type === 'signal' && item.detail && (_jsx(Box, { marginLeft: 13, children: _jsx(PollText, { color: "gray", text: `"${item.detail}"`, animate: isNewest }) })), item.type === 'analyzing' && (_jsx(Box, { marginLeft: 13, children: _jsx(Spinner, { label: item.text }) })), item.type === 'posted' && (_jsxs(Box, { children: [_jsxs(Text, { color: "gray", dimColor: true, children: [formatTime(item.timestamp), ' '] }), _jsxs(Text, { color: convictionColor(item.conviction ?? 0), children: [symbols.diamond, " Predicted", ' '] }), _jsx(PollText, { color: "white", text: item.text, animate: isNewest })] })), item.type === 'skipped' && (_jsxs(Box, { children: [_jsxs(Text, { color: "gray", dimColor: true, children: [formatTime(item.timestamp), ' '] }), _jsx(PollText, { color: "yellow", text: `${symbols.diamondOpen} ${item.text}`, animate: isNewest })] })), item.type === 'error' && (_jsxs(Box, { children: [_jsxs(Text, { color: "gray", dimColor: true, children: [formatTime(item.timestamp), ' '] }), _jsx(PollText, { color: "red", text: `${symbols.cross} ${item.text}`, animate: isNewest })] })), item.type === 'idle' && (_jsxs(Box, { children: [_jsxs(Text, { color: "gray", dimColor: true, children: [formatTime(item.timestamp), ' '] }), _jsx(PollText, { color: "gray", text: `${symbols.circle} ${item.text}`, animate: isNewest })] }))] }, i));
+                    })] }), (chatActivity.length > 0 || chatStreaming) && (_jsxs(_Fragment, { children: [_jsx(Box, { children: _jsxs(Text, { color: "gray", children: [border.teeLeft, `${border.horizontal.repeat(2)} chat with ${agentName} agent `, border.horizontal.repeat(Math.max(0, boxWidth - agentName.length - 22)), border.teeRight] }) }), _jsxs(Box, { flexDirection: "column", paddingLeft: 1, paddingRight: 1, minHeight: 2, maxHeight: 8, children: [visibleChatActivity.map((item, i) => (_jsxs(Box, { children: [item.type === 'chat-user' && (_jsxs(Box, { children: [_jsxs(Text, { color: "white", bold: true, children: ["you:", ' '] }), _jsx(Text, { color: "white", children: item.text })] })), item.type === 'chat-agent' && (_jsxs(Box, { children: [_jsxs(Text, { color: colors.honey, bold: true, children: [agentName, " agent:", ' '] }), _jsx(Text, { color: "white", wrap: "wrap", children: item.text })] })), item.type === 'chat-error' && (_jsx(Box, { children: _jsxs(Text, { color: "red", children: [symbols.cross, " ", item.text] }) }))] }, i))), chatStreaming && chatBuffer && (_jsxs(Box, { children: [_jsxs(Text, { color: colors.honey, bold: true, children: [agentName, " agent:", ' '] }), _jsx(Text, { color: "white", wrap: "wrap", children: chatBuffer })] }))] })] })), _jsx(Box, { children: _jsxs(Text, { color: "gray", children: [isInteractive ? border.teeLeft : border.bottomLeft, border.horizontal.repeat(boxWidth - 2), isInteractive ? border.teeRight : border.bottomRight] }) }), isInteractive && (_jsxs(_Fragment, { children: [_jsxs(Box, { paddingLeft: 1, children: [_jsxs(Text, { color: colors.honey, children: [symbols.arrow, " "] }), _jsx(TextInput, { value: input, onChange: setInput, onSubmit: (val) => {
+                                    setInput('');
+                                    void handleChatSubmit(val);
+                                }, placeholder: chatStreaming ? 'thinking...' : `chat with ${agentName} agent...` })] }), _jsx(Box, { children: _jsxs(Text, { color: "gray", children: [border.bottomLeft, border.horizontal.repeat(boxWidth - 2), border.bottomRight] }) })] }))] }));
+}

package/dist/agent/chat-prompt.js

@@ -0,0 +1,63 @@
+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) {
+    let threadsSection = '';
+    if (context.recentThreadSummaries.length > 0) {
+        const listed = context.recentThreadSummaries.map((t) => `- ${t}`).join('\n');
+        threadsSection = `\n## Recent Signals\n\n${listed}\n`;
+    }
+    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 prompt = `You are an AI trading agent having a conversation with your operator. Stay in character.
+
+Your personality:
+---
+${soulContent}
+---
+
+Your trading strategy:
+---
+${strategyContent}
+---
+${memorySection}${threadsSection}${predictionsSection}${sessionSection}
+The operator says: "${context.userMessage}"
+
+## 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.`;
+    return prompt;
+}

package/dist/agent/components/AsciiTicker.js

@@ -0,0 +1,81 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Box, Text } from 'ink';
+import { colors, animation } from '../theme.js';
+function buildTickerChars(step) {
+    const stepStr = String(step).padStart(2, '0');
+    const digits = stepStr.split('');
+    return animation.HEX_CHARS + digits.join('') + '\u25AA\u25AB\u2591\u2592';
+}
+function buildRow(cols, frame, rowIndex, tickerChars) {
+    const segments = [];
+    const isSecondRow = rowIndex === 1;
+    const scrollSpeed = isSecondRow ? 3 : 2;
+    const direction = isSecondRow ? -1 : 1;
+    const sinFreq = isSecondRow ? 0.4 : 0.3;
+    const sinPhase = isSecondRow ? -0.4 : 0.6;
+    const wrapLen = cols * 2;
+    for (let c = 0; c < cols; c++) {
+        const scrolledC = ((direction === 1)
+            ? (c + frame * scrollSpeed) % wrapLen
+            : (cols - c + frame * scrollSpeed) % wrapLen);
+        const charIdx = scrolledC % tickerChars.length;
+        const char = tickerChars[charIdx];
+        const isHex = char === '\u2B21' || char === '\u2B22';
+        const pulseHit = Math.sin((c + frame * sinPhase) * sinFreq) > 0.5;
+        // Edge fade: dim the outermost 4 columns
+        const edgeDist = Math.min(c, cols - 1 - c);
+        if (edgeDist < 2) {
+            segments.push({ char: '\u00B7', color: colors.grayDim });
+            continue;
+        }
+        if (edgeDist < 4) {
+            segments.push({ char, color: colors.grayDim });
+            continue;
+        }
+        if (pulseHit && isHex) {
+            segments.push({ char, color: colors.honey });
+        }
+        else if (pulseHit) {
+            segments.push({ char, color: colors.green });
+        }
+        else {
+            segments.push({ char, color: colors.grayDim });
+        }
+    }
+    return segments;
+}
+function renderSegments(segments) {
+    const elements = [];
+    let runColor = segments[0]?.color ?? colors.grayDim;
+    let runChars = '';
+    for (let i = 0; i < segments.length; i++) {
+        const seg = segments[i];
+        if (seg.color === runColor) {
+            runChars += seg.char;
+        }
+        else {
+            elements.push(_jsx(Text, { color: runColor, children: runChars }, `${elements.length}`));
+            runColor = seg.color;
+            runChars = seg.char;
+        }
+    }
+    if (runChars.length > 0) {
+        elements.push(_jsx(Text, { color: runColor, children: runChars }, `${elements.length}`));
+    }
+    return elements;
+}
+export function AsciiTicker({ rows = 1, step = 1 }) {
+    const [frame, setFrame] = useState(0);
+    const cols = process.stdout.columns || 60;
+    const tickerChars = buildTickerChars(step);
+    useEffect(() => {
+        const timer = setInterval(() => {
+            setFrame((prev) => prev + 1);
+        }, animation.TICK_MS);
+        return () => {
+            clearInterval(timer);
+        };
+    }, []);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: renderSegments(buildRow(cols, frame, 0, tickerChars)) }), rows === 2 && (_jsx(Text, { children: renderSegments(buildRow(cols, frame, 1, tickerChars)) }))] }));
+}

package/dist/agent/components/HoneycombBoot.js

@@ -0,0 +1,270 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useState, useEffect, useRef } from 'react';
+import { Box, Text } from 'ink';
+import { colors, animation } from '../theme.js';
+const BOOT_TOTAL_FRAMES = 58;
+const BOOT_FRAME_MS = 80;
+const NUM_BEES = 4;
+const NUM_STREAMS = 5;
+const SCRAMBLE_CHARS = '\u2B21\u2B22\u25C6\u25C7\u2591\u2592!@#$%01';
+const BOOT_MESSAGES = [
+    { prefix: '\u2B21', text: 'Initializing {name} agent...', frame: 30 },
+    { prefix: '\u25C6', text: 'Loading personality matrix...', frame: 36 },
+    { prefix: '\u25C7', text: 'Connecting to the hive...', frame: 42 },
+    { prefix: '\u2713', text: 'Neural link established', frame: 48 },
+];
+// ─── Private helpers ─────────────────────────────────
+function isHexEdge(r, c) {
+    const rowInHex = ((r % animation.HEX_H) + animation.HEX_H) % animation.HEX_H;
+    const isOddHex = Math.floor(r / animation.HEX_H) % 2 === 1;
+    const colOffset = isOddHex ? animation.HEX_W / 2 : 0;
+    const colInHex = (((c - colOffset) % animation.HEX_W) + animation.HEX_W) % animation.HEX_W;
+    if (rowInHex === 0 || rowInHex === animation.HEX_H - 1) {
+        return colInHex >= 2 && colInHex <= 5;
+    }
+    if (rowInHex === 1 || rowInHex === 2) {
+        return colInHex === 1 || colInHex === 6;
+    }
+    return false;
+}
+function compressRow(row) {
+    if (row.length === 0)
+        return [];
+    const segments = [];
+    let current = { text: row[0].char, color: row[0].color };
+    for (let i = 1; i < row.length; i++) {
+        if (row[i].color === current.color) {
+            current.text += row[i].char;
+        }
+        else {
+            segments.push(current);
+            current = { text: row[i].char, color: row[i].color };
+        }
+    }
+    segments.push(current);
+    return segments;
+}
+function initBees(rows, cols) {
+    const bees = [];
+    for (let i = 0; i < NUM_BEES; i++) {
+        bees.push({
+            r: Math.floor(Math.random() * rows),
+            c: Math.floor(Math.random() * cols),
+            vr: Math.random() > 0.5 ? 1 : -1,
+            vc: Math.random() > 0.5 ? 1 : -1,
+        });
+    }
+    return bees;
+}
+function initStreamCols(cols) {
+    const streamCols = [];
+    const spacing = Math.floor(cols / (NUM_STREAMS + 1));
+    for (let i = 1; i <= NUM_STREAMS; i++) {
+        streamCols.push(spacing * i);
+    }
+    return streamCols;
+}
+// ─── Grid builder ────────────────────────────────────
+function buildHoneycombGrid(cols, rows, frame, agentName, bees, streamCols, pulses) {
+    const centerR = Math.floor(rows / 2) - 2;
+    const centerC = Math.floor(cols / 2);
+    // Initialize empty grid
+    const grid = [];
+    for (let r = 0; r < rows; r++) {
+        const row = [];
+        for (let c = 0; c < cols; c++) {
+            row.push({ char: ' ', color: colors.grayDim });
+        }
+        grid.push(row);
+    }
+    // ── Layer 1: Hex skeleton base ──
+    for (let r = 0; r < rows; r++) {
+        for (let c = 0; c < cols; c++) {
+            if (isHexEdge(r, c)) {
+                grid[r][c] = { char: '\u00B7', color: colors.grayDim };
+            }
+        }
+    }
+    // ── Layer 2: Scanning wave ──
+    const scanRow = frame % (rows + 6);
+    for (let r = 0; r < rows; r++) {
+        for (let c = 0; c < cols; c++) {
+            if (!isHexEdge(r, c))
+                continue;
+            const dist = Math.abs(r - scanRow);
+            if (dist === 0) {
+                grid[r][c] = { char: '\u2B22', color: colors.honey };
+            }
+            else if (dist <= 1) {
+                grid[r][c] = { char: '\u2B21', color: colors.honey };
+            }
+        }
+    }
+    // ── Layer 3: Vertical data streams ──
+    if (frame >= 8) {
+        const streamPhase = frame - 8;
+        for (const sc of streamCols) {
+            if (sc >= cols)
+                continue;
+            for (let r = 0; r < rows; r++) {
+                const streamOffset = (streamPhase * 2 + sc) % (rows * 3);
+                const streamDist = (((r - streamOffset) % rows) + rows) % rows;
+                if (streamDist < 6) {
+                    const charIdx = (frame + r) % animation.DATA_CHARS.length;
+                    const streamChar = animation.DATA_CHARS[charIdx];
+                    let streamColor = colors.grayDim;
+                    if (streamDist === 0) {
+                        streamColor = colors.white;
+                    }
+                    else if (streamDist < 3) {
+                        streamColor = colors.green;
+                    }
+                    grid[r][sc] = { char: streamChar, color: streamColor };
+                }
+            }
+        }
+    }
+    // ── Layer 4: Pulse overlay ──
+    for (const pulse of pulses) {
+        if (pulse.r >= 0 && pulse.r < rows && pulse.c >= 0 && pulse.c < cols) {
+            const brightness = pulse.ttl / 8;
+            const cell = grid[pulse.r][pulse.c];
+            if (cell.char === '\u00B7' || cell.char === ' ') {
+                grid[pulse.r][pulse.c] = {
+                    char: brightness > 0.5 ? '\u2B21' : '\u00B7',
+                    color: pulse.color,
+                };
+            }
+        }
+    }
+    // ── Layer 5: Bee overlay ──
+    for (const bee of bees) {
+        const br = Math.max(0, Math.min(rows - 1, Math.round(bee.r)));
+        const bc = Math.max(0, Math.min(cols - 1, Math.round(bee.c)));
+        grid[br][bc] = { char: '\u25C6', color: colors.honey };
+    }
+    // ── Layer 6: Agent name with scramble→reveal ──
+    if (frame >= 22) {
+        const nameText = `\u2B21  ${agentName} agent  \u2B21`;
+        const nameStart = Math.max(0, centerC - Math.floor(nameText.length / 2));
+        const scrambleProgress = Math.min(1, (frame - 22) / 8);
+        // Clear space around the name
+        for (let c = nameStart - 2; c < nameStart + nameText.length + 2 && c < cols; c++) {
+            if (c >= 0) {
+                grid[centerR][c] = { char: ' ', color: colors.grayDim };
+                if (centerR - 1 >= 0)
+                    grid[centerR - 1][c] = { char: ' ', color: colors.grayDim };
+                if (centerR + 1 < rows)
+                    grid[centerR + 1][c] = { char: ' ', color: colors.grayDim };
+            }
+        }
+        // Top/bottom border lines around name
+        for (let c = nameStart; c < nameStart + nameText.length && c < cols; c++) {
+            if (centerR - 1 >= 0)
+                grid[centerR - 1][c] = { char: '\u2500', color: colors.honey };
+            if (centerR + 1 < rows)
+                grid[centerR + 1][c] = { char: '\u2500', color: colors.honey };
+        }
+        // Name text with scramble effect
+        for (let i = 0; i < nameText.length; i++) {
+            const c = nameStart + i;
+            if (c >= cols)
+                break;
+            const charThreshold = i / nameText.length;
+            if (charThreshold <= scrambleProgress) {
+                grid[centerR][c] = { char: nameText[i], color: colors.honey };
+            }
+            else {
+                const scrambleIdx = Math.floor(Math.random() * SCRAMBLE_CHARS.length);
+                grid[centerR][c] = { char: SCRAMBLE_CHARS[scrambleIdx], color: colors.gray };
+            }
+        }
+    }
+    // ── Layer 7: Boot messages with typewriter ──
+    const msgStartRow = centerR + 4;
+    for (let idx = 0; idx < BOOT_MESSAGES.length; idx++) {
+        const msg = BOOT_MESSAGES[idx];
+        if (frame < msg.frame)
+            continue;
+        const r = msgStartRow + idx;
+        if (r >= rows)
+            continue;
+        const fullText = `${msg.prefix} ${msg.text.replace('{name}', agentName)}`;
+        const msgStart = Math.max(0, centerC - Math.floor(fullText.length / 2));
+        const visibleChars = Math.min(fullText.length, (frame - msg.frame) * 3);
+        for (let i = 0; i < visibleChars; i++) {
+            const c = msgStart + i;
+            if (c >= cols)
+                break;
+            const isCheckmark = msg.prefix === '\u2713';
+            grid[r][c] = { char: fullText[i], color: isCheckmark ? colors.green : colors.honey };
+        }
+    }
+    return grid;
+}
+export function HoneycombBoot({ agentName, width, onComplete }) {
+    const [frame, setFrame] = useState(0);
+    const heightRef = useRef(process.stdout.rows || 24);
+    const completedRef = useRef(false);
+    const frameRef = useRef(0);
+    const beesRef = useRef(initBees(heightRef.current, width));
+    const streamColsRef = useRef(initStreamCols(width));
+    const pulsesRef = useRef([]);
+    useEffect(() => {
+        const tick = setInterval(() => {
+            const h = heightRef.current;
+            const f = frameRef.current;
+            // Advance bees every other frame
+            if (beesRef.current.length > 0 && f % 2 === 0) {
+                for (const bee of beesRef.current) {
+                    bee.r += bee.vr;
+                    bee.c += bee.vc;
+                    if (bee.r <= 0 || bee.r >= h - 1) {
+                        bee.vr *= -1;
+                        bee.r = Math.max(0, Math.min(h - 1, bee.r));
+                    }
+                    if (bee.c <= 0 || bee.c >= width - 1) {
+                        bee.vc *= -1;
+                        bee.c = Math.max(0, Math.min(width - 1, bee.c));
+                    }
+                    if (Math.random() > 0.3) {
+                        bee.vc = Math.random() > 0.5 ? 1 : -1;
+                    }
+                }
+            }
+            // Spawn pulses every 4 frames
+            if (f % 4 === 0) {
+                const currentPulses = pulsesRef.current;
+                for (let i = 0; i < 3; i++) {
+                    const pr = Math.floor(Math.random() * h);
+                    const pc = Math.floor(Math.random() * width);
+                    if (isHexEdge(pr, pc)) {
+                        const pulseColors = [colors.green, colors.red, colors.honey];
+                        const color = pulseColors[Math.floor(Math.random() * pulseColors.length)];
+                        currentPulses.push({ r: pr, c: pc, ttl: 8, color });
+                    }
+                }
+                pulsesRef.current = currentPulses
+                    .filter((p) => p.ttl > 0)
+                    .map((p) => ({ ...p, ttl: p.ttl - 1 }));
+            }
+            frameRef.current = f + 1;
+            setFrame(frameRef.current);
+            if (frameRef.current >= BOOT_TOTAL_FRAMES && !completedRef.current) {
+                completedRef.current = true;
+                clearInterval(tick);
+                setTimeout(onComplete, 300);
+            }
+        }, BOOT_FRAME_MS);
+        return () => {
+            clearInterval(tick);
+        };
+    }, [onComplete, width]);
+    const height = heightRef.current;
+    const clampedFrame = Math.min(frame, BOOT_TOTAL_FRAMES);
+    const grid = buildHoneycombGrid(width, height, clampedFrame, agentName, beesRef.current, streamColsRef.current, pulsesRef.current);
+    return (_jsx(Box, { flexDirection: "column", height: height, children: grid.map((row, r) => {
+            const segments = compressRow(row);
+            return (_jsx(Box, { width: width, children: _jsx(Text, { children: segments.map((seg, i) => (_jsx(Text, { color: seg.color, children: seg.text }, i))) }) }, r));
+        }) }));
+}

package/dist/agent/components/Spinner.js

@@ -0,0 +1,37 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Text } from 'ink';
+import { colors } from '../theme.js';
+const SPINNER_FRAMES = ['\u25D0', '\u25D3', '\u25D1', '\u25D2'];
+export function Spinner({ label }) {
+    const [frame, setFrame] = useState(0);
+    useEffect(() => {
+        const timer = setInterval(() => {
+            setFrame((prev) => (prev + 1) % SPINNER_FRAMES.length);
+        }, 120);
+        return () => {
+            clearInterval(timer);
+        };
+    }, []);
+    return (_jsxs(Text, { children: [_jsx(Text, { color: colors.honey, children: SPINNER_FRAMES[frame] }), _jsxs(Text, { color: "gray", children: [" ", label] })] }));
+}
+export function TypewriterText({ text, color, speed = 25, }) {
+    const [visible, setVisible] = useState(0);
+    useEffect(() => {
+        if (visible >= text.length)
+            return;
+        const timer = setTimeout(() => {
+            setVisible((prev) => Math.min(prev + 2, text.length));
+        }, speed);
+        return () => {
+            clearTimeout(timer);
+        };
+    }, [visible, text, speed]);
+    return _jsx(Text, { color: color, children: text.slice(0, visible) });
+}
+export function PollText({ text, color, animate, }) {
+    if (animate) {
+        return _jsx(TypewriterText, { text: text, color: color });
+    }
+    return _jsx(Text, { color: color, children: text });
+}

package/dist/agent/config.js

@@ -0,0 +1,52 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+async function loadMarkdownFile(filename) {
+    const filePath = path.join(process.cwd(), filename);
+    const content = await fs.readFile(filePath, 'utf-8');
+    return content;
+}
+function extractField(content, pattern) {
+    const match = content.match(pattern);
+    if (match === null) {
+        return null;
+    }
+    const value = match[1].trim();
+    return value;
+}
+export async function loadAgentConfig() {
+    const soulContent = await loadMarkdownFile('SOUL.md');
+    const strategyContent = await loadMarkdownFile('STRATEGY.md');
+    const name = extractField(soulContent, /^#\s+Agent:\s+(.+)$/m);
+    if (name === null) {
+        throw new Error('Could not parse agent name from SOUL.md. Expected "# Agent: <name>" as the first heading.');
+    }
+    const avatarUrl = extractField(soulContent, /^## Avatar\s*\n+(https?:\/\/.+)$/m);
+    if (avatarUrl === null) {
+        throw new Error('Could not parse avatar URL from SOUL.md. Expected a valid URL under "## Avatar".');
+    }
+    const bioRaw = extractField(soulContent, /^## Bio\s*\n+(.+)$/m);
+    const bio = bioRaw ?? null;
+    const signalMethod = extractField(strategyContent, /^-\s+Method:\s+(.+)$/m);
+    const convictionStyle = extractField(strategyContent, /^-\s+Boldness:\s+(.+)$/m);
+    const directionalBias = extractField(strategyContent, /^-\s+Directional bias:\s+(.+)$/m);
+    const participation = extractField(strategyContent, /^-\s+Participation:\s+(.+)$/m);
+    if (signalMethod === null ||
+        convictionStyle === null ||
+        directionalBias === null ||
+        participation === null) {
+        const missing = [
+            signalMethod === null ? 'Method' : null,
+            convictionStyle === null ? 'Boldness' : null,
+            directionalBias === null ? 'Directional bias' : null,
+            participation === null ? 'Participation' : null,
+        ].filter(Boolean);
+        throw new Error(`Could not parse prediction profile from STRATEGY.md. Missing fields: ${missing.join(', ')}`);
+    }
+    const predictionProfile = {
+        signal_method: signalMethod,
+        conviction_style: convictionStyle,
+        directional_bias: directionalBias,
+        participation,
+    };
+    return { name, bio, avatarUrl, soulContent, strategyContent, predictionProfile };
+}