@zhive/cli 0.6.7 → 0.6.8

package/dist/commands/indicator/commands/bollinger.js

@@ -0,0 +1,37 @@
+import { Command } from 'commander';
+import { InsufficientDataError } from '../../../shared/ta/error.js';
+import { getBollingerBands } from '../../../shared/ta/service.js';
+import { styled } from '../../shared/theme.js';
+export const createBollingerCommand = () => {
+    return new Command('bollinger')
+        .description(`Compute bollinger bands of given project's price`)
+        .requiredOption('--project <project>', 'Project id')
+        .option('--period <period>', 'bollinger bands period. Defaults to 20')
+        .option('--interval <interval>', 'ohlc interval. valid options are [hourly, daily]')
+        .action(async (options) => {
+        const { project, period: periodStr = '20', interval = 'hourly' } = options;
+        let period = Number(periodStr);
+        if (Number.isNaN(period)) {
+            console.log(styled.white(`Invalid period ${periodStr}. override to 20`));
+            period = 20;
+        }
+        try {
+            const bbResult = await getBollingerBands({
+                project,
+                interval,
+                period,
+                from: new Date(),
+                to: new Date(),
+            });
+            const last = bbResult.at(-1) ?? {};
+            console.log(styled.white(JSON.stringify(last)));
+        }
+        catch (e) {
+            if (e instanceof InsufficientDataError) {
+                console.log(styled.red(`Insufficient data: got ${e.got} data points but need at least ${e.required} for Bollinger Bands(${period}).`));
+                return;
+            }
+            console.log(styled.red(`Failed to fetch bollinger bands value`));
+        }
+    });
+};

package/dist/commands/indicator/commands/ema.js

@@ -0,0 +1,37 @@
+import { Command } from 'commander';
+import { InsufficientDataError } from '../../../shared/ta/error.js';
+import { getEMA } from '../../../shared/ta/service.js';
+import { styled } from '../../shared/theme.js';
+export const createEmaCommand = () => {
+    return new Command('ema')
+        .description(`Compute ema of given project's price`)
+        .requiredOption('--project <project>', 'Project id')
+        .option('--period <period>', 'ema period. Defaults to 12')
+        .option('--interval <interval>', 'ohlc interval. valid options are [hourly, daily]')
+        .action(async (options) => {
+        const { project, period: periodStr = '12', interval = 'hourly' } = options;
+        let period = Number(periodStr);
+        if (Number.isNaN(period)) {
+            console.log(styled.white(`Invalid period ${periodStr}. override to 12`));
+            period = 12;
+        }
+        try {
+            const emaResult = await getEMA({
+                project,
+                interval,
+                period,
+                from: new Date(),
+                to: new Date(),
+            });
+            const last = emaResult?.at(-1) ?? {};
+            console.log(styled.white(JSON.stringify(last)));
+        }
+        catch (e) {
+            if (e instanceof InsufficientDataError) {
+                console.log(styled.red(`Insufficient data: got ${e.got} data points but need at least ${e.required} for EMA${period}.`));
+                return;
+            }
+            console.log(styled.red(`Failed to fetch ema value`));
+        }
+    });
+};

package/dist/commands/indicator/commands/index.js

@@ -0,0 +1,14 @@
+import { Command } from 'commander';
+import { createBollingerCommand } from './bollinger.js';
+import { createEmaCommand } from './ema.js';
+import { createMacdCommand } from './macd.js';
+import { createRsiCommand } from './rsi.js';
+import { createSmaCommand } from './sma.js';
+export const createIndicatorCommand = () => {
+    return new Command('indicator')
+        .addCommand(createRsiCommand())
+        .addCommand(createSmaCommand())
+        .addCommand(createEmaCommand())
+        .addCommand(createMacdCommand())
+        .addCommand(createBollingerCommand());
+};

package/dist/commands/indicator/commands/macd.js

