minovative-mind-cli 2.11.5 → 2.13.0

package/dist/services/swebench/sweBenchRunnerService.js

@@ -0,0 +1,618 @@
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { loadInstancesFromFile, filterInstances, appendPrediction, savePredictions, } from './instanceLoader.js';
+import { extractGitPatch, isGitRepository, resetWorkspaceRepo, cloneOrEnsureRepo, checkoutBaseCommit, } from './gitDiffExtractor.js';
+import { setApprovalMode } from '../agent-tools.js';
+import { executeSingleTurn } from '../agent.js';
+import { createSharedChatSession } from '../ai.js';
+import { AsyncInputHandler } from '../agent/inputHandler.js';
+import { getRecoveryMetrics, resetRecoveryMetrics } from '../metrics.js';
+export const DEFAULT_MODEL_NAME = 'minovative-mind-agent';
+export const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes per instance
+/**
+ * Formats a SWE-bench instance into a comprehensive problem prompt for the agent.
+ */
+export function buildInstancePrompt(instance) {
+    const parts = [
+        `You are an expert software engineer resolving an issue in the repository ${instance.repo}.`,
+        '',
+        '# Problem Statement',
+        instance.problem_statement.trim(),
+    ];
+    if (instance.hints_text && instance.hints_text.trim().length > 0) {
+        parts.push('', '# Hints', instance.hints_text.trim());
+    }
+    parts.push('', '# Instructions', '1. Investigate the repository to locate the relevant files, functions, and logic.', '2. Implement precise code edits to resolve the problem described above.', '3. Ensure your solution is clean, robust, and does not alter unrelated files or tests.');
+    return parts.join('\n');
+}
+import * as os from 'node:os';
+/**
+ * Resolves the workspace directory for an instance based on configuration.
+ */
+export function resolveInstanceWorkspaceDir(instance, options = {}) {
+    if (options.workspaceDirMap) {
+        if (options.workspaceDirMap[instance.instance_id]) {
+            return path.resolve(options.workspaceDirMap[instance.instance_id]);
+        }
+        if (options.workspaceDirMap[instance.repo]) {
+            return path.resolve(options.workspaceDirMap[instance.repo]);
+        }
+    }
+    const baseDir = options.workspacesBaseDir || (options.autoCloneRepos ? path.join(os.homedir(), '.cache', 'swe-bench-repos') : undefined);
+    if (baseDir) {
+        // Check if instance_id folder exists or repo name folder
+        const byId = path.resolve(baseDir, instance.instance_id);
+        if (fs.existsSync(byId)) {
+            return byId;
+        }
+        const sanitizedRepo = instance.repo.replace('/', '__');
+        const byRepo = path.resolve(baseDir, sanitizedRepo);
+        if (fs.existsSync(byRepo)) {
+            return byRepo;
+        }
+        return byRepo;
+    }
+    return options.defaultDir ? path.resolve(options.defaultDir) : process.cwd();
+}
+/**
+ * Default agent execution loop implementation running mmcli executeSingleTurn.
+ */
+async function defaultAgentExecutor(params) {
+    resetRecoveryMetrics();
+    const chat = createSharedChatSession();
+    const inputHandler = new AsyncInputHandler();
+    const chatSessionState = {
+        id: `swebench-${params.instance.instance_id}-${Date.now()}`,
+        title: `SWE-bench: ${params.instance.instance_id}`,
+        totalTokens: 0,
+        totalInputTokens: 0,
+        totalOutputTokens: 0,
+        totalCreditsUsed: 0,
+        latestUsageMetadata: undefined,
+    };
+    await executeSingleTurn(params.workspaceDir, params.prompt, chat, inputHandler, chatSessionState, false);
+    const cached = chatSessionState.latestUsageMetadata?.cachedTokens ||
+        chatSessionState.latestUsageMetadata?.cachedContentTokenCount ||
+        0;
+    const input = chatSessionState.totalInputTokens || 0;
+    const output = chatSessionState.totalOutputTokens || 0;
+    const total = chatSessionState.totalTokens || input + output;
+    const recoveryMetrics = getRecoveryMetrics();
+    return {
+        tokens: {
+            inputTokens: input,
+            outputTokens: output,
+            cachedTokens: cached,
+            totalTokens: total,
+        },
+        recoveryMetrics,
+    };
+}
+/**
+ * Executes the mmcli agent loop on a single SWE-bench instance and extracts the resulting patch.
+ */
+export async function runSWEBenchInstance(instance, options = {}) {
+    const startTime = Date.now();
+    const modelName = options.modelName || DEFAULT_MODEL_NAME;
+    const workspaceDir = options.workspaceDir ? path.resolve(options.workspaceDir) : process.cwd();
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const logs = [];
+    const log = (msg) => {
+        logs.push(`[${new Date().toISOString()}] ${msg}`);
+        if (options.onLog) {
+            options.onLog(msg);
+        }
+    };
+    log(`Starting evaluation on instance ${instance.instance_id} (${instance.repo})`);
+    let executionSuccess = false;
+    let turnCount = 0;
+    let executionError;
+    let instanceTokens;
+    let instanceRecoveryMetrics;
+    let patch = '';
+    try {
+        setApprovalMode('skip-all');
+        resetRecoveryMetrics();
+        // 1. Prepare Workspace (Auto-clone / Reset to base commit if requested)
+        let isRepo = await isGitRepository(workspaceDir);
+        if (!isRepo && options.autoCloneRepos && instance.repo) {
+            log(`Repository not found locally. Auto-cloning ${instance.repo} into ${workspaceDir}...`);
+            await cloneOrEnsureRepo(instance.repo, workspaceDir);
+            isRepo = true;
+        }
+        if (isRepo && instance.base_commit) {
+            if (options.resetWorkspace !== false) {
+                log(`Resetting workspace to base commit ${instance.base_commit}...`);
+                await checkoutBaseCommit(workspaceDir, instance.base_commit);
+                await resetWorkspaceRepo(workspaceDir);
+            }
+        }
+        // 2. Construct Problem Prompt
+        const prompt = buildInstancePrompt(instance);
+        // 3. Execute mmcli Agent Loop with Timeout (or skip if dryRun)
+        if (options.dryRun) {
+            log(`Dry run enabled - skipping agent execution loop`);
+            executionSuccess = true;
+        }
+        else {
+            log(`Executing agent loop for problem statement...`);
+            const executor = options.agentExecutor || defaultAgentExecutor;
+            const prevSkipVerification = process.env.MMCLI_SKIP_VERIFICATION;
+            process.env.MMCLI_SKIP_VERIFICATION = 'true';
+            try {
+                const executeWithTimeout = async () => {
+                    const execRes = await executor({
+                        instance,
+                        workspaceDir,
+                        prompt,
+                        abortSignal: options.abortSignal,
+                        onLog: options.onLog,
+                    });
+                    if (execRes && typeof execRes === 'object') {
+                        if ('tokens' in execRes && execRes.tokens) {
+                            instanceTokens = execRes.tokens;
+                        }
+                        if ('recoveryMetrics' in execRes && execRes.recoveryMetrics) {
+                            instanceRecoveryMetrics = execRes.recoveryMetrics;
+                        }
+                    }
+                    if (!instanceRecoveryMetrics) {
+                        instanceRecoveryMetrics = getRecoveryMetrics();
+                    }
+                    turnCount++;
+                };
+                const timeoutPromise = new Promise((_, reject) => {
+                    const timer = setTimeout(() => {
+                        reject(new Error(`Instance evaluation timed out after ${timeoutMs}ms`));
+                    }, timeoutMs);
+                    if (options.abortSignal) {
+                        options.abortSignal.addEventListener('abort', () => {
+                            clearTimeout(timer);
+                            reject(new Error('Instance evaluation aborted by signal'));
+                        });
+                    }
+                });
+                await Promise.race([executeWithTimeout(), timeoutPromise]);
+                executionSuccess = true;
+                log(`Agent execution completed successfully`);
+            }
+            finally {
+                if (prevSkipVerification !== undefined) {
+                    process.env.MMCLI_SKIP_VERIFICATION = prevSkipVerification;
+                }
+                else {
+                    delete process.env.MMCLI_SKIP_VERIFICATION;
+                }
+            }
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        executionError = msg;
+        log(`Agent execution failed: ${msg}`);
+    }
+    finally {
+        // 4. Extract Git Diff Patch
+        try {
+            const isRepo = await isGitRepository(workspaceDir);
+            if (isRepo) {
+                log(`Extracting git diff patch against base commit ${instance.base_commit || 'HEAD'}...`);
+                patch = await extractGitPatch(workspaceDir, {
+                    baseCommit: instance.base_commit,
+                    includeUntracked: true,
+                });
+                log(`Extracted patch size: ${patch.length} characters`);
+            }
+            else {
+                log(`Skipping patch extraction: workspace is not a git repository`);
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            log(`Failed to extract git diff patch: ${msg}`);
+            if (!executionError) {
+                executionError = `Patch extraction error: ${msg}`;
+            }
+        }
+    }
+    const prediction = {
+        instance_id: instance.instance_id,
+        model_patch: patch,
+        model_name_or_path: modelName,
+    };
+    return {
+        instance_id: instance.instance_id,
+        repo: instance.repo,
+        base_commit: instance.base_commit,
+        prediction,
+        success: executionSuccess && !executionError,
+        executionTimeMs: Date.now() - startTime,
+        diffSizeChars: patch.length,
+        turnCount,
+        tokens: instanceTokens,
+        recoveryMetrics: instanceRecoveryMetrics || getRecoveryMetrics(),
+        error: executionError,
+        logs,
+    };
+}
+/**
+ * Runs evaluation across a suite of SWE-bench instances.
+ */
+export async function runSWEBenchEvaluation(options) {
+    const startTime = Date.now();
+    const logger = options.logger || console;
+    // 1. Load instances
+    let instances = [];
+    if (options.instances && options.instances.length > 0) {
+        instances = filterInstances(options.instances, {
+            instanceIds: options.instanceIds,
+            repo: options.repo,
+            limit: options.limit,
+            offset: options.offset,
+            shuffle: options.shuffle,
+            seed: options.seed,
+        });
+    }
+    else if (options.instancesPath) {
+        instances = await loadInstancesFromFile(options.instancesPath, {
+            instanceIds: options.instanceIds,
+            repo: options.repo,
+            limit: options.limit,
+            offset: options.offset,
+            shuffle: options.shuffle,
+            seed: options.seed,
+        });
+    }
+    else {
+        throw new Error('Either `instances` array or `instancesPath` must be provided.');
+    }
+    const total = instances.length;
+    logger.info?.(`Loaded ${total} SWE-bench instances for evaluation`);
+    const results = [];
+    const concurrency = Math.max(1, options.concurrency || 1);
+    let completed = 0;
+    // 2. Execute instances with concurrency limit
+    const queue = [...instances];
+    async function worker() {
+        while (queue.length > 0) {
+            const instance = queue.shift();
+            if (!instance)
+                break;
+            const workspaceDir = resolveInstanceWorkspaceDir(instance, {
+                workspacesBaseDir: options.workspacesBaseDir,
+                workspaceDirMap: options.workspaceDirMap,
+                autoCloneRepos: options.autoCloneRepos,
+                defaultDir: process.cwd(),
+            });
+            options.onProgress?.({
+                completed,
+                total,
+                currentInstanceId: instance.instance_id,
+                status: 'running',
+                elapsedMs: Date.now() - startTime,
+            });
+            let result;
+            try {
+                result = await runSWEBenchInstance(instance, {
+                    workspaceDir,
+                    modelName: options.modelName,
+                    maxTurns: options.maxTurns,
+                    timeoutMs: options.timeoutMsPerInstance,
+                    resetWorkspace: options.resetWorkspaceBeforeRun,
+                    autoCloneRepos: options.autoCloneRepos,
+                    dryRun: options.dryRun,
+                    verbose: options.verbose,
+                    agentExecutor: options.agentExecutor,
+                    onLog: (msg) => {
+                        if (options.verbose) {
+                            logger.info?.(`[${instance.instance_id}] ${msg}`);
+                        }
+                        else {
+                            logger.debug?.(`[${instance.instance_id}] ${msg}`);
+                        }
+                    },
+                });
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                result = {
+                    instance_id: instance.instance_id,
+                    repo: instance.repo,
+                    base_commit: instance.base_commit,
+                    prediction: {
+                        instance_id: instance.instance_id,
+                        model_patch: '',
+                        model_name_or_path: options.modelName || DEFAULT_MODEL_NAME,
+                    },
+                    success: false,
+                    executionTimeMs: 0,
+                    diffSizeChars: 0,
+                    error: msg,
+                };
+            }
+            results.push(result);
+            completed++;
+            // Stream prediction to output file immediately if configured
+            if (options.outputPredictionsPath) {
+                try {
+                    await appendPrediction(result.prediction, options.outputPredictionsPath);
+                }
+                catch (err) {
+                    logger.warn?.(`Failed to append prediction to ${options.outputPredictionsPath}: ${err}`);
+                }
+            }
+            options.onInstanceComplete?.(result);
+            options.onProgress?.({
+                completed,
+                total,
+                currentInstanceId: instance.instance_id,
+                status: result.success ? 'success' : 'error',
+                elapsedMs: Date.now() - startTime,
+                error: result.error,
+            });
+            logger.info?.(`[${completed}/${total}] Instance ${instance.instance_id} finished: ${result.success ? 'SUCCESS' : 'FAILED'} (diff size: ${result.diffSizeChars} chars, time: ${(result.executionTimeMs / 1000).toFixed(1)}s)`);
+        }
+    }
+    const workers = Array.from({ length: concurrency }, () => worker());
+    await Promise.all(workers);
+    const succeeded = results.filter((r) => r.success).length;
+    const failed = results.filter((r) => !r.success).length;
+    const durationMs = Date.now() - startTime;
+    const metrics = calculateEvaluationMetrics(results, durationMs, options.modelName || DEFAULT_MODEL_NAME);
+    // Ensure full predictions file is saved cleanly if output path given
+    if (options.outputPredictionsPath) {
+        const predictions = results.map((r) => r.prediction);
+        await savePredictions(predictions, options.outputPredictionsPath);
+    }
+    const summary = {
+        total,
+        succeeded,
+        failed,
+        skipped: total - (succeeded + failed),
+        durationMs,
+        predictionsFilePath: options.outputPredictionsPath,
+        reportFilePath: options.reportPath,
+        metrics,
+        results,
+    };
+    if (options.reportPath) {
+        try {
+            await saveEvaluationReport(summary, options.reportPath);
+        }
+        catch (err) {
+            logger.warn?.(`Failed to write evaluation report to ${options.reportPath}: ${err}`);
+        }
+    }
+    return summary;
+}
+/**
+ * Computes aggregate metrics across SWE-bench evaluation results including token usage,
+ * repository pass rates, diff sizes, and timing statistics.
+ */
+export function calculateEvaluationMetrics(results, totalDurationMs, modelName = DEFAULT_MODEL_NAME) {
+    let totalTokens = 0;
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let totalCachedTokens = 0;
+    let totalDiffCharacters = 0;
+    let minDurationMs = results.length > 0 ? Infinity : 0;
+    let maxDurationMs = 0;
+    let totalCircuitBreakerTrips = 0;
+    let totalPrunedLines = 0;
+    let totalPrunedChars = 0;
+    const repoMap = {};
+    for (const res of results) {
+        if (res.tokens) {
+            totalTokens += res.tokens.totalTokens || 0;
+            totalInputTokens += res.tokens.inputTokens || 0;
+            totalOutputTokens += res.tokens.outputTokens || 0;
+            totalCachedTokens += res.tokens.cachedTokens || 0;
+        }
+        if (res.recoveryMetrics) {
+            totalCircuitBreakerTrips += res.recoveryMetrics.circuitBreakerTrips || 0;
+            totalPrunedLines += res.recoveryMetrics.prunedLines || 0;
+            totalPrunedChars += res.recoveryMetrics.prunedChars || 0;
+        }
+        totalDiffCharacters += res.diffSizeChars || 0;
+        if (res.executionTimeMs < minDurationMs)
+            minDurationMs = res.executionTimeMs;
+        if (res.executionTimeMs > maxDurationMs)
+            maxDurationMs = res.executionTimeMs;
+        const repoKey = res.repo || 'unknown';
+        if (!repoMap[repoKey]) {
+            repoMap[repoKey] = { total: 0, succeeded: 0, failed: 0, totalDurationMs: 0 };
+        }
+        repoMap[repoKey].total++;
+        if (res.success) {
+            repoMap[repoKey].succeeded++;
+        }
+        else {
+            repoMap[repoKey].failed++;
+        }
+        repoMap[repoKey].totalDurationMs += res.executionTimeMs;
+    }
+    if (minDurationMs === Infinity)
+        minDurationMs = 0;
+    const repoBreakdown = {};
+    for (const [repo, stats] of Object.entries(repoMap)) {
+        repoBreakdown[repo] = {
+            total: stats.total,
+            succeeded: stats.succeeded,
+            failed: stats.failed,
+            passRatePercent: stats.total > 0 ? Number(((stats.succeeded / stats.total) * 100).toFixed(1)) : 0,
+            averageDurationMs: stats.total > 0 ? Math.round(stats.totalDurationMs / stats.total) : 0,
+        };
+    }
+    const cacheHitRatePercent = totalInputTokens > 0 ? Number(((totalCachedTokens / totalInputTokens) * 100).toFixed(1)) : 0;
+    const platformName = process.platform === 'darwin'
+        ? 'Darwin (macOS)'
+        : process.platform === 'win32'
+            ? 'Windows'
+            : 'Linux';
+    const isAppleSilicon = process.platform === 'darwin' && process.arch === 'arm64';
+    return {
+        totalTokens,
+        totalInputTokens,
+        totalOutputTokens,
+        totalCachedTokens,
+        cacheHitRatePercent,
+        averageDurationMs: results.length > 0 ? Math.round(totalDurationMs / results.length) : 0,
+        minDurationMs,
+        maxDurationMs,
+        totalDiffCharacters,
+        averageDiffCharacters: results.length > 0 ? Math.round(totalDiffCharacters / results.length) : 0,
+        recoveryMetrics: {
+            totalCircuitBreakerTrips,
+            totalPrunedLines,
+            totalPrunedChars,
+        },
+        repoBreakdown,
+        environment: {
+            platform: isAppleSilicon ? `${platformName} (Apple Silicon)` : platformName,
+            architecture: process.arch,
+            nodeVersion: process.version,
+            modelName,
+            timestamp: new Date().toISOString(),
+        },
+    };
+}
+/**
+ * Saves a structured, public-ready evaluation report JSON file containing summary statistics,
+ * token economics, repository breakdown, and individual instance outcomes.
+ */
+export async function saveEvaluationReport(summary, reportPath) {
+    const resolved = path.resolve(reportPath);
+    await fs.promises.mkdir(path.dirname(resolved), { recursive: true });
+    const instances = summary.results.map((r) => ({
+        instance_id: r.instance_id,
+        repo: r.repo,
+        base_commit: r.base_commit,
+        success: r.success,
+        execution_time_seconds: Number((r.executionTimeMs / 1000).toFixed(1)),
+        diff_size_characters: r.diffSizeChars,
+        turn_count: r.turnCount ?? 1,
+        tokens: r.tokens
+            ? {
+                input: r.tokens.inputTokens,
+                output: r.tokens.outputTokens,
+                cached: r.tokens.cachedTokens,
+                total: r.tokens.totalTokens,
+            }
+            : undefined,
+        recovery_metrics: r.recoveryMetrics
+            ? {
+                circuit_breaker_trips: r.recoveryMetrics.circuitBreakerTrips,
+                pruned_log_lines: r.recoveryMetrics.prunedLines,
+                pruned_log_characters: r.recoveryMetrics.prunedChars,
+            }
+            : undefined,
+        error: r.error,
+    }));
+    const report = {
+        benchmark: 'SWE-bench Lite',
+        timestamp: summary.metrics?.environment.timestamp || new Date().toISOString(),
+        environment: summary.metrics?.environment,
+        summary: {
+            total_instances: summary.total,
+            succeeded: summary.succeeded,
+            failed: summary.failed,
+            skipped: summary.skipped,
+            success_rate_percent: summary.total > 0 ? Number(((summary.succeeded / summary.total) * 100).toFixed(1)) : 0,
+            total_duration_seconds: Number((summary.durationMs / 1000).toFixed(1)),
+            average_duration_seconds: summary.total > 0 ? Number((summary.durationMs / 1000 / summary.total).toFixed(1)) : 0,
+            total_diff_characters: summary.metrics?.totalDiffCharacters || 0,
+            average_patch_characters: summary.metrics?.averageDiffCharacters || 0,
+        },
+        recovery_metrics: summary.metrics?.recoveryMetrics
+            ? {
+                circuit_breaker_trips: summary.metrics.recoveryMetrics.totalCircuitBreakerTrips,
+                pruned_log_lines: summary.metrics.recoveryMetrics.totalPrunedLines,
+                pruned_log_characters: summary.metrics.recoveryMetrics.totalPrunedChars,
+            }
+            : undefined,
+        token_economics: summary.metrics
+            ? {
+                total_tokens: summary.metrics.totalTokens,
+                total_input_tokens: summary.metrics.totalInputTokens,
+                total_output_tokens: summary.metrics.totalOutputTokens,
+                total_cached_tokens: summary.metrics.totalCachedTokens,
+                cache_hit_rate_percent: summary.metrics.cacheHitRatePercent,
+            }
+            : undefined,
+        repository_breakdown: summary.metrics?.repoBreakdown || {},
+        instances,
+    };
+    await fs.promises.writeFile(resolved, JSON.stringify(report, null, 2), 'utf-8');
+}
+/**
+ * Formats a clean, high-impact ASCII terminal summary dashboard for SWE-bench evaluation runs.
+ */
+export function formatEvaluationReportSummary(summary) {
+    const m = summary.metrics;
+    const totalSec = (summary.durationMs / 1000).toFixed(1);
+    const avgSec = m
+        ? (m.averageDurationMs / 1000).toFixed(1)
+        : (summary.durationMs / 1000 / Math.max(1, summary.total)).toFixed(1);
+    const passRate = summary.total > 0 ? ((summary.succeeded / summary.total) * 100).toFixed(1) : '0.0';
+    const lines = [];
+    lines.push(`\n======================================================================`);
+    lines.push(`  🏆 MINOVATIVE MIND SWE-BENCH EVALUATION SUMMARY REPORT`);
+    lines.push(`======================================================================`);
+    lines.push(``);
+    lines.push(`📈 EXECUTION & RESOLUTION METRICS`);
+    lines.push(`  • Total Instances Evaluated : ${summary.total}`);
+    lines.push(`  • Succeeded Runs            : ${summary.succeeded} / ${summary.total} (${passRate}%)`);
+    lines.push(`  • Failed / Timed Out        : ${summary.failed}`);
+    if (summary.skipped > 0) {
+        lines.push(`  • Skipped                   : ${summary.skipped}`);
+    }
+    lines.push(`  • Total Duration            : ${totalSec}s`);
+    lines.push(`  • Average Time / Instance   : ${avgSec}s`);
+    if (m) {
+        lines.push(``);
+        lines.push(`💻 CODE GENERATION & PATCH METRICS`);
+        lines.push(`  • Total Diff Volume         : ${m.totalDiffCharacters.toLocaleString()} characters`);
+        lines.push(`  • Average Patch Size        : ${m.averageDiffCharacters.toLocaleString()} characters / instance`);
+        if (m.recoveryMetrics &&
+            (m.recoveryMetrics.totalCircuitBreakerTrips > 0 || m.recoveryMetrics.totalPrunedLines > 0)) {
+            lines.push(``);
+            lines.push(`🔧 RECOVERY & CIRCUIT BREAKER METRICS`);
+            lines.push(`  • Circuit Breaker Advisories: ${m.recoveryMetrics.totalCircuitBreakerTrips} interventions (prevented repetitive command loops)`);
+            lines.push(`  • Error Log Volume Pruned   : ${m.recoveryMetrics.totalPrunedLines.toLocaleString()} lines (${m.recoveryMetrics.totalPrunedChars.toLocaleString()} characters stripped)`);
+        }
+        if (m.totalTokens > 0) {
+            lines.push(``);
+            lines.push(`🪙 TOKEN USAGE & CONTEXT CACHING`);
+            lines.push(`  • Total Tokens Processed    : ${m.totalTokens.toLocaleString()}`);
+            lines.push(`  • Input Tokens              : ${m.totalInputTokens.toLocaleString()}`);
+            lines.push(`  • Output Tokens             : ${m.totalOutputTokens.toLocaleString()}`);
+            lines.push(`  • Cached Tokens             : ${m.totalCachedTokens.toLocaleString()} (${m.cacheHitRatePercent}% CACHE HIT)`);
+        }
+        const repos = Object.entries(m.repoBreakdown);
+        if (repos.length > 0) {
+            lines.push(``);
+            lines.push(`📂 REPOSITORY BREAKDOWN`);
+            lines.push(`  ┌──────────────────────────────┬────────────┬─────────────┬─────────────┐`);
+            lines.push(`  │ Repository                   │ Succeeded  │ Failed      │ Pass Rate   │`);
+            lines.push(`  ├──────────────────────────────┼────────────┼─────────────┼─────────────┤`);
+            for (const [repo, stat] of repos) {
+                const repoPadded = repo.padEnd(28).substring(0, 28);
+                const succPadded = `${stat.succeeded} / ${stat.total}`.padEnd(10);
+                const failPadded = `${stat.failed}`.padEnd(11);
+                const ratePadded = `${stat.passRatePercent}%`.padEnd(11);
+                lines.push(`  │ ${repoPadded} │ ${succPadded} │ ${failPadded} │ ${ratePadded} │`);
+            }
+            lines.push(`  └──────────────────────────────┴────────────┴─────────────┴─────────────┘`);
+        }
+    }
+    lines.push(``);
+    lines.push(`📁 ARTIFACTS`);
+    if (summary.predictionsFilePath) {
+        lines.push(`  • Predictions File : ${summary.predictionsFilePath}`);
+    }
+    if (summary.reportFilePath) {
+        lines.push(`  • Detailed Report  : ${summary.reportFilePath}`);
+    }
+    lines.push(`======================================================================\n`);
+    return lines.join('\n');
+}