@zhive/cli 0.5.0

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

@@ -0,0 +1,152 @@
+import chalk from 'chalk';
+import { colors, symbols } from '../../shared/theme.js';
+import { formatTime, formatTokenUsage } from '../../../shared/agent/utils.js';
+import { HIVE_FRONTEND_URL } from '../../../shared/config/constant.js';
+const time = (item) => chalk.gray.dim(`${formatTime(item.timestamp)} `);
+const onlineActivityFormatter = {
+    getText(item) {
+        return `${item.name} agent online \u2014 "${item.bio}"`;
+    },
+    getDetail(_item) {
+        return undefined;
+    },
+    format(item) {
+        const text = this.getText(item);
+        return [` ${time(item)}${chalk.hex(colors.honey)(symbols.hive)} ${chalk.white(text)}`];
+    },
+};
+const idelActivityFormatter = {
+    getText(item) {
+        return item.text;
+    },
+    getDetail(_item) {
+        return undefined;
+    },
+    format(item) {
+        return [` ${time(item)}${chalk.gray(`${symbols.circle} ${this.getText(item)}`)}`];
+    },
+};
+const errorActivityFormatter = {
+    getText(item) {
+        return item.errorMessage;
+    },
+    getDetail(_item) {
+        return undefined;
+    },
+    format(item) {
+        return [` ${time(item)}${chalk.hex(colors.red)(`${symbols.cross} ${this.getText(item)}`)}`];
+    },
+};
+const megathreadPostedActivityFormatter = {
+    getText(item) {
+        const sign = item.conviction >= 0 ? '+' : '';
+        return `[${sign}${item.conviction.toFixed(2)}%] "${item.summary}"`;
+    },
+    getDetail(item) {
+        return item.id.split('@')[0];
+    },
+    format(item) {
+        const lines = [];
+        const pad = ' '.repeat(13);
+        const cColor = colors.controversial;
+        const url = `${HIVE_FRONTEND_URL}/c/${item.projectId}/megathread/${item.timeframe}`;
+        const result = this.getText(item);
+        lines.push(`${pad}${chalk.hex(cColor)(symbols.diamond)} ${chalk.white(result)}`);
+        lines.push(`${' '.repeat(15)}${chalk.gray.dim(`url: ${url}`)}`);
+        return lines;
+    },
+};
+const megathreadErrorActivityFormatter = {
+    getText(item) {
+        return item.errorMessage;
+    },
+    getDetail(item) {
+        return item.id.split('@')[0];
+    },
+    format(item) {
+        const pad = ' '.repeat(13);
+        return [`${pad}${chalk.hex(colors.red)(`${symbols.cross} ${this.getText(item)}`)}`];
+    },
+};
+const megathreadActivityFormatter = {
+    getText(item) {
+        const projectTag = `c/${item.projectId}`;
+        return `${projectTag} \u00B7 ${item.timeframe} round`;
+    },
+    getDetail(item) {
+        return item.id.split('@')[0];
+    },
+    format(item) {
+        const mainLine = ` ${time(item)}${chalk.hex(colors.controversial)(symbols.hive)} ${chalk.hex(colors.controversial)(this.getText(item))}`;
+        const lines = [mainLine];
+        switch (item.status) {
+            case 'skipped': {
+                lines[0] += chalk.hex(colors.honey)(` ${symbols.diamondOpen} skipped`);
+                break;
+            }
+            case 'posted': {
+                lines.push(...megathreadPostedActivityFormatter.format(item));
+                break;
+            }
+            case 'error': {
+                lines.push(...megathreadErrorActivityFormatter.format(item));
+                break;
+            }
+            default:
+                break;
+        }
+        if (item.tokenUsage) {
+            const { input, output, tools } = formatTokenUsage(item.tokenUsage);
+            lines.push(`${' '.repeat(15)}${chalk.gray.dim(`${input} \u00b7 ${output}`)}`);
+            if (tools !== null) {
+                const toolCountInfo = `${tools} (${item.tokenUsage.toolCalls} calls)`;
+                lines.push(`${' '.repeat(15)}${chalk.gray.dim(toolCountInfo)}`);
+            }
+        }
+        return lines;
+    },
+};
+export const activityFormatter = {
+    getText(item) {
+        switch (item.type) {
+            case 'error':
+                return errorActivityFormatter.getText(item);
+            case 'idle':
+                return idelActivityFormatter.getText(item);
+            case 'megathread':
+                return megathreadActivityFormatter.getText(item);
+            case 'online':
+                return onlineActivityFormatter.getText(item);
+            default:
+                return '';
+        }
+    },
+    getDetail(item) {
+        switch (item.type) {
+            case 'error':
+                return errorActivityFormatter.getDetail(item);
+            case 'idle':
+                return idelActivityFormatter.getDetail(item);
+            case 'megathread':
+                return megathreadActivityFormatter.getDetail(item);
+            case 'online':
+                return onlineActivityFormatter.getDetail(item);
+            default:
+                return undefined;
+        }
+    },
+    format(item) {
+        switch (item.type) {
+            case 'error':
+                return errorActivityFormatter.format(item);
+            case 'idle':
+                return idelActivityFormatter.format(item);
+            case 'megathread':
+                return megathreadActivityFormatter.format(item);
+            case 'online':
+                return onlineActivityFormatter.format(item);
+            default:
+                return [];
+        }
+    },
+};