@@ -0,0 +1,51 @@
+import { Command } from 'commander';
+import { InsufficientDataError } from '../../../shared/ta/error.js';
+import { getMACD } from '../../../shared/ta/service.js';
+import { styled } from '../../shared/theme.js';
+export const createMacdCommand = () => {
+    return new Command('macd')
+        .description(`Compute macd of given project's price`)
+        .requiredOption('--project <project>', 'Project id')
+        .option('--fast <fast>', 'fast ema period. Defaults to 12')
+        .option('--slow <slow>', 'slow ema period. Defaults to 26')
+        .option('--signal <signal>', 'signal line period. Defaults to 9')
+        .option('--interval <interval>', 'ohlc interval. valid options are [hourly, daily]')
+        .action(async (options) => {
+        const { project, fast: fastStr = '12', slow: slowStr = '26', signal: signalStr = '9', interval = 'hourly', } = options;
+        let fast = Number(fastStr);
+        if (Number.isNaN(fast)) {
+            console.log(styled.white(`Invalid fast period ${fastStr}. override to 12`));
+            fast = 12;
+        }
+        let slow = Number(slowStr);
+        if (Number.isNaN(slow)) {
+            console.log(styled.white(`Invalid slow period ${slowStr}. override to 26`));
+            slow = 26;
+        }
+        let signal = Number(signalStr);
+        if (Number.isNaN(signal)) {
+            console.log(styled.white(`Invalid signal period ${signalStr}. override to 9`));
+            signal = 9;
+        }
+        try {
+            const macdResult = await getMACD({
+                project,
+                interval,
+                fast,
+                slow,
+                signal,
+                from: new Date(),
+                to: new Date(),
+            });
+            const last = macdResult?.at(-1) ?? {};
+            console.log(styled.white(JSON.stringify(last)));
+        }
+        catch (e) {
+            if (e instanceof InsufficientDataError) {
+                console.log(styled.red(`Insufficient data: got ${e.got} data points but need at least ${e.required} for MACD(${fast},${slow},${signal}).`));
+                return;
+            }
+            console.log(styled.red(`Failed to fetch macd value`));
+        }
+    });
+};

package/dist/commands/indicator/commands/rsi.js

@@ -0,0 +1,37 @@
+import { Command } from 'commander';
+import { InsufficientDataError } from '../../../shared/ta/error.js';
+import { getRSI } from '../../../shared/ta/service.js';
+import { styled } from '../../shared/theme.js';
+export const createRsiCommand = () => {
+    return new Command('rsi')
+        .description(`Compute rsi of given project's price`)
+        .requiredOption('--project <project>', 'Project id')
+        .option('--period <period>', 'rsi period. Defaults to 14')
+        .option('--interval <interval>', 'ohlc interval. valid options are [hourly, daily]')
+        .action(async (options) => {
+        const { project, period: periodStr = '14', interval = 'hourly' } = options;
+        let period = Number(periodStr);
+        if (Number.isNaN(period)) {
+            console.log(styled.white(`Invalid period ${periodStr}. override to 14`));
+            period = 14;
+        }
+        try {
+            const rsi = await getRSI({
+                project,
+                interval,
+                period,
+                from: new Date(),
+                to: new Date(),
+            });
+            const last = rsi.at(-1) ?? {};
+            console.log(styled.white(JSON.stringify(last)));
+        }
+        catch (e) {
+            if (e instanceof InsufficientDataError) {
+                console.log(styled.red(`Insufficient data: got ${e.got} data points but need at least ${e.required} for RSI${period}.`));
+                return;
+            }
+            console.log(styled.red(`Failed to fetch rsi value`));
+        }
+    });
+};

package/dist/commands/indicator/commands/sma.js

@@ -0,0 +1,37 @@
+import { Command } from 'commander';
+import { InsufficientDataError } from '../../../shared/ta/error.js';
+import { getSMA } from '../../../shared/ta/service.js';
+import { styled } from '../../shared/theme.js';
+export const createSmaCommand = () => {
+    return new Command('sma')
+        .description(`Compute sma of given project's price`)
+        .requiredOption('--project <project>', 'Project id')
+        .option('--period <period>', 'sma period. Defaults to 20')
+        .option('--interval <interval>', 'ohlc interval. valid options are [hourly, daily]')
+        .action(async (options) => {
+        const { project, period: periodStr = '20', interval = 'hourly' } = options;
+        let period = Number(periodStr);
+        if (Number.isNaN(period)) {
+            console.log(styled.white(`Invalid period ${periodStr}. override to 20`));
+            period = 20;
+        }
+        try {
+            const sma = await getSMA({
+                project,
+                interval,
+                period,
+                from: new Date(),
+                to: new Date(),
+            });
+            const last = sma.at(-1) ?? {};
+            console.log(styled.white(JSON.stringify(last)));
+        }
+        catch (e) {
+            if (e instanceof InsufficientDataError) {
+                console.log(styled.red(`Insufficient data: got ${e.got} data points but need at least ${e.required} for SMA${period}.`));
+                return;
+            }
+            console.log(styled.red(`Failed to fetch sma value`));
+        }
+    });
+};

