@jsonstudio/rcc 0.89.1968 → 0.89.2195

package/dist/server/runtime/http-server/stats-manager.js

@@ -3,7 +3,10 @@ import fsSync from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 import { buildInfo } from '../../../build-info.js';
+import { buildHistoricalProviderRow, buildSessionProviderRow, composeBucketKey, computeProviderTotals, extractToolCalls, formatProviderLabel, logHistoricalFromMemory, logProviderSummaryTable, logToolSummary, mergeSnapshotIntoHistorical, snapshotTools } from './stats-manager-internals.js';
 const DEFAULT_STATS_LOG_PATH = path.join(os.homedir(), '.routecodex', 'logs', 'provider-stats.jsonl');
+const DEFAULT_HISTORY_MAX_TAIL_BYTES = 8 * 1024 * 1024;
+const DEFAULT_HISTORY_MAX_LINES = 20000;
 function resolveBoolFromEnv(value, fallback) {
     if (!value) {
         return fallback;
@@ -23,6 +26,47 @@ function isStatsEnabledByDefault() {
 function isStatsVerboseEnabled(enabled) {
     return resolveBoolFromEnv(process.env.ROUTECODEX_STATS_VERBOSE ?? process.env.RCC_STATS_VERBOSE, enabled && buildInfo.mode !== 'release');
 }
+function resolvePositiveIntEnv(primary, secondary, fallback) {
+    const values = [primary, secondary];
+    for (const value of values) {
+        const parsed = Number(String(value || '').trim());
+        if (Number.isFinite(parsed) && parsed >= 1) {
+            return Math.floor(parsed);
+        }
+    }
+    return fallback;
+}
+function readTailLines(filePath, maxTailBytes, maxLines) {
+    let text = '';
+    const stat = fsSync.statSync(filePath);
+    if (!Number.isFinite(stat.size) || stat.size <= 0) {
+        return [];
+    }
+    if (stat.size <= maxTailBytes) {
+        text = fsSync.readFileSync(filePath, 'utf-8');
+    }
+    else {
+        const start = Math.max(0, stat.size - maxTailBytes);
+        const fd = fsSync.openSync(filePath, 'r');
+        try {
+            const length = stat.size - start;
+            const buffer = Buffer.alloc(length);
+            const read = fsSync.readSync(fd, buffer, 0, length, start);
+            text = buffer.toString('utf8', 0, read);
+            const firstNl = text.indexOf('\n');
+            if (firstNl >= 0) {
+                text = text.slice(firstNl + 1);
+            }
+        }
+        finally {
+            fsSync.closeSync(fd);
+        }
+    }
+    return text
+        .split(/\r?\n/)
+        .filter(Boolean)
+        .slice(-maxLines);
+}
 export class StatsManager {
     inflight = new Map();
     buckets = new Map();
@@ -52,9 +96,7 @@ export class StatsManager {
         if (!this.enabled || !requestId) {
             return;
         }
-        this.inflight.set(requestId, {
-            startTime: Date.now()
-        });
+        this.inflight.set(requestId, { startTime: Date.now() });
     }
     bindProvider(requestId, meta) {
         if (!this.enabled || !requestId) {
@@ -73,10 +115,7 @@ export class StatsManager {
             }
             return;
         }
-        this.inflight.set(requestId, {
-            startTime: Date.now(),
-            ...meta
-        });
+        this.inflight.set(requestId, { startTime: Date.now(), ...meta });
     }
     recordCompletion(requestId, options) {
         if (!this.enabled || !requestId) {
@@ -87,7 +126,7 @@ export class StatsManager {
         if (!sample?.providerKey) {
             return;
         }
-        const key = this.composeBucketKey(sample.providerKey, sample.model);
+        const key = composeBucketKey(sample.providerKey, sample.model);
         let bucket = this.buckets.get(key);
         if (!bucket) {
             const now = Date.now();
@@ -128,14 +167,14 @@ export class StatsManager {
         if (!providerKey) {
             return;
         }
-        const toolCalls = this.extractToolCalls(payload);
+        const toolCalls = extractToolCalls(payload);
         if (!toolCalls.length) {
             return;
         }
         const now = Date.now();
         this.totalToolCalls += toolCalls.length;
         this.totalToolResponses += 1;
-        const providerBucketKey = this.composeBucketKey(providerKey, meta.model);
+        const providerBucketKey = composeBucketKey(providerKey, meta.model);
         const providerTotals = this.toolProviderTotals.get(providerBucketKey) ?? {
             providerKey,
             model: meta.model,
@@ -190,26 +229,17 @@ export class StatsManager {
     }
     snapshot(uptimeMs) {
         if (!this.enabled) {
-            return {
-                generatedAt: Date.now(),
-                uptimeMs,
-                totals: []
-            };
-        }
-        const totals = Array.from(this.buckets.values()).map(bucket => ({
-            ...bucket,
-            averageLatencyMs: bucket.requestCount ? bucket.totalLatencyMs / bucket.requestCount : 0,
-            averagePromptTokens: bucket.requestCount ? bucket.totalPromptTokens / bucket.requestCount : 0,
-            averageCompletionTokens: bucket.requestCount ? bucket.totalCompletionTokens / bucket.requestCount : 0,
-            averageOutputTokens: bucket.requestCount ? bucket.totalOutputTokens / bucket.requestCount : 0
-        }));
-        const tools = this.snapshotTools();
-        return {
-            generatedAt: Date.now(),
-            uptimeMs,
-            totals,
-            ...(tools ? { tools } : {})
-        };
+            return { generatedAt: Date.now(), uptimeMs, totals: [] };
+        }
+        const totals = computeProviderTotals(this.buckets);
+        const tools = snapshotTools({
+            totalToolCalls: this.totalToolCalls,
+            totalToolResponses: this.totalToolResponses,
+            toolBuckets: this.toolBuckets,
+            toolBucketsByProvider: this.toolBucketsByProvider,
+            toolProviderTotals: this.toolProviderTotals
+        });
+        return { generatedAt: Date.now(), uptimeMs, totals, ...(tools ? { tools } : {}) };
     }
     logSummary(uptimeMs) {
         const snapshot = this.snapshot(uptimeMs);
@@ -217,7 +247,16 @@ export class StatsManager {
             return snapshot;
         }
         this.ensureHistoricalLoaded();
-        this.mergeSnapshotIntoHistorical(snapshot);
+        const merged = mergeSnapshotIntoHistorical({
+            snapshot,
+            historicalBuckets: this.historicalBuckets,
+            historicalToolAggregate: this.historicalToolAggregate,
+            historicalToolByProvider: this.historicalToolByProvider,
+            historicalSnapshotCount: this.historicalSnapshotCount,
+            historicalSampleCount: this.historicalSampleCount
+        });
+        this.historicalSnapshotCount = merged.historicalSnapshotCount;
+        this.historicalSampleCount = merged.historicalSampleCount;
         if (!this.verboseLogging) {
             return snapshot;
         }
@@ -226,8 +265,8 @@ export class StatsManager {
             return snapshot;
         }
         console.log('\n[Stats][session] Provider summary (uptime=%d ms · samples=%d)', Math.round(snapshot.uptimeMs), snapshot.totals.reduce((sum, bucket) => sum + bucket.requestCount, 0));
-        this.logProviderSummaryTable(snapshot.totals.map((bucket) => this.buildSessionProviderRow(bucket)), false);
-        this.logToolSummary(snapshot.tools);
+        logProviderSummaryTable(snapshot.totals.map((bucket) => buildSessionProviderRow(bucket)), false);
+        logToolSummary(snapshot.tools, formatProviderLabel);
         return snapshot;
     }
     async persistSnapshot(snapshot, options) {
@@ -248,9 +287,6 @@ export class StatsManager {
             console.warn('[Stats] Failed to persist provider stats snapshot', error);
         }
     }
-    /**
-     * 打印历史 provider-stats 聚合（内存中实时维护，异常退出前也能看到历史）。
-     */
     async logHistoricalSummary(options) {
         if (!this.enabled || !this.verboseLogging) {
             return;
@@ -261,25 +297,20 @@ export class StatsManager {
         else {
             this.ensureHistoricalLoaded();
         }
-        this.logHistoricalFromMemory();
+        logHistoricalFromMemory({
+            historicalBuckets: this.historicalBuckets,
+            historicalSnapshotCount: this.historicalSnapshotCount,
+            historicalSampleCount: this.historicalSampleCount,
+            historicalToolAggregate: this.historicalToolAggregate,
+            historicalToolByProvider: this.historicalToolByProvider
+        });
     }
     snapshotHistorical() {
         if (!this.enabled) {
-            return {
-                generatedAt: Date.now(),
-                snapshotCount: 0,
-                sampleCount: 0,
-                totals: []
-            };
+            return { generatedAt: Date.now(), snapshotCount: 0, sampleCount: 0, totals: [] };
         }
         this.ensureHistoricalLoaded();
-        const totals = Array.from(this.historicalBuckets.values()).map(bucket => ({
-            ...bucket,
-            averageLatencyMs: bucket.requestCount ? bucket.totalLatencyMs / bucket.requestCount : 0,
-            averagePromptTokens: bucket.requestCount ? bucket.totalPromptTokens / bucket.requestCount : 0,
-            averageCompletionTokens: bucket.requestCount ? bucket.totalCompletionTokens / bucket.requestCount : 0,
-            averageOutputTokens: bucket.requestCount ? bucket.totalOutputTokens / bucket.requestCount : 0
-        }));
+        const totals = computeProviderTotals(this.historicalBuckets);
         return {
             generatedAt: Date.now(),
             snapshotCount: this.historicalSnapshotCount,
@@ -287,416 +318,6 @@ export class StatsManager {
             totals
         };
     }
-    composeBucketKey(providerKey, model) {
-        return `${providerKey}|${model ?? '-'}`;
-    }
-    snapshotTools() {
-        if (this.totalToolCalls <= 0 && this.totalToolResponses <= 0) {
-            return undefined;
-        }
-        const byToolName = {};
-        for (const [name, bucket] of this.toolBuckets.entries()) {
-            byToolName[name] = { ...bucket };
-        }
-        const byProviderKey = {};
-        for (const [providerKey, providerTools] of this.toolBucketsByProvider.entries()) {
-            const totals = this.toolProviderTotals.get(providerKey);
-            const byTool = {};
-            for (const [name, bucket] of providerTools.entries()) {
-                byTool[name] = { ...bucket };
-            }
-            byProviderKey[providerKey] = {
-                providerKey: totals?.providerKey ?? providerKey,
-                model: totals?.model,
-                totalCalls: totals?.totalCalls ?? 0,
-                totalResponses: totals?.totalResponses ?? 0,
-                byToolName: byTool
-            };
-        }
-        return {
-            totalCalls: this.totalToolCalls,
-            totalResponses: this.totalToolResponses,
-            byToolName,
-            byProviderKey
-        };
-    }
-    logToolSummary(snapshot) {
-        if (!snapshot || snapshot.totalCalls <= 0) {
-            return;
-        }
-        console.log('\n[Stats] Tools:');
-        console.log('  total tool calls : %d (responses with tools=%d)', snapshot.totalCalls, snapshot.totalResponses);
-        const sorted = Object.values(snapshot.byToolName)
-            .sort((a, b) => b.callCount - a.callCount)
-            .slice(0, 10);
-        if (sorted.length) {
-            console.log('  top tools:');
-            for (const bucket of sorted) {
-                console.log('    %s → calls=%d responses=%d', bucket.toolName, bucket.callCount, bucket.responseCount);
-            }
-        }
-        const providerEntries = Object.values(snapshot.byProviderKey ?? {});
-        if (providerEntries.length) {
-            console.log('  by provider:');
-            const sortedProviders = providerEntries
-                .slice()
-                .sort((a, b) => b.totalCalls - a.totalCalls)
-                .slice(0, 10);
-            for (const provider of sortedProviders) {
-                const label = this.formatProviderLabel(provider.providerKey, provider.model);
-                console.log('    %s → calls=%d responses=%d', label, provider.totalCalls, provider.totalResponses);
-            }
-        }
-    }
-    logHistoricalToolSummary(toolAggregate, toolByProvider) {
-        if (toolAggregate.size === 0) {
-            return;
-        }
-        const totalCalls = Array.from(toolAggregate.values()).reduce((sum, bucket) => sum + bucket.callCount, 0);
-        const totalResponses = Array.from(toolAggregate.values()).reduce((sum, bucket) => sum + bucket.responseCount, 0);
-        console.log('\n[Stats] Historical tools summary (total calls=%d, responses with tools=%d)', totalCalls, totalResponses);
-        const sorted = Array.from(toolAggregate.values())
-            .sort((a, b) => b.callCount - a.callCount)
-            .slice(0, 10);
-        if (sorted.length) {
-            console.log('  top tools:');
-            for (const bucket of sorted) {
-                console.log('    %s → calls=%d responses=%d', bucket.toolName, bucket.callCount, bucket.responseCount);
-            }
-        }
-        if (toolByProvider.size) {
-            console.log('  by provider:');
-            const entries = Array.from(toolByProvider.entries()).sort((a, b) => a[0].localeCompare(b[0]));
-            for (const [, bucket] of entries) {
-                const label = this.formatProviderLabel(bucket.providerKey, bucket.model);
-                console.log('    %s → calls=%d responses=%d', label, bucket.totalCalls, bucket.totalResponses);
-            }
-        }
-    }
-    mergeToolAggregate(toolAggregate, toolByProvider, tools) {
-        for (const bucket of Object.values(tools.byToolName ?? {})) {
-            if (!bucket || !bucket.toolName) {
-                continue;
-            }
-            const existing = toolAggregate.get(bucket.toolName);
-            if (!existing) {
-                toolAggregate.set(bucket.toolName, { ...bucket });
-            }
-            else {
-                existing.callCount += bucket.callCount;
-                existing.responseCount += bucket.responseCount;
-                if (bucket.firstSeenAt < existing.firstSeenAt) {
-                    existing.firstSeenAt = bucket.firstSeenAt;
-                }
-                if (bucket.lastSeenAt > existing.lastSeenAt) {
-                    existing.lastSeenAt = bucket.lastSeenAt;
-                }
-            }
-        }
-        for (const providerRecord of Object.values(tools.byProviderKey ?? {})) {
-            if (!providerRecord || !providerRecord.providerKey) {
-                continue;
-            }
-            const providerKey = providerRecord.providerKey;
-            const bucketKey = this.composeBucketKey(providerKey, providerRecord.model);
-            const entry = toolByProvider.get(bucketKey) ?? {
-                providerKey,
-                model: providerRecord.model,
-                totalCalls: 0,
-                totalResponses: 0,
-                byToolName: new Map()
-            };
-            entry.totalCalls += providerRecord.totalCalls ?? 0;
-            entry.totalResponses += providerRecord.totalResponses ?? 0;
-            for (const toolBucket of Object.values(providerRecord.byToolName ?? {})) {
-                if (!toolBucket || !toolBucket.toolName) {
-                    continue;
-                }
-                const existing = entry.byToolName.get(toolBucket.toolName);
-                if (!existing) {
-                    entry.byToolName.set(toolBucket.toolName, { ...toolBucket });
-                }
-                else {
-                    existing.callCount += toolBucket.callCount;
-                    existing.responseCount += toolBucket.responseCount;
-                    if (toolBucket.firstSeenAt < existing.firstSeenAt) {
-                        existing.firstSeenAt = toolBucket.firstSeenAt;
-                    }
-                    if (toolBucket.lastSeenAt > existing.lastSeenAt) {
-                        existing.lastSeenAt = toolBucket.lastSeenAt;
-                    }
-                }
-            }
-            toolByProvider.set(bucketKey, entry);
-        }
-    }
-    extractToolCalls(payload) {
-        if (!payload || typeof payload !== 'object') {
-            return [];
-        }
-        const record = payload;
-        const calls = [];
-        const seenIds = new Set();
-        const addCall = (nameRaw, idRaw) => {
-            const name = typeof nameRaw === 'string' && nameRaw.trim() ? nameRaw.trim() : '';
-            if (!name) {
-                return;
-            }
-            const id = typeof idRaw === 'string' && idRaw.trim() ? idRaw.trim() : undefined;
-            if (id && seenIds.has(id)) {
-                return;
-            }
-            if (id) {
-                seenIds.add(id);
-            }
-            calls.push({ name, ...(id ? { id } : {}) });
-        };
-        const toolCalls = (record.tool_calls ??
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            record.required_action?.submit_tool_outputs?.tool_calls);
-        if (Array.isArray(toolCalls)) {
-            for (const toolCall of toolCalls) {
-                if (!toolCall || typeof toolCall !== 'object') {
-                    continue;
-                }
-                const toolRec = toolCall;
-                const fn = toolRec.function;
-                addCall(fn?.name ?? toolRec.name, toolRec.id ?? toolRec.call_id ?? toolRec.tool_call_id);
-            }
-        }
-        const output = record.output;
-        if (Array.isArray(output)) {
-            for (const entry of output) {
-                if (!entry || typeof entry !== 'object') {
-                    continue;
-                }
-                const node = entry;
-                const type = typeof node.type === 'string' ? node.type.trim().toLowerCase() : '';
-                if (type === 'function_call' || type === 'tool_call' || type === 'function') {
-                    addCall(node.name ?? node.tool_name ??
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                        node.function?.name, node.call_id ?? node.id);
-                }
-                if (Array.isArray(node.content)) {
-                    for (const contentItem of node.content) {
-                        if (!contentItem || typeof contentItem !== 'object') {
-                            continue;
-                        }
-                        const contentNode = contentItem;
-                        const contentType = typeof contentNode.type === 'string' ? contentNode.type.trim().toLowerCase() : '';
-                        if (contentType === 'tool_call' || contentType === 'function_call') {
-                            addCall(contentNode.name ?? contentNode.tool_name ??
-                                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                                contentNode.function?.name, contentNode.call_id ?? contentNode.id);
-                        }
-                    }
-                }
-            }
-        }
-        const choices = record.choices;
-        if (Array.isArray(choices)) {
-            for (const choice of choices) {
-                if (!choice || typeof choice !== 'object') {
-                    continue;
-                }
-                const message = choice.message;
-                if (!message || typeof message !== 'object') {
-                    continue;
-                }
-                const toolCallsNode = message.tool_calls;
-                if (Array.isArray(toolCallsNode)) {
-                    for (const toolCall of toolCallsNode) {
-                        if (!toolCall || typeof toolCall !== 'object') {
-                            continue;
-                        }
-                        const toolRec = toolCall;
-                        const fn = toolRec.function;
-                        addCall(fn?.name ?? toolRec.name, toolRec.id ?? toolRec.tool_call_id);
-                    }
-                }
-            }
-        }
-        return calls;
-    }
-    mergeSnapshotIntoHistorical(snapshot) {
-        if (!snapshot) {
-            return;
-        }
-        this.historicalSnapshotCount += 1;
-        const totals = Array.isArray(snapshot.totals) ? snapshot.totals : [];
-        let snapshotSamples = 0;
-        for (const bucket of totals) {
-            const key = this.composeBucketKey(bucket.providerKey, bucket.model);
-            const existing = this.historicalBuckets.get(key);
-            const promptTokens = bucket.totalPromptTokens ?? 0;
-            const completionTokens = bucket.totalCompletionTokens ?? 0;
-            const outputTokens = bucket.totalOutputTokens ?? 0;
-            const latency = bucket.totalLatencyMs ?? 0;
-            const firstAt = typeof bucket.firstRequestAt === 'number' ? bucket.firstRequestAt : Date.now();
-            const lastAt = typeof bucket.lastRequestAt === 'number' ? bucket.lastRequestAt : Date.now();
-            if (!existing) {
-                this.historicalBuckets.set(key, {
-                    providerKey: bucket.providerKey,
-                    providerType: bucket.providerType,
-                    model: bucket.model,
-                    requestCount: bucket.requestCount ?? 0,
-                    errorCount: bucket.errorCount ?? 0,
-                    totalLatencyMs: latency,
-                    totalPromptTokens: promptTokens,
-                    totalCompletionTokens: completionTokens,
-                    totalOutputTokens: outputTokens,
-                    firstRequestAt: firstAt,
-                    lastRequestAt: lastAt
-                });
-            }
-            else {
-                existing.requestCount += bucket.requestCount ?? 0;
-                existing.errorCount += bucket.errorCount ?? 0;
-                existing.totalLatencyMs += latency;
-                existing.totalPromptTokens += promptTokens;
-                existing.totalCompletionTokens += completionTokens;
-                existing.totalOutputTokens += outputTokens;
-                if (firstAt < existing.firstRequestAt) {
-                    existing.firstRequestAt = firstAt;
-                }
-                if (lastAt > existing.lastRequestAt) {
-                    existing.lastRequestAt = lastAt;
-                }
-            }
-            snapshotSamples += bucket.requestCount ?? 0;
-        }
-        this.historicalSampleCount += snapshotSamples;
-        if (snapshot.tools && typeof snapshot.tools === 'object') {
-            this.mergeToolAggregate(this.historicalToolAggregate, this.historicalToolByProvider, snapshot.tools);
-        }
-    }
-    logHistoricalFromMemory() {
-        if (!this.historicalBuckets.size) {
-            console.log('[Stats] No historical provider activity recorded');
-            return;
-        }
-        console.log('\n[Stats][historical] Provider summary (snapshots=%d · samples=%d)', this.historicalSnapshotCount, this.historicalSampleCount);
-        const sorted = Array.from(this.historicalBuckets.values()).sort((a, b) => a.providerKey.localeCompare(b.providerKey));
-        this.logProviderSummaryTable(sorted.map((bucket) => this.buildHistoricalProviderRow(bucket)), true);
-        this.logHistoricalToolSummary(this.historicalToolAggregate, this.historicalToolByProvider);
-    }
-    buildSessionProviderRow(bucket) {
-        const okCount = bucket.requestCount - bucket.errorCount;
-        return {
-            providerKey: this.normalizeCellValue(bucket.providerKey),
-            model: this.normalizeCellValue(bucket.model),
-            requests: String(bucket.requestCount),
-            ok: String(okCount),
-            err: String(bucket.errorCount),
-            avgLatencyMs: bucket.averageLatencyMs.toFixed(1),
-            avgTokens: this.formatAverageTokenTriple(bucket.averagePromptTokens, bucket.averageCompletionTokens, bucket.averageOutputTokens),
-            totalTokens: this.formatTotalTokenTriple(bucket.totalPromptTokens, bucket.totalCompletionTokens, bucket.totalOutputTokens)
-        };
-    }
-    buildHistoricalProviderRow(bucket) {
-        const okCount = bucket.requestCount - bucket.errorCount;
-        const avgLatency = bucket.requestCount ? bucket.totalLatencyMs / bucket.requestCount : 0;
-        const avgPrompt = bucket.requestCount ? bucket.totalPromptTokens / bucket.requestCount : 0;
-        const avgCompletion = bucket.requestCount ? bucket.totalCompletionTokens / bucket.requestCount : 0;
-        const avgTotal = bucket.requestCount ? bucket.totalOutputTokens / bucket.requestCount : 0;
-        return {
-            providerKey: this.normalizeCellValue(bucket.providerKey),
-            model: this.normalizeCellValue(bucket.model),
-            requests: String(bucket.requestCount),
-            ok: String(okCount),
-            err: String(bucket.errorCount),
-            avgLatencyMs: avgLatency.toFixed(1),
-            avgTokens: this.formatAverageTokenTriple(avgPrompt, avgCompletion, avgTotal),
-            totalTokens: this.formatTotalTokenTriple(bucket.totalPromptTokens, bucket.totalCompletionTokens, bucket.totalOutputTokens),
-            window: this.formatWindowRange(bucket.firstRequestAt, bucket.lastRequestAt)
-        };
-    }
-    logProviderSummaryTable(rows, includeWindow) {
-        if (!rows.length) {
-            return;
-        }
-        const columns = [
-            { key: 'providerKey', title: 'providerKey', align: 'left', maxWidth: 44 },
-            { key: 'model', title: 'model', align: 'left', maxWidth: 28 },
-            { key: 'requests', title: 'req', align: 'right' },
-            { key: 'ok', title: 'ok', align: 'right' },
-            { key: 'err', title: 'err', align: 'right' },
-            { key: 'avgLatencyMs', title: 'avgMs', align: 'right' },
-            { key: 'avgTokens', title: 'avgTok(i/o/t)', align: 'right', maxWidth: 22 },
-            { key: 'totalTokens', title: 'totTok(i/o/t)', align: 'right', maxWidth: 22 }
-        ];
-        if (includeWindow) {
-            columns.push({ key: 'window', title: 'window', align: 'left', maxWidth: 41 });
-        }
-        const widths = columns.map((column) => {
-            const maxCellLength = rows.reduce((maxLength, row) => {
-                const value = this.normalizeCellValue(row[column.key]);
-                const clipped = this.clipCellValue(value, column.maxWidth);
-                return Math.max(maxLength, clipped.length);
-            }, column.title.length);
-            if (typeof column.maxWidth === 'number' && column.maxWidth > 0) {
-                return Math.min(Math.max(column.title.length, maxCellLength), column.maxWidth);
-            }
-            return Math.max(column.title.length, maxCellLength);
-        });
-        console.log(this.renderTableRow(columns, widths, undefined, true));
-        console.log(this.renderTableSeparator(widths));
-        for (const row of rows) {
-            console.log(this.renderTableRow(columns, widths, row, false));
-        }
-    }
-    renderTableRow(columns, widths, row, isHeader) {
-        const cells = columns.map((column, index) => {
-            const value = isHeader
-                ? column.title
-                : this.normalizeCellValue(row?.[column.key]);
-            const clipped = this.clipCellValue(value, widths[index]);
-            return column.align === 'right'
-                ? clipped.padStart(widths[index], ' ')
-                : clipped.padEnd(widths[index], ' ');
-        });
-        return `  | ${cells.join(' | ')} |`;
-    }
-    renderTableSeparator(widths) {
-        return `  |-` + widths.map((width) => '-'.repeat(width)).join('-|-') + '-|';
-    }
-    clipCellValue(value, maxWidth) {
-        if (!Number.isFinite(maxWidth) || typeof maxWidth !== 'number' || maxWidth <= 0) {
-            return value;
-        }
-        if (value.length <= maxWidth) {
-            return value;
-        }
-        if (maxWidth <= 1) {
-            return '…';
-        }
-        if (maxWidth <= 3) {
-            return value.slice(0, maxWidth);
-        }
-        return `${value.slice(0, maxWidth - 1)}…`;
-    }
-    normalizeCellValue(value) {
-        if (value === undefined || value === null) {
-            return '-';
-        }
-        const normalized = String(value).trim();
-        return normalized.length ? normalized : '-';
-    }
-    formatAverageTokenTriple(prompt, completion, total) {
-        if (prompt === 0 && completion === 0 && total === 0) {
-            return '-';
-        }
-        return `${prompt.toFixed(1)}/${completion.toFixed(1)}/${total.toFixed(1)}`;
-    }
-    formatTotalTokenTriple(prompt, completion, total) {
-        if (prompt === 0 && completion === 0 && total === 0) {
-            return '-';
-        }
-        return `${prompt}/${completion}/${total}`;
-    }
-    formatWindowRange(firstAt, lastAt) {
-        return `${this.formatIso(firstAt)}→${this.formatIso(lastAt)}`;
-    }
     ensureHistoricalLoaded() {
         if (!this.enabled || this.historicalLoaded) {
             return;
@@ -712,12 +333,22 @@ export class StatsManager {
             this.historicalSampleCount = 0;
         }
         try {
-            const raw = fsSync.readFileSync(logPath, 'utf-8');
-            const lines = raw.split(/\r?\n/).filter(Boolean);
+            const maxTailBytes = resolvePositiveIntEnv(process.env.ROUTECODEX_STATS_HISTORY_MAX_TAIL_BYTES, process.env.RCC_STATS_HISTORY_MAX_TAIL_BYTES, DEFAULT_HISTORY_MAX_TAIL_BYTES);
+            const maxLines = resolvePositiveIntEnv(process.env.ROUTECODEX_STATS_HISTORY_MAX_LINES, process.env.RCC_STATS_HISTORY_MAX_LINES, DEFAULT_HISTORY_MAX_LINES);
+            const lines = readTailLines(logPath, maxTailBytes, maxLines);
             for (const line of lines) {
                 try {
                     const record = JSON.parse(line);
-                    this.mergeSnapshotIntoHistorical(record);
+                    const merged = mergeSnapshotIntoHistorical({
+                        snapshot: record,
+                        historicalBuckets: this.historicalBuckets,
+                        historicalToolAggregate: this.historicalToolAggregate,
+                        historicalToolByProvider: this.historicalToolByProvider,
+                        historicalSnapshotCount: this.historicalSnapshotCount,
+                        historicalSampleCount: this.historicalSampleCount
+                    });
+                    this.historicalSnapshotCount = merged.historicalSnapshotCount;
+                    this.historicalSampleCount = merged.historicalSampleCount;
                 }
                 catch {
                     continue;
@@ -725,7 +356,7 @@ export class StatsManager {
             }
         }
         catch {
-            // File missing or unreadable → treat as empty history.
+            // File missing or unreadable -> treat as empty history.
         }
         this.historicalLoaded = true;
     }
@@ -741,25 +372,6 @@ export class StatsManager {
         }
         return this.statsLogPath;
     }
-    formatProviderLabel(providerKey, model) {
-        const key = typeof providerKey === 'string' && providerKey.trim() ? providerKey.trim() : '-';
-        const modelId = typeof model === 'string' && model.trim() ? model.trim() : undefined;
-        if (modelId) {
-            return `${key} / ${modelId}`;
-        }
-        return key;
-    }
-    formatIso(value) {
-        if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0) {
-            return '-';
-        }
-        try {
-            return new Date(value).toISOString();
-        }
-        catch {
-            return '-';
-        }
-    }
     resolveLogPath(explicit) {
         if (explicit && explicit.trim()) {
             return explicit.trim();