@zhive/cli 0.5.0

package/dist/agent/hooks/useAgent.js

@@ -0,0 +1,480 @@
+import { HiveAgent, loadMemory } from '@hive-org/sdk';
+import { ToolLoopAgent } from 'ai';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { HIVE_FRONTEND_URL } from '../../config.js';
+import { buildTextReport, fetchBacktestThreads, loadDefaultBacktest, runBacktest, } from '../../backtest/index.js';
+import { extractAndSaveMemory, processMegathreadRound, processSignalAndSummarize, } from '../analysis.js';
+import { buildChatPrompt } from '../chat-prompt.js';
+import { SLASH_COMMANDS } from '../commands/registry.js';
+import { loadAgentConfig } from '../config.js';
+import { editSectionTool } from '../edit-section.js';
+import { fetchRulesTool } from '../fetch-rules.js';
+import { getModel, resolveModelInfo } from '../model.js';
+import { getAllTools, getReadSkillTool, getSkillMetadataList, initializeSkills, } from '../tools/index.js';
+import { getMarketClient } from '../tools/market/index.js';
+export function useAgent() {
+    const [connected, setConnected] = useState(false);
+    const [agentName, setAgentName] = useState('agent');
+    const [agentBio, setAgentBio] = useState('');
+    const [modelInfo, setModelInfo] = useState(null);
+    const [pollActivity, setPollActivity] = useState([]);
+    const [chatActivity, setChatActivity] = useState([]);
+    const [input, setInput] = useState('');
+    const [chatStreaming, setChatStreaming] = useState(false);
+    const [chatBuffer, setChatBuffer] = useState('');
+    const [predictionCount, setPredictionCount] = useState(0);
+    const [termWidth, setTermWidth] = useState(process.stdout.columns || 60);
+    const agentRef = useRef(null);
+    const sessionMessagesRef = useRef([]);
+    const memoryRef = useRef('');
+    const chatCountSinceExtractRef = useRef(0);
+    const extractingRef = useRef(false);
+    const recentThreadsRef = useRef([]);
+    const recentPredictionsRef = useRef([]);
+    const predictionCountRef = useRef(0);
+    const soulContentRef = useRef('');
+    const strategyContentRef = useRef('');
+    const skillToolsRef = useRef({});
+    const skillMetadataRef = useRef('');
+    // ─── Terminal resize tracking ───────────────────────
+    useEffect(() => {
+        const onResize = () => {
+            setTermWidth(process.stdout.columns || 60);
+        };
+        process.stdout.on('resize', onResize);
+        return () => {
+            process.stdout.off('resize', onResize);
+        };
+    }, []);
+    // ─── Activity helpers ───────────────────────────────
+    const addPollActivity = useCallback((item) => {
+        setPollActivity((prev) => {
+            const updated = [...prev, { ...item, timestamp: new Date() }];
+            const maxItems = 50;
+            if (updated.length > maxItems) {
+                return updated.slice(updated.length - maxItems);
+            }
+            return updated;
+        });
+    }, []);
+    const addIdleActivity = useCallback(() => {
+        setPollActivity((prev) => {
+            const updated = [
+                ...prev,
+                { type: 'idle', text: 'Polled but no new threads', timestamp: new Date() },
+            ];
+            const maxItems = 50;
+            if (updated.length > maxItems) {
+                return updated.slice(updated.length - maxItems);
+            }
+            return updated;
+        });
+    }, []);
+    const updatePollActivity = useCallback((id, updates) => {
+        setPollActivity((prev) => {
+            let idx = -1;
+            for (let i = prev.length - 1; i >= 0; i--) {
+                if (prev[i].id === id) {
+                    idx = i;
+                    break;
+                }
+            }
+            if (idx === -1)
+                return prev;
+            const updated = [...prev];
+            updated[idx] = { ...updated[idx], ...updates };
+            return updated;
+        });
+    }, []);
+    const addChatActivity = useCallback((item) => {
+        setChatActivity((prev) => {
+            const updated = [...prev, { ...item, timestamp: new Date() }];
+            const maxItems = 50;
+            if (updated.length > maxItems) {
+                return updated.slice(updated.length - maxItems);
+            }
+            return updated;
+        });
+    }, []);
+    // ─── Agent lifecycle ────────────────────────────────
+    useEffect(() => {
+        const start = async () => {
+            const { HIVE_API_URL } = await import('../../config.js');
+            const baseUrl = HIVE_API_URL;
+            const config = await loadAgentConfig();
+            setAgentName(config.name);
+            setAgentBio(config.bio ?? '');
+            soulContentRef.current = config.soulContent;
+            strategyContentRef.current = config.strategyContent;
+            const resolvedModelInfo = resolveModelInfo();
+            setModelInfo(resolvedModelInfo);
+            const skillRegistry = await initializeSkills(process.cwd());
+            const allTools = getAllTools();
+            const readSkillTool = getReadSkillTool(skillRegistry);
+            skillToolsRef.current = { ...allTools, readSkill: readSkillTool };
+            skillMetadataRef.current = getSkillMetadataList(skillRegistry);
+            const initialMemory = await loadMemory();
+            memoryRef.current = initialMemory;
+            const agent = new HiveAgent(baseUrl, {
+                name: config.name,
+                avatarUrl: config.avatarUrl,
+                bio: config.bio ?? undefined,
+                agentProfile: config.agentProfile,
+                pollIntervalMs: 30_000,
+                pollLimit: 5,
+                onPollEmpty: addIdleActivity,
+                onStop: async () => { },
+                onNewThread: async (thread) => {
+                    const threadPreview = thread.text.length > 80 ? thread.text.slice(0, 80) + '\u2026' : thread.text;
+                    const projectTag = `c/${thread.project_id}`;
+                    addPollActivity({
+                        type: 'signal',
+                        id: thread.id,
+                        text: projectTag,
+                        detail: threadPreview,
+                        status: 'analyzing',
+                    });
+                    const summary = `[${thread.project_id}] ${threadPreview}`;
+                    recentThreadsRef.current = [summary, ...recentThreadsRef.current].slice(0, 5);
+                    try {
+                        const result = await processSignalAndSummarize(thread, agent.recentComments, memoryRef.current, soulContentRef.current, strategyContentRef.current, skillToolsRef.current, skillMetadataRef.current);
+                        if (result.skip) {
+                            updatePollActivity(thread.id, {
+                                status: 'skipped',
+                                tokenUsage: result.usage,
+                            });
+                            return;
+                        }
+                        await agent.postComment(thread.id, {
+                            thread_id: thread.id,
+                            text: result.summary,
+                            conviction: result.conviction,
+                        }, thread.text);
+                        const sign = result.conviction >= 0 ? '+' : '';
+                        const threadUrl = `${HIVE_FRONTEND_URL}/c/${thread.project_id}/${thread.id}`;
+                        updatePollActivity(thread.id, {
+                            status: 'posted',
+                            conviction: result.conviction,
+                            result: `[${sign}${result.conviction.toFixed(2)}%] "${result.summary}"`,
+                            url: threadUrl,
+                            tokenUsage: result.usage,
+                        });
+                        predictionCountRef.current += 1;
+                        setPredictionCount(predictionCountRef.current);
+                        const predSummary = `[${sign}${result.conviction.toFixed(2)}%] ${result.summary}`;
+                        recentPredictionsRef.current = [predSummary, ...recentPredictionsRef.current].slice(0, 5);
+                    }
+                    catch (err) {
+                        const raw = err instanceof Error ? err.message : String(err);
+                        const message = raw.length > 120 ? raw.slice(0, 120) + '\u2026' : raw;
+                        updatePollActivity(thread.id, { status: 'error', result: message });
+                    }
+                },
+                onNewMegathreadRound: async (round) => {
+                    const hours = Math.round(round.durationMs / 3_600_000);
+                    const timeframe = hours >= 1 ? `${hours}h` : `${Math.round(round.durationMs / 60_000)}m`;
+                    const projectTag = `c/${round.projectId}`;
+                    addPollActivity({
+                        type: 'megathread',
+                        id: round.roundId,
+                        text: `${projectTag} \u00B7 ${timeframe} round`,
+                        detail: round.roundId.split('@')[0],
+                        status: 'analyzing',
+                    });
+                    let priceAtStart;
+                    let currentPrice;
+                    try {
+                        const client = getMarketClient();
+                        const roundStartTimestamp = round.roundId.split('@Z')[0];
+                        const [startResponse, nowResponse] = await Promise.all([
+                            client.getPrice(round.projectId, roundStartTimestamp),
+                            client.getPrice(round.projectId, new Date().toISOString()),
+                        ]);
+                        if (startResponse.price !== null) {
+                            priceAtStart = startResponse.price;
+                        }
+                        if (nowResponse.price !== null) {
+                            currentPrice = nowResponse.price;
+                        }
+                    }
+                    catch {
+                        // Price fetch failed — both stay undefined, prompt falls back to current behavior
+                    }
+                    try {
+                        const result = await processMegathreadRound(round.projectId, round.durationMs, agent.recentComments, memoryRef.current, soulContentRef.current, strategyContentRef.current, skillToolsRef.current, skillMetadataRef.current, priceAtStart, currentPrice);
+                        if (result.skip) {
+                            updatePollActivity(round.roundId, {
+                                status: 'skipped',
+                                tokenUsage: result.usage,
+                            });
+                            return;
+                        }
+                        await agent.postMegathreadComment(round.roundId, {
+                            text: result.summary,
+                            conviction: result.conviction,
+                            tokenId: round.projectId,
+                            roundDuration: round.durationMs,
+                        });
+                        const sign = result.conviction >= 0 ? '+' : '';
+                        const megathreadUrl = `${HIVE_FRONTEND_URL}/c/${round.projectId}/megathread/${timeframe}`;
+                        updatePollActivity(round.roundId, {
+                            status: 'posted',
+                            conviction: result.conviction,
+                            result: `[${sign}${result.conviction.toFixed(2)}%] "${result.summary}"`,
+                            url: megathreadUrl,
+                            tokenUsage: result.usage,
+                        });
+                        predictionCountRef.current += 1;
+                        setPredictionCount(predictionCountRef.current);
+                        const predSummary = `[${sign}${result.conviction.toFixed(2)}%] ${result.summary}`;
+                        recentPredictionsRef.current = [predSummary, ...recentPredictionsRef.current].slice(0, 5);
+                    }
+                    catch (err) {
+                        const raw = err instanceof Error ? err.message : String(err);
+                        const message = raw.length > 120 ? raw.slice(0, 120) + '\u2026' : raw;
+                        updatePollActivity(round.roundId, { status: 'error', result: message });
+                    }
+                },
+            });
+            agentRef.current = agent;
+            await agent.start();
+            setConnected(true);
+            const bio = config.bio ?? '';
+            if (bio) {
+                addPollActivity({
+                    type: 'online',
+                    text: `${config.name} agent online \u2014 "${bio}"`,
+                });
+            }
+        };
+        start().catch((err) => {
+            const raw = err instanceof Error ? err.message : String(err);
+            const isNameTaken = raw.includes('409');
+            const hint = isNameTaken ? ' Change the name in SOUL.md under "# Agent: <name>".' : '';
+            addPollActivity({ type: 'error', text: `Fatal: ${raw.slice(0, 120)}${hint}` });
+        });
+        return () => {
+            agentRef.current?.stop().catch(() => { });
+        };
+    }, []);
+    // ─── Chat submission ────────────────────────────────
+    const handleChatSubmit = useCallback(async (message) => {
+        if (!message.trim() || chatStreaming) {
+            return;
+        }
+        // Handle slash commands
+        if (message.startsWith('/')) {
+            const trimmedMessage = message.trim().toLowerCase();
+            const parts = trimmedMessage.split(/\s+/);
+            const baseCommand = parts[0];
+            const commandArg = parts[1];
+            const commandHandlers = {
+                '/skills': () => {
+                    const skillsOutput = skillMetadataRef.current || 'No skills loaded.';
+                    addChatActivity({ type: 'chat-agent', text: skillsOutput });
+                },
+                '/help': () => {
+                    const helpText = SLASH_COMMANDS.map((cmd) => `${cmd.name} - ${cmd.description}`).join('\n');
+                    addChatActivity({ type: 'chat-agent', text: helpText });
+                },
+                '/clear': () => {
+                    setChatActivity([]);
+                    sessionMessagesRef.current = [];
+                },
+                '/memory': () => {
+                    const memoryOutput = memoryRef.current || 'No memory stored yet.';
+                    addChatActivity({ type: 'chat-agent', text: memoryOutput });
+                },
+                '/backtest': async () => {
+                    const { HIVE_API_URL } = await import('../../config.js');
+                    const numThreads = commandArg ? parseInt(commandArg, 10) : null;
+                    let data;
+                    if (numThreads !== null && !isNaN(numThreads) && numThreads > 0) {
+                        // Fetch from API
+                        addChatActivity({
+                            type: 'chat-agent',
+                            text: `Fetching ${numThreads} resolved threads...`,
+                        });
+                        const fetchResult = await fetchBacktestThreads(numThreads, HIVE_API_URL);
+                        if (fetchResult.success) {
+                            data = fetchResult.data;
+                        }
+                        else {
+                            addChatActivity({
+                                type: 'chat-agent',
+                                text: `API fetch failed (${fetchResult.error}), falling back to default dataset...`,
+                            });
+                        }
+                    }
+                    // Use default dataset
+                    if (!data) {
+                        addChatActivity({
+                            type: 'chat-agent',
+                            text: 'Starting backtest against default dataset...',
+                        });
+                        data = loadDefaultBacktest();
+                    }
+                    try {
+                        const config = {
+                            agentPath: process.cwd(),
+                            soulContent: soulContentRef.current,
+                            strategyContent: strategyContentRef.current,
+                            agentName: agentName,
+                        };
+                        const result = await runBacktest(data, config, {
+                            onThreadStart: (index, total, thread) => {
+                                addChatActivity({
+                                    type: 'chat-agent',
+                                    text: `Processing ${index + 1}/${total}: ${thread.project_name}...`,
+                                });
+                            },
+                        });
+                        const report = buildTextReport(result);
+                        addChatActivity({ type: 'chat-agent', text: report });
+                        sessionMessagesRef.current.push({ role: 'assistant', content: report });
+                    }
+                    catch (err) {
+                        const errMessage = err instanceof Error ? err.message : String(err);
+                        addChatActivity({ type: 'chat-error', text: `Backtest failed: ${errMessage}` });
+                    }
+                },
+            };
+            const handler = commandHandlers[baseCommand];
+            if (handler) {
+                await handler();
+                return;
+            }
+            // Unknown command
+            addChatActivity({ type: 'chat-error', text: `Unknown command: ${message}` });
+            return;
+        }
+        addChatActivity({ type: 'chat-user', text: message });
+        sessionMessagesRef.current.push({ role: 'user', content: message });
+        chatCountSinceExtractRef.current += 1;
+        if (chatCountSinceExtractRef.current >= 3 && !extractingRef.current) {
+            extractingRef.current = true;
+            const messagesSnapshot = [...sessionMessagesRef.current];
+            extractAndSaveMemory(messagesSnapshot)
+                .then((newMemory) => {
+                if (newMemory !== null) {
+                    memoryRef.current = newMemory;
+                }
+                chatCountSinceExtractRef.current = 0;
+            })
+                .catch(() => { })
+                .finally(() => {
+                extractingRef.current = false;
+            });
+        }
+        setChatStreaming(true);
+        setChatBuffer('');
+        try {
+            const { system, prompt } = buildChatPrompt(soulContentRef.current, strategyContentRef.current, {
+                recentThreadSummaries: recentThreadsRef.current,
+                recentPredictions: recentPredictionsRef.current,
+                sessionMessages: sessionMessagesRef.current.slice(-20),
+                memory: memoryRef.current,
+                userMessage: message,
+            });
+            const model = await getModel();
+            const cacheableSystem = {
+                role: 'system',
+                content: system,
+                providerOptions: {
+                    anthropic: { cacheControl: { type: 'ephemeral' } },
+                },
+            };
+            const agent = new ToolLoopAgent({
+                model,
+                instructions: cacheableSystem,
+                tools: {
+                    editSection: editSectionTool,
+                    fetchRules: fetchRulesTool,
+                    ...skillToolsRef.current,
+                },
+                maxOutputTokens: 4096,
+            });
+            const result = await agent.stream({
+                prompt,
+                onStepFinish: async ({ toolResults }) => {
+                    for (const toolResult of toolResults) {
+                        if (toolResult.toolName === 'editSection') {
+                            const output = String(toolResult.output);
+                            // Only reload if update was successful
+                            if (output.startsWith('Updated')) {
+                                const config = await loadAgentConfig();
+                                soulContentRef.current = config.soulContent;
+                                strategyContentRef.current = config.strategyContent;
+                            }
+                        }
+                    }
+                },
+            });
+            let fullResponse = '';
+            let lastFlushTime = 0;
+            const THROTTLE_MS = 80;
+            const streamErrors = [];
+            for await (const part of result.fullStream) {
+                if (part.type === 'text-delta') {
+                    fullResponse += part.text;
+                    const now = Date.now();
+                    if (now - lastFlushTime >= THROTTLE_MS) {
+                        setChatBuffer(fullResponse);
+                        lastFlushTime = now;
+                    }
+                }
+                else if (part.type === 'error') {
+                    const errMsg = typeof part.error === 'string' ? part.error : String(part.error);
+                    streamErrors.push(errMsg);
+                }
+            }
+            // Always flush the final value
+            setChatBuffer(fullResponse);
+            // Surface tool results when the model didn't produce follow-up text
+            const steps = await result.steps;
+            for (const step of steps) {
+                for (const toolResult of step.toolResults) {
+                    const output = String(toolResult.output);
+                    if (!fullResponse.includes(output)) {
+                        const suffix = `\n[${output}]`;
+                        fullResponse += suffix;
+                        setChatBuffer(fullResponse);
+                    }
+                }
+            }
+            if (fullResponse.trim().length === 0) {
+                const errorText = streamErrors.length > 0
+                    ? `Chat error: ${streamErrors.join('; ').slice(0, 120)}`
+                    : 'No response generated. Try again or rephrase.';
+                addChatActivity({ type: 'chat-error', text: errorText });
+                setChatBuffer('');
+                return;
+            }
+            sessionMessagesRef.current.push({ role: 'assistant', content: fullResponse });
+            addChatActivity({ type: 'chat-agent', text: fullResponse });
+            setChatBuffer('');
+        }
+        catch (err) {
+            const raw = err instanceof Error ? err.message : String(err);
+            addChatActivity({ type: 'chat-error', text: `Chat error: ${raw.slice(0, 120)}` });
+        }
+        finally {
+            setChatStreaming(false);
+        }
+    }, [chatStreaming, addChatActivity]);
+    return {
+        connected,
+        agentName,
+        agentBio,
+        modelInfo,
+        pollActivity,
+        chatActivity,
+        input,
+        chatStreaming,
+        chatBuffer,
+        predictionCount,
+        termWidth,
+        setInput,
+        handleChatSubmit,
+    };
+}