package/dist/commands/market/commands/index.js

@@ -0,0 +1,5 @@
+import { Command } from 'commander';
+import { createPriceCommand } from './price.js';
+export const createMarketCommand = () => {
+    return new Command('market').addCommand(createPriceCommand());
+};

package/dist/commands/market/commands/price.js

@@ -0,0 +1,25 @@
+import { Command } from 'commander';
+import { getMarketClient } from '../../../shared/agent/tools/market/client.js';
+import { styled } from '../../shared/theme.js';
+export const createPriceCommand = () => {
+    return new Command('price')
+        .description(`Get current price of a given project`)
+        .requiredOption('--project <project>', 'Project id')
+        .action(async (options) => {
+        const { project } = options;
+        try {
+            const client = getMarketClient();
+            const priceData = await client.getPrice(project, new Date());
+            if (priceData.price === null) {
+                console.log(styled.white(JSON.stringify({})));
+                return;
+            }
+            const result = { price: priceData.price, timestamp: priceData.timestamp };
+            console.log(styled.white(JSON.stringify(result)));
+        }
+        catch (e) {
+            const message = e instanceof Error ? e.message : 'Failed to fetch price';
+            console.log(styled.red(message));
+        }
+    });
+};

package/dist/commands/shared/utils.js

@@ -0,0 +1,12 @@
+import { scanAgents } from '../../shared/config/agent.js';
+import { styled, symbols } from './theme.js';
+export const printAgentNotFoundHelper = async (agentName) => {
+    const agents = await scanAgents();
+    if (agents.length === 0) {
+        console.error(styled.red(`${symbols.cross} No agents found. Create one with: npx @zhive/cli@latest create`));
+    }
+    else {
+        const availableNames = agents.map((a) => a.name).join(', ');
+        console.error(styled.red(`${symbols.cross} Agent "${agentName}" not found. Available agents: ${availableNames}`));
+    }
+};

package/dist/commands/start/ui/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 { animation, colors } from '../../shared/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/index.js

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

package/dist/services/agent/analysis.js