package/dist/commands/start/services/backtest/default-backtest-data.js

@@ -0,0 +1,200 @@
+/**
+ * Default backtest dataset bundled with the CLI.
+ * Contains 10 threads from Bitcoin, Ethereum, Solana, and Dogecoin.
+ */
+export const DEFAULT_BACKTEST_DATA = {
+    metadata: {
+        id: 'default',
+        name: 'Default Backtest Dataset',
+        created_at: '2026-02-26T00:00:00Z',
+    },
+    threads: [
+        {
+            project_id: 'ethereum',
+            project_name: 'Ethereum',
+            project_symbol: '$ETH',
+            project_categories: [
+                'smart-contract-platform',
+                'layer-1',
+                'ethereum-ecosystem',
+                'proof-of-stake-pos',
+                'world-liberty-financial-portfolio',
+            ],
+            project_description: 'Ethereum is a global, open-source platform for decentralized applications.',
+            text: 'Balaji Srinivasan describes a "Global Privacy Era" as crypto\'s third phase, where the next decade of Web3 focuses on protecting user data and financial sovereignty through strong encryption rather than scalability or speed. Ethereum is highlighted as part of this shift from fully transparent ledgers to more confidential, programmable computation.',
+            timestamp: '2025-12-31T20:00:00Z',
+            price_on_fetch: 2969.01,
+            price_on_eval: 2971.55,
+            citations: [{ title: '2006719380713869499' }, { title: '2006683920881037680' }],
+        },
+        {
+            project_id: 'solana',
+            project_name: 'Solana',
+            project_symbol: '$SOL',
+            project_categories: [
+                'smart-contract-platform',
+                'solana-ecosystem',
+                'layer-1',
+                'alleged-sec-securities',
+                'proof-of-stake-pos',
+                'made-in-usa',
+                'coinlist-launchpad',
+            ],
+            project_description: 'Solana is a high-performance Layer 1 blockchain designed for mass adoption by providing a fast, secure, and low-cost environment for decentralized applications.',
+            text: 'ORE partners with PrivacyCash to launch an official shielded pool on Solana, enabling live private transfers of ORE as a native store-of-value token. Builders also announce Pandora OS v2.0 with stealth transfers and one-time unlinkable addresses on Solana mainnet, signaling major new privacy initiatives on the network.',
+            timestamp: '2026-01-01T01:00:00Z',
+            price_on_fetch: 124.98,
+            price_on_eval: 124.94,
+            citations: [{ title: '2006787547519918102' }, { title: '2006787600028410119' }],
+        },
+        {
+            project_id: 'solana',
+            project_name: 'Solana',
+            project_symbol: '$SOL',
+            project_categories: [
+                'smart-contract-platform',
+                'solana-ecosystem',
+                'layer-1',
+                'alleged-sec-securities',
+                'proof-of-stake-pos',
+                'made-in-usa',
+                'coinlist-launchpad',
+            ],
+            project_description: 'Solana is a high-performance Layer 1 blockchain designed for mass adoption by providing a fast, secure, and low-cost environment for decentralized applications.',
+            text: 'Solana is introducing the c-spl confidential token standard in Q1 2026, enabling encrypted balances and native private transfers. This privacy infrastructure targets institutional adoption by allowing banks and enterprises to conduct confidential onchain transactions, potentially unlocking complex financial instruments for the $16B in Solana stablecoins.',
+            timestamp: '2026-01-01T06:00:00Z',
+            price_on_fetch: 125.06,
+            price_on_eval: 124.43,
+            citations: [{ title: '2006857900543848485' }, { title: '2006862849327435958' }],
+        },
+        {
+            project_id: 'bitcoin',
+            project_name: 'Bitcoin',
+            project_symbol: '$BTC',
+            project_categories: [
+                'smart-contract-platform',
+                'layer-1',
+                'proof-of-work-pow',
+                'bitcoin-ecosystem',
+            ],
+            project_description: "Bitcoin is the world's first decentralized cryptocurrency, created in 2009 by the pseudonymous Satoshi Nakamoto.",
+            text: 'BlackRock transferred 1,134 BTC (~$101.4M) and 7,255 ETH (~$22.1M) to Coinbase/ Coinbase Prime and is described as selling millions in crypto ahead of a key PMI data release. The move coincides with $2.2B in BTC and ETH options expiry, drawing market attention to potential selling pressure on Bitcoin and Ethereum.',
+            timestamp: '2026-01-01T19:00:00Z',
+            price_on_fetch: 88053,
+            price_on_eval: 88266,
+            citations: [{ title: '2007064336708354389' }, { title: '2007066963671924967' }],
+        },
+        {
+            project_id: 'solana',
+            project_name: 'Solana',
+            project_symbol: '$SOL',
+            project_categories: [
+                'smart-contract-platform',
+                'solana-ecosystem',
+                'layer-1',
+                'alleged-sec-securities',
+                'proof-of-stake-pos',
+                'made-in-usa',
+                'coinlist-launchpad',
+            ],
+            project_description: 'Solana is a high-performance Layer 1 blockchain designed for mass adoption by providing a fast, secure, and low-cost environment for decentralized applications.',
+            text: 'Tweets highlight Solana\'s active memecoin culture, with users trading and promoting tokens like $KITKAT, $wif, SolanaWhale, and Epileptic, and tools such as MemeMax and 24/7 "Solana Memecoin Hunting" communities emerging. References to Trump\'s 2025 Solana memecoin and expectations for 2026 ("Make Solana Memecoins great again") show sustained speculative interest and growing infrastructure around Solana memecoin trading.',
+            timestamp: '2026-01-02T01:00:00Z',
+            price_on_fetch: 126.59,
+            price_on_eval: 127.47,
+            citations: [{ title: '2007142205451055298' }, { title: '2007150298876522740' }],
+        },
+        {
+            project_id: 'dogecoin',
+            project_name: 'Dogecoin',
+            project_symbol: '$DOGE',
+            project_categories: [
+                'smart-contract-platform',
+                'meme-token',
+                'dog-themed-coins',
+                'elon-musk-inspired-coins',
+                'proof-of-work-pow',
+                '4chan-themed',
+            ],
+            project_description: 'Dogecoin is a cryptocurrency based on the popular "Doge" Internet meme and features a Shiba Inu on its logo.',
+            text: 'Tweets highlight growing focus on a proposed Bitwise Dogecoin ETF (ticker "BWOW"), emphasizing that it carries high risk, significant volatility, and potential for complete loss of investment, and is not registered under the 1940 Act. Market chatter also notes a January 9 final decision deadline for a Dogecoin ETF and rising Dogecoin price and open interest into 2026.',
+            timestamp: '2026-01-02T07:00:00Z',
+            price_on_fetch: 0.128493,
+            price_on_eval: 0.132792,
+            citations: [{ title: '2007168051129840065' }, { title: '2007118652018196634' }],
+        },
+        {
+            project_id: 'bitcoin',
+            project_name: 'Bitcoin',
+            project_symbol: '$BTC',
+            project_categories: [
+                'smart-contract-platform',
+                'layer-1',
+                'proof-of-work-pow',
+                'bitcoin-ecosystem',
+            ],
+            project_description: "Bitcoin is the world's first decentralized cryptocurrency, created in 2009 by the pseudonymous Satoshi Nakamoto.",
+            text: 'Bitcoin users mark Proof of Keys Day, coinciding with the 17th anniversary of the Genesis Block, by urging holders to withdraw BTC from exchanges into cold storage and verify self-custody. Tweets emphasize the slogan "Not your keys, not your coins" and frame the day as a security checkup for Bitcoin holdings.',
+            timestamp: '2026-01-02T15:00:00Z',
+            price_on_fetch: 89551,
+            price_on_eval: 90310,
+            citations: [{ title: '2007362498282901908' }, { title: '2007373924133417089' }],
+        },
+        {
+            project_id: 'solana',
+            project_name: 'Solana',
+            project_symbol: '$SOL',
+            project_categories: [
+                'smart-contract-platform',
+                'solana-ecosystem',
+                'layer-1',
+                'alleged-sec-securities',
+                'proof-of-stake-pos',
+                'made-in-usa',
+                'coinlist-launchpad',
+            ],
+            project_description: 'Solana is a high-performance Layer 1 blockchain designed for mass adoption by providing a fast, secure, and low-cost environment for decentralized applications.',
+            text: "Circle mints $750M USDC on Solana, marking the first injection of fresh USDC stablecoin liquidity on the network in 2026. This follows $56.25B USDC minted on Solana in 2025, reinforcing Solana's growing role as a major stablecoin and DeFi liquidity hub.",
+            timestamp: '2026-01-02T17:00:00Z',
+            price_on_fetch: 130.55,
+            price_on_eval: 131.54,
+            citations: [{ title: '2007386708032270424' }, { title: '2007383683783963093' }],
+        },
+        {
+            project_id: 'ethereum',
+            project_name: 'Ethereum',
+            project_symbol: '$ETH',
+            project_categories: [
+                'smart-contract-platform',
+                'layer-1',
+                'ethereum-ecosystem',
+                'proof-of-stake-pos',
+                'world-liberty-financial-portfolio',
+            ],
+            project_description: 'Ethereum is a global, open-source platform for decentralized applications.',
+            text: 'Ethereum spot ETFs record $174M in net inflows on Jan. 2, their strongest day since early December, after about $2B in outflows from November through December. Products from Grayscale and BlackRock lead the renewed institutional demand, signaling a shift back to risk-on sentiment for ETH in early 2026.',
+            timestamp: '2026-01-03T02:00:00Z',
+            price_on_fetch: 3129.52,
+            price_on_eval: 3114.78,
+            citations: [{ title: '2007536719055167799' }, { title: '2007492243502858607' }],
+        },
+        {
+            project_id: 'ethereum',
+            project_name: 'Ethereum',
+            project_symbol: '$ETH',
+            project_categories: [
+                'smart-contract-platform',
+                'layer-1',
+                'ethereum-ecosystem',
+                'proof-of-stake-pos',
+                'world-liberty-financial-portfolio',
+            ],
+            project_description: 'Ethereum is a global, open-source platform for decentralized applications.',
+            text: 'Ethereum set a new all-time high with about 2.2-2.23 million transactions processed in a single day around Dec 29, 2025, with several subsequent days near that level. This record onchain activity indicates strong and growing network demand and utility across DeFi, NFTs, and emerging L2 ecosystems amid ongoing upgrades.',
+            timestamp: '2026-01-03T03:00:00Z',
+            price_on_fetch: 3125.17,
+            price_on_eval: 3110.91,
+            citations: [{ title: '2007529962350207036' }, { title: '2007525811075665958' }],
+        },
+    ],
+};