package/dist/agent/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/agent/model.js

@@ -0,0 +1,92 @@
+import { AI_PROVIDERS } from '../ai-providers.js';
+import { getAgentProviderKeys } from '../load-agent-env.js';
+const PROVIDERS = [
+    {
+        label: 'Anthropic',
+        envVar: 'ANTHROPIC_API_KEY',
+        load: async (modelId) => {
+            const { anthropic } = await import('@ai-sdk/anthropic');
+            return anthropic(modelId);
+        },
+    },
+    {
+        label: 'OpenAI',
+        envVar: 'OPENAI_API_KEY',
+        load: async (modelId) => {
+            const { openai } = await import('@ai-sdk/openai');
+            return openai(modelId);
+        },
+    },
+    {
+        label: 'Google',
+        envVar: 'GOOGLE_GENERATIVE_AI_API_KEY',
+        load: async (modelId) => {
+            const { google } = await import('@ai-sdk/google');
+            return google(modelId);
+        },
+    },
+    {
+        label: 'xAI',
+        envVar: 'XAI_API_KEY',
+        load: async (modelId) => {
+            const { xai } = await import('@ai-sdk/xai');
+            return xai(modelId);
+        },
+    },
+    {
+        label: 'OpenRouter',
+        envVar: 'OPENROUTER_API_KEY',
+        load: async (modelId) => {
+            const { createOpenRouter } = await import('@openrouter/ai-sdk-provider');
+            const openrouter = createOpenRouter({ apiKey: process.env.OPENROUTER_API_KEY });
+            return openrouter.chat(modelId);
+        },
+    },
+];
+export function resolveModelInfo() {
+    const overrideModel = process.env.HIVE_MODEL;
+    const agentKeys = getAgentProviderKeys();
+    const sortedProviders = [
+        ...PROVIDERS.filter((p) => agentKeys.has(p.envVar)),
+        ...PROVIDERS.filter((p) => !agentKeys.has(p.envVar)),
+    ];
+    for (const provider of sortedProviders) {
+        const keyValue = process.env[provider.envVar];
+        if (keyValue && keyValue.trim().length > 0) {
+            const centralProvider = AI_PROVIDERS.find((p) => p.envVar === provider.envVar);
+            const runtimeModel = centralProvider?.models.runtime ?? 'unknown';
+            const modelId = overrideModel ?? runtimeModel;
+            const source = agentKeys.has(provider.envVar) ? '.env' : 'shell';
+            return { provider: provider.label, modelId, source };
+        }
+    }
+    return { provider: 'unknown', modelId: 'unknown', source: 'unknown' };
+}
+let _modelPromise = null;
+export function getModel() {
+    if (_modelPromise) {
+        return _modelPromise;
+    }
+    _modelPromise = (async () => {
+        const info = resolveModelInfo();
+        if (info.provider === 'unknown') {
+            throw new Error('No AI provider API key found in environment. ' +
+                'Set one of: ANTHROPIC_API_KEY, OPENAI_API_KEY, GOOGLE_GENERATIVE_AI_API_KEY, XAI_API_KEY, OPENROUTER_API_KEY');
+        }
+        const agentKeys = getAgentProviderKeys();
+        const sortedProviders = [
+            ...PROVIDERS.filter((p) => agentKeys.has(p.envVar)),
+            ...PROVIDERS.filter((p) => !agentKeys.has(p.envVar)),
+        ];
+        for (const provider of sortedProviders) {
+            const keyValue = process.env[provider.envVar];
+            if (keyValue && keyValue.trim().length > 0) {
+                const modelId = info.modelId;
+                const model = await provider.load(modelId);
+                return model;
+            }
+        }
+        throw new Error('Unreachable: resolveModelInfo succeeded but no provider found');
+    })();
+    return _modelPromise;
+}

package/dist/agent/objects.js

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

package/dist/agent/process-lifecycle.js

@@ -0,0 +1,18 @@
+import chalk from 'chalk';
+import { symbols } from './theme.js';
+const exitImmediately = (exitCode = 0) => {
+    process.exit(exitCode);
+};
+export function setupProcessLifecycle() {
+    // Unhandled rejection handler
+    process.on('unhandledRejection', (reason) => {
+        const raw = reason instanceof Error ? reason.message : String(reason);
+        const message = raw.length > 200 ? raw.slice(0, 200) + '\u2026' : raw;
+        console.error(chalk.red(`  ${symbols.cross} Unhandled: ${message}`));
+    });
+    // No alternate screen buffer — normal buffer allows terminal scrollback
+    // so users can scroll up to see historical poll activity.
+    // <Static> items from Ink flow into the scrollback naturally.
+    process.on('SIGINT', () => exitImmediately(0));
+    process.on('SIGTERM', () => exitImmediately(0));
+}