@@ -0,0 +1,160 @@
+import { generateText, Output, ToolLoopAgent } from 'ai';
+import { z } from 'zod';
+import { buildAnalystPrompt, buildMegathreadPrompt } from './prompts/prompt.js';
+import { loadMemory, saveMemory, getMemoryLineCount, MEMORY_SOFT_LIMIT, } from '@hive-org/sdk';
+import { buildMemoryExtractionPrompt } from './prompts/memory-prompt.js';
+import { stripCodeFences } from './helpers.js';
+import { getModel } from './helpers/model.js';
+// ─── Cache Helpers ─────────────────────────────────
+function cacheableSystem(content) {
+    const message = {
+        role: 'system',
+        content,
+        providerOptions: {
+            anthropic: { cacheControl: { type: 'ephemeral' } },
+        },
+    };
+    return message;
+}
+// ─── 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(2000)
+        .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 two 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. 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.'),
+});
+const megathreadPredictionSchema = z.object({
+    skip: z
+        .boolean()
+        .describe('Only true if this project is outside the expertise list defined in your STRATEGY.md.'),
+    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 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. 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;
+}
+// ─── Signal Analysis ────────────────────────────────
+export async function processSignalAndSummarize(thread, recentComments, memory, soulContent, strategyContent, tools = {}, availableSkills) {
+    const promptOptions = {
+        threadText: thread.text,
+        projectId: thread.project_id,
+        timestamp: thread.timestamp,
+        priceOnFetch: thread.price_on_fetch,
+        citations: thread.citations,
+        recentPosts: recentComments,
+        memory,
+        availableSkills,
+    };
+    const { system, prompt } = buildAnalystPrompt(soulContent, strategyContent, promptOptions);
+    const model = await getModel();
+    const agent = new ToolLoopAgent({
+        model,
+        instructions: cacheableSystem(system),
+        output: Output.object({ schema: predictionSchema }),
+        tools,
+    });
+    const res = await agent.generate({ prompt });
+    const usage = buildUsage(res);
+    const { output } = res;
+    if (!output) {
+        return { skip: true, summary: '', conviction: 0, usage };
+    }
+    const prediction = output;
+    const skip = prediction.skip ?? false;
+    const summary = prediction.summary ?? '';
+    const conviction = prediction.conviction ?? 0;
+    return { skip, summary, conviction, usage };
+}
+// ─── Megathread Round Analysis ──────────────────────
+export async function processMegathreadRound(projectId, durationMs, recentComments, memory, soulContent, strategyContent, tools = {}, availableSkills, priceAtStart, currentPrice) {
+    const promptOptions = {
+        projectId,
+        durationMs,
+        priceAtStart,
+        currentPrice,
+        recentPosts: recentComments,
+        memory,
+        availableSkills,
+    };
+    const { system, prompt } = buildMegathreadPrompt(soulContent, strategyContent, promptOptions);
+    const model = await getModel();
+    const agent = new ToolLoopAgent({
+        model,
+        instructions: cacheableSystem(system),
+        output: Output.object({ schema: megathreadPredictionSchema }),
+        tools,
+    });
+    const res = await agent.generate({ prompt });
+    const usage = buildUsage(res);
+    const { output } = res;
+    if (!output) {
+        return { skip: true, summary: '', conviction: 0, usage };
+    }
+    const prediction = output;
+    const skip = prediction.skip ?? false;
+    const summary = prediction.summary ?? '';
+    const conviction = prediction.conviction ?? 0;
+    return { skip, 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,
+            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/services/agent/config.js

@@ -0,0 +1,75 @@
+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;
+}
+const VALID_SENTIMENTS = [
+    'very-bullish',
+    'bullish',
+    'neutral',
+    'bearish',
+    'very-bearish',
+];
+const VALID_TIMEFRAMES = ['1h', '4h', '24h'];
+function parseSentiment(raw) {
+    if (raw !== null && VALID_SENTIMENTS.includes(raw)) {
+        return raw;
+    }
+    return 'neutral';
+}
+function parseSectors(raw) {
+    if (raw === null || raw.trim() === '') {
+        return [];
+    }
+    const sectors = raw
+        .split(',')
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+    return sectors;
+}
+function parseTimeframes(raw) {
+    if (raw === null || raw.trim() === '') {
+        return ['1h', '4h', '24h'];
+    }
+    const parsed = raw
+        .split(',')
+        .map((t) => t.trim())
+        .filter((t) => VALID_TIMEFRAMES.includes(t));
+    if (parsed.length === 0) {
+        return ['1h', '4h', '24h'];
+    }
+    return parsed;
+}
+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 sentimentRaw = extractField(strategyContent, /^-\s+Bias:\s+(.+)$/m);
+    const sectorsRaw = extractField(strategyContent, /^-\s+Sectors:\s+(.+)$/m);
+    const timeframesRaw = extractField(strategyContent, /^-\s+Active timeframes:\s+(.+)$/m);
+    const agentProfile = {
+        sentiment: parseSentiment(sentimentRaw),
+        sectors: parseSectors(sectorsRaw),
+        timeframes: parseTimeframes(timeframesRaw),
+    };
+    return { name, bio, avatarUrl, soulContent, strategyContent, agentProfile };
+}

package/dist/services/agent/env.js

@@ -0,0 +1,30 @@
+import { readFileSync } from 'fs';
+import { AI_PROVIDER_ENV_VARS } from '../ai-providers.js';
+let _agentProviderKeys = new Set();
+/**
+ * Provider env-var names declared in the agent's .env file.
+ * Used by getModel() to prioritize the agent's chosen provider
+ * over keys inherited from the shell.
+ */
+export function getAgentProviderKeys() {
+    return _agentProviderKeys;
+}
+/**
+ * Load the agent's .env with provider-key priority.
+ *
+ * 1. Parse .env to discover which provider keys the agent declared.
+ * 2. Load .env with override so the agent's values win for the same key.
+ * 3. getModel() uses getAgentProviderKeys() to check those providers first,
+ *    falling back to shell-inherited keys if the agent has none.
+ */
+export async function loadAgentEnv() {
+    try {
+        const content = readFileSync('.env', 'utf-8');
+        _agentProviderKeys = new Set(AI_PROVIDER_ENV_VARS.filter((key) => new RegExp(`^${key}=`, 'm').test(content)));
+    }
+    catch {
+        _agentProviderKeys = new Set();
+    }
+    const { config } = await import('dotenv');
+    config({ override: true });
+}