package/dist/commands/start/services/backtest/fetch.js

@@ -0,0 +1,42 @@
+import { HiveClient } from '@zhive/sdk';
+import { extractErrorMessage } from '../../../../shared/agent/utils.js';
+/**
+ * Fetches locked threads from the API and converts them to BacktestData format.
+ * Only threads with price_on_eval are included (guaranteed by the API).
+ */
+export async function fetchBacktestThreads(limit, baseUrl) {
+    try {
+        const client = new HiveClient(baseUrl);
+        const threads = await client.getLockedThreads(limit);
+        const backtestThreads = threads
+            .filter((t) => t.price_on_eval !== undefined && t.price_on_eval !== null)
+            .map((t) => ({
+            project_id: t.project_id,
+            project_name: t.project_name,
+            project_symbol: t.project_symbol,
+            project_categories: t.project_categories,
+            project_description: t.project_description,
+            text: t.text,
+            timestamp: t.timestamp,
+            price_on_fetch: t.price_on_fetch,
+            price_on_eval: t.price_on_eval,
+            citations: t.citations,
+        }));
+        if (backtestThreads.length === 0) {
+            return { success: false, error: 'No resolved threads with price data found' };
+        }
+        const data = {
+            metadata: {
+                id: `api-${Date.now()}`,
+                name: `API fetch (${backtestThreads.length} threads)`,
+                created_at: new Date().toISOString(),
+            },
+            threads: backtestThreads,
+        };
+        return { success: true, data };
+    }
+    catch (error) {
+        const message = extractErrorMessage(error);
+        return { success: false, error: message };
+    }
+}

package/dist/commands/start/services/backtest/import.js

@@ -0,0 +1,109 @@
+import fs from 'fs-extra';
+import { z } from 'zod';
+import { extractErrorMessage } from '../../../../shared/agent/utils.js';
+/**
+ * Schema for validating imported JSON file.
+ */
+const citationSchema = z.object({
+    url: z.string().optional(),
+    title: z.string(),
+});
+const importThreadSchema = z.object({
+    project_id: z.string().min(1, 'project_id is required'),
+    project_name: z.string().min(1, 'project_name is required'),
+    text: z.string().min(1, 'text is required'),
+    timestamp: z.string().optional(),
+    price_on_fetch: z.number().positive('price_on_fetch must be positive'),
+    price_on_eval: z.number().positive('price_on_eval must be positive'),
+    project_symbol: z.string().optional(),
+    project_categories: z.array(z.string()).optional(),
+    project_description: z.string().optional(),
+    citations: z.array(citationSchema).optional(),
+});
+const importFileSchema = z.object({
+    name: z.string().optional(),
+    threads: z.array(importThreadSchema).min(1, 'At least one thread is required'),
+});
+/**
+ * Import and validate a backtest JSON file.
+ */
+export async function importBacktestFile(filePath) {
+    // Check if file exists
+    const exists = await fs.pathExists(filePath);
+    if (!exists) {
+        return { success: false, error: `File not found: ${filePath}` };
+    }
+    // Read file content
+    let content;
+    try {
+        content = await fs.readJson(filePath);
+    }
+    catch (err) {
+        const message = extractErrorMessage(err);
+        return { success: false, error: `Failed to parse JSON: ${message}` };
+    }
+    // Validate structure
+    const parseResult = importFileSchema.safeParse(content);
+    if (!parseResult.success) {
+        const issues = parseResult.error.issues
+            .map((issue) => `${issue.path.join('.')}: ${issue.message}`)
+            .join('; ');
+        return { success: false, error: `Validation failed: ${issues}` };
+    }
+    const importData = parseResult.data;
+    // Convert to BacktestThread format
+    const threads = importData.threads.map((t) => convertImportThread(t));
+    return {
+        success: true,
+        data: {
+            name: importData.name,
+            threads,
+        },
+    };
+}
+/**
+ * Convert an import thread to a BacktestThread.
+ */
+function convertImportThread(input) {
+    const thread = {
+        project_id: input.project_id,
+        project_name: input.project_name,
+        project_symbol: input.project_symbol,
+        project_categories: input.project_categories,
+        project_description: input.project_description,
+        text: input.text,
+        timestamp: input.timestamp ?? new Date().toISOString(),
+        price_on_fetch: input.price_on_fetch,
+        price_on_eval: input.price_on_eval,
+        citations: input.citations ?? [],
+    };
+    return thread;
+}
+/**
+ * Validate a single thread input (for interactive mode).
+ */
+export function validateThreadInput(input) {
+    const errors = [];
+    if (!input.project_id || input.project_id.trim() === '') {
+        errors.push('project_id is required');
+    }
+    if (!input.project_name || input.project_name.trim() === '') {
+        errors.push('project_name is required');
+    }
+    if (!input.text || input.text.trim() === '') {
+        errors.push('text is required');
+    }
+    if (typeof input.price_on_fetch !== 'number' || input.price_on_fetch <= 0) {
+        errors.push('price_on_fetch must be a positive number');
+    }
+    if (typeof input.price_on_eval !== 'number' || input.price_on_eval <= 0) {
+        errors.push('price_on_eval must be a positive number');
+    }
+    return errors;
+}
+/**
+ * Create a BacktestThread from validated input.
+ */
+export function createThread(input) {
+    return convertImportThread(input);
+}

package/dist/commands/start/services/backtest/index.js

@@ -0,0 +1,10 @@
+// Import
+export { importBacktestFile, validateThreadInput, createThread } from './import.js';
+// Storage
+export { DEFAULT_BACKTEST_ID, loadDefaultBacktest } from './storage.js';
+// Fetch
+export { fetchBacktestThreads } from './fetch.js';
+// Runner
+export { runBacktest } from './runner.js';
+// Results
+export { formatConviction, formatPercentage, getDirectionIndicator, formatThreadResult, formatSummary, getAccuracyGrade, buildTextReport, } from './results.js';

package/dist/commands/start/services/backtest/results.js

@@ -0,0 +1,113 @@
+/**
+ * Format a number with sign for display.
+ */
+export function formatConviction(value) {
+    const sign = value >= 0 ? '+' : '';
+    const formatted = `${sign}${value.toFixed(2)}%`;
+    return formatted;
+}
+/**
+ * Format a percentage for display.
+ */
+export function formatPercentage(value) {
+    const formatted = `${value.toFixed(1)}%`;
+    return formatted;
+}
+/**
+ * Get direction indicator.
+ */
+export function getDirectionIndicator(conviction) {
+    if (conviction > 0) {
+        return 'bullish';
+    }
+    if (conviction < 0) {
+        return 'bearish';
+    }
+    return 'neutral';
+}
+export function formatThreadResult(result) {
+    if (result.skipped) {
+        return {
+            index: result.thread_index + 1,
+            projectName: result.project_name,
+            predicted: 'SKIP',
+            actual: formatConviction(result.actual_price_change_percent),
+            direction: 'skipped',
+            error: '-',
+            summary: '(skipped)',
+            thread_text: result.thread_text,
+        };
+    }
+    const directionLabel = result.direction_correct ? 'correct' : 'incorrect';
+    return {
+        index: result.thread_index + 1,
+        projectName: result.project_name,
+        predicted: formatConviction(result.predicted_conviction),
+        actual: formatConviction(result.actual_price_change_percent),
+        direction: directionLabel,
+        error: result.absolute_error !== null ? result.absolute_error.toFixed(2) : '-',
+        summary: result.predicted_summary.slice(0, 200) + (result.predicted_summary.length > 200 ? '...' : ''),
+        thread_text: result.thread_text.slice(0, 100) + (result.thread_text.length > 100 ? '...' : ''),
+    };
+}
+export function formatSummary(result) {
+    return {
+        agentName: result.agent_name,
+        backtestId: result.backtest_id,
+        totalThreads: result.total_threads,
+        threadsPredicted: result.threads_predicted,
+        threadsSkipped: result.threads_skipped,
+        directionAccuracy: formatPercentage(result.direction_accuracy),
+        meanAbsoluteError: result.mean_absolute_error.toFixed(2),
+        runAt: new Date(result.run_at).toLocaleString(),
+    };
+}
+/**
+ * Get accuracy grade based on direction accuracy percentage.
+ */
+export function getAccuracyGrade(accuracy) {
+    if (accuracy >= 70) {
+        return { grade: 'A', color: 'green' };
+    }
+    if (accuracy >= 60) {
+        return { grade: 'B', color: 'green' };
+    }
+    if (accuracy >= 50) {
+        return { grade: 'C', color: 'honey' };
+    }
+    if (accuracy >= 40) {
+        return { grade: 'D', color: 'red' };
+    }
+    return { grade: 'F', color: 'red' };
+}
+/**
+ * Build a text report of the backtest results.
+ */
+export function buildTextReport(result) {
+    const lines = [];
+    const summary = formatSummary(result);
+    lines.push(`Backtest Results: ${summary.backtestId}`);
+    lines.push(`Agent: ${summary.agentName}`);
+    lines.push(`Run at: ${summary.runAt}`);
+    lines.push('');
+    lines.push('--- Summary ---');
+    lines.push(`Total threads: ${summary.totalThreads}`);
+    lines.push(`Predictions made: ${summary.threadsPredicted}`);
+    lines.push(`Skipped: ${summary.threadsSkipped}`);
+    lines.push(`Direction accuracy: ${summary.directionAccuracy}`);
+    lines.push(`Mean absolute error: ${summary.meanAbsoluteError}`);
+    lines.push('');
+    lines.push('--- Per-Thread Results ---');
+    for (const threadResult of result.thread_results) {
+        const formatted = formatThreadResult(threadResult);
+        const directionSymbol = formatted.direction === 'correct'
+            ? '[OK]'
+            : formatted.direction === 'skipped'
+                ? '[--]'
+                : '[XX]';
+        lines.push(`#${formatted.index} ${formatted.projectName}: Predicted ${formatted.predicted}, Actual ${formatted.actual} ${directionSymbol}`);
+        lines.push(`\tThread: ${formatted.thread_text}`);
+        lines.push(`\tSummary: ${formatted.summary}`);
+    }
+    return lines.join('\n');
+}