@blockrun/franklin 3.0.0

package/dist/session/search.js

@@ -0,0 +1,229 @@
+/**
+ * Session search — find past conversations by keyword.
+ *
+ * Inspired by Hermes Agent's FTS5 search (`hermes_state.py`). For RunCode's
+ * scale (last 20 sessions) we use a lightweight in-memory tokenized search
+ * instead of SQLite FTS5 — zero install cost, same user experience.
+ */
+import fs from 'node:fs';
+import { listSessions, getSessionFilePath } from './storage.js';
+// ─── Tokenization ─────────────────────────────────────────────────────────
+function tokenize(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^\w\s]/g, ' ')
+        .split(/\s+/)
+        .filter(t => t.length > 1);
+}
+function parseQuery(query) {
+    const phrases = [];
+    // Extract quoted phrases first
+    const cleaned = query.replace(/"([^"]+)"/g, (_, phrase) => {
+        phrases.push(phrase.toLowerCase());
+        return ' ';
+    });
+    const terms = tokenize(cleaned);
+    return { terms, phrases };
+}
+// ─── Snippet Extraction ───────────────────────────────────────────────────
+function extractSnippet(content, query, maxLen = 200) {
+    const lower = content.toLowerCase();
+    const q = query.toLowerCase();
+    const idx = lower.indexOf(q);
+    if (idx === -1) {
+        // Fall back to first token match
+        const firstToken = tokenize(query)[0];
+        if (firstToken) {
+            const tIdx = lower.indexOf(firstToken);
+            if (tIdx !== -1)
+                return centerSnippet(content, tIdx, firstToken.length, maxLen);
+        }
+        return content.slice(0, maxLen);
+    }
+    return centerSnippet(content, idx, q.length, maxLen);
+}
+function centerSnippet(content, matchStart, matchLen, maxLen) {
+    const padding = Math.floor((maxLen - matchLen) / 2);
+    const start = Math.max(0, matchStart - padding);
+    const end = Math.min(content.length, matchStart + matchLen + padding);
+    const prefix = start > 0 ? '...' : '';
+    const suffix = end < content.length ? '...' : '';
+    return (prefix + content.slice(start, end) + suffix).replace(/\s+/g, ' ').trim();
+}
+function extractMessageText(msg) {
+    if (typeof msg.content === 'string')
+        return msg.content;
+    if (Array.isArray(msg.content)) {
+        return msg.content
+            .map((part) => {
+            if (typeof part === 'string')
+                return part;
+            if (!part || typeof part !== 'object')
+                return '';
+            const p = part;
+            if (p.type === 'text' && typeof p.text === 'string')
+                return p.text;
+            if (p.type === 'tool_use' && typeof p.name === 'string')
+                return `[tool:${p.name}]`;
+            if (p.type === 'tool_result') {
+                const c = p.content;
+                if (typeof c === 'string')
+                    return c;
+                if (Array.isArray(c)) {
+                    return c.map((cp) => {
+                        if (typeof cp === 'string')
+                            return cp;
+                        if (cp && typeof cp === 'object' && 'text' in cp)
+                            return String(cp.text);
+                        return '';
+                    }).join(' ');
+                }
+            }
+            return '';
+        })
+            .join(' ');
+    }
+    return '';
+}
+// ─── Core Search ──────────────────────────────────────────────────────────
+/**
+ * Search sessions for a query string.
+ * Returns results ranked by relevance (term frequency + recency).
+ */
+export function searchSessions(query, options = {}) {
+    const { limit = 10, model, since } = options;
+    const { terms, phrases } = parseQuery(query);
+    if (terms.length === 0 && phrases.length === 0)
+        return [];
+    const sessions = listSessions();
+    const results = [];
+    for (const session of sessions) {
+        if (model && !session.model.toLowerCase().includes(model.toLowerCase()))
+            continue;
+        if (since && session.updatedAt < since)
+            continue;
+        const match = scoreSession(session, terms, phrases, query);
+        if (match)
+            results.push(match);
+    }
+    // Sort by score desc, then recency desc
+    results.sort((a, b) => {
+        if (b.score !== a.score)
+            return b.score - a.score;
+        return b.session.updatedAt - a.session.updatedAt;
+    });
+    return results.slice(0, limit);
+}
+function scoreSession(session, terms, phrases, originalQuery) {
+    // Locate the session's JSONL file (search in sessions dir)
+    const sessionFile = findSessionFile(session.id);
+    if (!sessionFile)
+        return null;
+    let rawContent;
+    try {
+        rawContent = fs.readFileSync(sessionFile, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+    // Parse messages
+    const messages = [];
+    for (const line of rawContent.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            const msg = JSON.parse(line);
+            if (msg && typeof msg === 'object' && 'role' in msg) {
+                messages.push(msg);
+            }
+        }
+        catch { /* skip malformed */ }
+    }
+    if (messages.length === 0)
+        return null;
+    // Score each message
+    let totalScore = 0;
+    let hitCount = 0;
+    let bestSnippet = '';
+    let bestMatchedRole = 'user';
+    let bestMessageScore = 0;
+    for (const msg of messages) {
+        const text = extractMessageText(msg);
+        if (!text)
+            continue;
+        const lowerText = text.toLowerCase();
+        // Score: sum of term frequencies + phrase bonuses
+        let msgScore = 0;
+        for (const term of terms) {
+            const count = countOccurrences(lowerText, term);
+            if (count > 0) {
+                msgScore += count;
+                hitCount += count;
+            }
+        }
+        for (const phrase of phrases) {
+            const count = countOccurrences(lowerText, phrase);
+            if (count > 0) {
+                // Phrase matches are worth 3x term matches
+                msgScore += count * 3;
+                hitCount += count;
+            }
+        }
+        // Assistant matches slightly preferred (usually more substantive)
+        if (msg.role === 'assistant')
+            msgScore *= 1.1;
+        if (msgScore > bestMessageScore) {
+            bestMessageScore = msgScore;
+            bestSnippet = extractSnippet(text, originalQuery);
+            bestMatchedRole = msg.role === 'assistant' ? 'assistant' : 'user';
+        }
+        totalScore += msgScore;
+    }
+    if (totalScore === 0)
+        return null;
+    // Recency bonus: newer sessions get a small boost
+    const ageDays = (Date.now() - session.updatedAt) / (1000 * 60 * 60 * 24);
+    const recencyBonus = Math.max(0, 5 - ageDays * 0.1);
+    const finalScore = totalScore + recencyBonus;
+    return {
+        session,
+        score: finalScore,
+        hitCount,
+        snippet: bestSnippet,
+        matchedRole: bestMatchedRole,
+    };
+}
+function countOccurrences(text, needle) {
+    if (!needle)
+        return 0;
+    let count = 0;
+    let idx = 0;
+    while ((idx = text.indexOf(needle, idx)) !== -1) {
+        count++;
+        idx += needle.length;
+    }
+    return count;
+}
+function findSessionFile(sessionId) {
+    const p = getSessionFilePath(sessionId);
+    return fs.existsSync(p) ? p : null;
+}
+// ─── Display ──────────────────────────────────────────────────────────────
+export function formatSearchResults(matches, query) {
+    if (matches.length === 0) {
+        return `\nNo sessions found matching "${query}".\n`;
+    }
+    const lines = [];
+    lines.push(`\n  Found ${matches.length} session${matches.length === 1 ? '' : 's'} matching "${query}":\n`);
+    for (let i = 0; i < matches.length; i++) {
+        const m = matches[i];
+        const date = new Date(m.session.updatedAt).toISOString().slice(0, 16).replace('T', ' ');
+        const hitLabel = m.hitCount === 1 ? 'hit' : 'hits';
+        lines.push(`  ${i + 1}. ${m.session.id}`);
+        lines.push(`     ${date} | ${m.session.model} | ${m.hitCount} ${hitLabel} | score ${m.score.toFixed(1)}`);
+        lines.push(`     [${m.matchedRole}] ${m.snippet}`);
+        lines.push('');
+    }
+    lines.push(`  Resume: runcode  (then /resume <session-id>)\n`);
+    return lines.join('\n');
+}

package/dist/session/storage.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Session persistence for runcode.
+ * Saves conversation history as JSONL for resume capability.
+ */
+import type { Dialogue } from '../agent/types.js';
+export interface SessionMeta {
+    id: string;
+    model: string;
+    workDir: string;
+    createdAt: number;
+    updatedAt: number;
+    turnCount: number;
+    messageCount: number;
+}
+/** Get the absolute path to a session's JSONL file (for external readers like search). */
+export declare function getSessionFilePath(id: string): string;
+/**
+ * Create a new session ID based on timestamp.
+ */
+export declare function createSessionId(): string;
+/**
+ * Save a message to the session transcript (append-only JSONL).
+ */
+export declare function appendToSession(sessionId: string, message: Dialogue): void;
+/**
+ * Update session metadata.
+ */
+export declare function updateSessionMeta(sessionId: string, meta: Partial<SessionMeta>): void;
+/**
+ * Load session metadata.
+ */
+export declare function loadSessionMeta(sessionId: string): SessionMeta | null;
+/**
+ * Load full session history from JSONL.
+ */
+export declare function loadSessionHistory(sessionId: string): Dialogue[];
+/**
+ * List all saved sessions, newest first.
+ */
+export declare function listSessions(): SessionMeta[];
+/**
+ * Prune old sessions beyond MAX_SESSIONS.
+ */
+/**
+ * Prune old sessions beyond MAX_SESSIONS.
+ * Accepts optional activeSessionId to protect from deletion.
+ */
+export declare function pruneOldSessions(activeSessionId?: string): void;

package/dist/session/storage.js

@@ -0,0 +1,173 @@
+/**
+ * Session persistence for runcode.
+ * Saves conversation history as JSONL for resume capability.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { BLOCKRUN_DIR } from '../config.js';
+const MAX_SESSIONS = 20; // Keep last 20 sessions
+let resolvedSessionsDir = null;
+function getSessionsDir() {
+    if (resolvedSessionsDir)
+        return resolvedSessionsDir;
+    const preferred = path.join(BLOCKRUN_DIR, 'sessions');
+    const fallback = path.join(os.tmpdir(), 'runcode', 'sessions');
+    for (const dir of [preferred, fallback]) {
+        try {
+            fs.mkdirSync(dir, { recursive: true });
+            resolvedSessionsDir = dir;
+            return dir;
+        }
+        catch {
+            // Try the next candidate.
+        }
+    }
+    // If both locations fail, keep the preferred path so the original error
+    // surfaces from the caller rather than hiding the failure.
+    resolvedSessionsDir = preferred;
+    return resolvedSessionsDir;
+}
+function sessionPath(id) {
+    return path.join(getSessionsDir(), `${id}.jsonl`);
+}
+/** Get the absolute path to a session's JSONL file (for external readers like search). */
+export function getSessionFilePath(id) {
+    return sessionPath(id);
+}
+function metaPath(id) {
+    return path.join(getSessionsDir(), `${id}.meta.json`);
+}
+function withWritableSessionDir(action) {
+    const preferred = path.join(BLOCKRUN_DIR, 'sessions');
+    const fallback = path.join(os.tmpdir(), 'runcode', 'sessions');
+    try {
+        action();
+    }
+    catch (err) {
+        const code = err.code;
+        const shouldFallback = (code === 'EACCES' || code === 'EPERM' || code === 'EROFS') &&
+            resolvedSessionsDir === preferred;
+        if (!shouldFallback)
+            throw err;
+        fs.mkdirSync(fallback, { recursive: true });
+        resolvedSessionsDir = fallback;
+        action();
+    }
+}
+/**
+ * Create a new session ID based on timestamp.
+ */
+export function createSessionId() {
+    const now = new Date();
+    const ts = now.toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    return `session-${ts}`;
+}
+/**
+ * Save a message to the session transcript (append-only JSONL).
+ */
+export function appendToSession(sessionId, message) {
+    const line = JSON.stringify(message) + '\n';
+    withWritableSessionDir(() => {
+        fs.appendFileSync(sessionPath(sessionId), line);
+    });
+}
+/**
+ * Update session metadata.
+ */
+export function updateSessionMeta(sessionId, meta) {
+    withWritableSessionDir(() => {
+        const existing = loadSessionMeta(sessionId);
+        const updated = {
+            id: sessionId,
+            model: meta.model || existing?.model || 'unknown',
+            workDir: meta.workDir || existing?.workDir || '',
+            createdAt: existing?.createdAt || Date.now(),
+            updatedAt: Date.now(),
+            turnCount: meta.turnCount ?? existing?.turnCount ?? 0,
+            messageCount: meta.messageCount ?? existing?.messageCount ?? 0,
+        };
+        fs.writeFileSync(metaPath(sessionId), JSON.stringify(updated, null, 2));
+    });
+}
+/**
+ * Load session metadata.
+ */
+export function loadSessionMeta(sessionId) {
+    try {
+        return JSON.parse(fs.readFileSync(metaPath(sessionId), 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Load full session history from JSONL.
+ */
+export function loadSessionHistory(sessionId) {
+    try {
+        const content = fs.readFileSync(sessionPath(sessionId), 'utf-8');
+        const lines = content.trim().split('\n').filter(Boolean);
+        const results = [];
+        for (const line of lines) {
+            try {
+                results.push(JSON.parse(line));
+            }
+            catch {
+                // Skip corrupted lines — partial writes from crashes
+                continue;
+            }
+        }
+        return results;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * List all saved sessions, newest first.
+ */
+export function listSessions() {
+    const sessionsDir = getSessionsDir();
+    try {
+        const files = fs.readdirSync(sessionsDir)
+            .filter(f => f.endsWith('.meta.json'));
+        const metas = [];
+        for (const file of files) {
+            try {
+                const meta = JSON.parse(fs.readFileSync(path.join(sessionsDir, file), 'utf-8'));
+                metas.push(meta);
+            }
+            catch { /* skip corrupted */ }
+        }
+        return metas.sort((a, b) => b.updatedAt - a.updatedAt);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Prune old sessions beyond MAX_SESSIONS.
+ */
+/**
+ * Prune old sessions beyond MAX_SESSIONS.
+ * Accepts optional activeSessionId to protect from deletion.
+ */
+export function pruneOldSessions(activeSessionId) {
+    const sessions = listSessions();
+    if (sessions.length <= MAX_SESSIONS)
+        return;
+    const toDelete = sessions
+        .slice(MAX_SESSIONS)
+        .filter(s => s.id !== activeSessionId); // Never delete active session
+    for (const s of toDelete) {
+        try {
+            fs.unlinkSync(sessionPath(s.id));
+        }
+        catch { /* ok */ }
+        try {
+            fs.unlinkSync(metaPath(s.id));
+        }
+        catch { /* ok */ }
+    }
+}

package/dist/stats/insights.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Session insights engine.
+ *
+ * Rich usage analytics from the stats tracker history.
+ * Inspired by hermes-agent's `agent/insights.py` and Claude Code's /insights.
+ *
+ * Provides:
+ *   - Per-model cost and request breakdown
+ *   - Daily activity trend (sparkline)
+ *   - Top sessions by cost
+ *   - Tool usage patterns
+ *   - Cost projections and efficiency metrics
+ */
+export interface InsightsReport {
+    /** Window size in days */
+    days: number;
+    /** Records within the window */
+    windowRecords: number;
+    /** Total cost in window */
+    totalCostUsd: number;
+    /** Total input tokens in window */
+    totalInputTokens: number;
+    /** Total output tokens in window */
+    totalOutputTokens: number;
+    /** Savings vs always using Claude Opus */
+    savedVsOpusUsd: number;
+    /** Per-model breakdown, sorted by cost desc */
+    byModel: Array<{
+        model: string;
+        requests: number;
+        costUsd: number;
+        inputTokens: number;
+        outputTokens: number;
+        avgLatencyMs: number;
+        percentOfTotal: number;
+    }>;
+    /** Daily activity (last N days), oldest first */
+    daily: Array<{
+        date: string;
+        requests: number;
+        costUsd: number;
+    }>;
+    /** Projections */
+    projections: {
+        avgCostPerDay: number;
+        projectedMonthlyUsd: number;
+        projectedYearlyUsd: number;
+    };
+    /** Average request cost */
+    avgRequestCostUsd: number;
+    /** Efficiency: cost per 1K tokens */
+    costPer1KTokens: number;
+}
+export declare function generateInsights(days?: number): InsightsReport;
+export declare function formatInsights(report: InsightsReport, days: number): string;

package/dist/stats/insights.js

@@ -0,0 +1,195 @@
+/**
+ * Session insights engine.
+ *
+ * Rich usage analytics from the stats tracker history.
+ * Inspired by hermes-agent's `agent/insights.py` and Claude Code's /insights.
+ *
+ * Provides:
+ *   - Per-model cost and request breakdown
+ *   - Daily activity trend (sparkline)
+ *   - Top sessions by cost
+ *   - Tool usage patterns
+ *   - Cost projections and efficiency metrics
+ */
+import { loadStats } from './tracker.js';
+import { OPUS_PRICING, MODEL_PRICING } from '../pricing.js';
+// ─── Generate Report ──────────────────────────────────────────────────────
+export function generateInsights(days = 30) {
+    const stats = loadStats();
+    const now = Date.now();
+    const windowStart = now - days * 24 * 60 * 60 * 1000;
+    const windowHistory = stats.history.filter(r => r.timestamp >= windowStart);
+    // Aggregate totals
+    let totalCost = 0;
+    let totalInput = 0;
+    let totalOutput = 0;
+    const modelAgg = new Map();
+    for (const r of windowHistory) {
+        totalCost += r.costUsd;
+        totalInput += r.inputTokens;
+        totalOutput += r.outputTokens;
+        const existing = modelAgg.get(r.model) ?? {
+            requests: 0,
+            costUsd: 0,
+            inputTokens: 0,
+            outputTokens: 0,
+            totalLatencyMs: 0,
+        };
+        existing.requests++;
+        existing.costUsd += r.costUsd;
+        existing.inputTokens += r.inputTokens;
+        existing.outputTokens += r.outputTokens;
+        existing.totalLatencyMs += r.latencyMs;
+        modelAgg.set(r.model, existing);
+    }
+    // Build byModel array sorted by cost
+    const byModel = [];
+    for (const [model, agg] of modelAgg.entries()) {
+        byModel.push({
+            model,
+            requests: agg.requests,
+            costUsd: agg.costUsd,
+            inputTokens: agg.inputTokens,
+            outputTokens: agg.outputTokens,
+            avgLatencyMs: agg.requests > 0 ? Math.round(agg.totalLatencyMs / agg.requests) : 0,
+            percentOfTotal: totalCost > 0 ? (agg.costUsd / totalCost) * 100 : 0,
+        });
+    }
+    byModel.sort((a, b) => b.costUsd - a.costUsd);
+    // Daily activity
+    const dailyMap = new Map();
+    for (let i = 0; i < days; i++) {
+        const d = new Date(now - i * 24 * 60 * 60 * 1000);
+        const key = d.toISOString().slice(0, 10);
+        dailyMap.set(key, { requests: 0, costUsd: 0 });
+    }
+    for (const r of windowHistory) {
+        const key = new Date(r.timestamp).toISOString().slice(0, 10);
+        const existing = dailyMap.get(key);
+        if (existing) {
+            existing.requests++;
+            existing.costUsd += r.costUsd;
+        }
+    }
+    const daily = Array.from(dailyMap.entries())
+        .map(([date, v]) => ({ date, ...v }))
+        .sort((a, b) => a.date.localeCompare(b.date));
+    // Calculate savings vs Opus
+    const opusCostPer1M = (OPUS_PRICING.input + OPUS_PRICING.output) / 2;
+    const opusWouldCost = ((totalInput + totalOutput) / 1_000_000) * opusCostPer1M;
+    const savedVsOpusUsd = Math.max(0, opusWouldCost - totalCost);
+    // Projections
+    const avgCostPerDay = days > 0 ? totalCost / days : 0;
+    const projections = {
+        avgCostPerDay,
+        projectedMonthlyUsd: avgCostPerDay * 30,
+        projectedYearlyUsd: avgCostPerDay * 365,
+    };
+    // Efficiency
+    const totalTokens = totalInput + totalOutput;
+    const costPer1KTokens = totalTokens > 0 ? (totalCost / totalTokens) * 1000 : 0;
+    const avgRequestCostUsd = windowHistory.length > 0 ? totalCost / windowHistory.length : 0;
+    return {
+        days,
+        windowRecords: windowHistory.length,
+        totalCostUsd: totalCost,
+        totalInputTokens: totalInput,
+        totalOutputTokens: totalOutput,
+        savedVsOpusUsd,
+        byModel,
+        daily,
+        projections,
+        avgRequestCostUsd,
+        costPer1KTokens,
+    };
+}
+// ─── Format for Display ───────────────────────────────────────────────────
+function sparkline(values) {
+    if (values.length === 0)
+        return '';
+    const max = Math.max(...values);
+    if (max === 0)
+        return '▁'.repeat(values.length);
+    const chars = ['▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'];
+    return values.map(v => chars[Math.min(7, Math.floor((v / max) * 8))]).join('');
+}
+function formatUsd(n) {
+    if (n === 0)
+        return '$0';
+    if (n < 0.01)
+        return `$${n.toFixed(4)}`;
+    if (n < 1)
+        return `$${n.toFixed(3)}`;
+    return `$${n.toFixed(2)}`;
+}
+function formatTokens(n) {
+    if (n < 1000)
+        return String(n);
+    if (n < 1_000_000)
+        return `${(n / 1000).toFixed(1)}K`;
+    return `${(n / 1_000_000).toFixed(2)}M`;
+}
+function shortModelName(model) {
+    // Strip provider prefix for display
+    const idx = model.indexOf('/');
+    return idx > -1 ? model.slice(idx + 1) : model;
+}
+export function formatInsights(report, days) {
+    const sep = '─'.repeat(60);
+    const lines = [];
+    lines.push('');
+    lines.push(sep);
+    lines.push(`  RUNCODE INSIGHTS — last ${days} days`);
+    lines.push(sep);
+    if (report.windowRecords === 0) {
+        lines.push('');
+        lines.push('  No activity in this window.');
+        lines.push('');
+        lines.push(sep);
+        lines.push('');
+        return lines.join('\n');
+    }
+    // Summary
+    lines.push('');
+    lines.push(`  Requests:     ${report.windowRecords}`);
+    lines.push(`  Total cost:   ${formatUsd(report.totalCostUsd)}`);
+    lines.push(`  Input tokens: ${formatTokens(report.totalInputTokens)}`);
+    lines.push(`  Output tokens: ${formatTokens(report.totalOutputTokens)}`);
+    lines.push(`  Avg/request:  ${formatUsd(report.avgRequestCostUsd)}  (${formatUsd(report.costPer1KTokens)}/1K tokens)`);
+    if (report.savedVsOpusUsd > 0) {
+        lines.push(`  Saved vs Opus: ${formatUsd(report.savedVsOpusUsd)} by using cheaper models`);
+    }
+    // Projections
+    lines.push('');
+    lines.push('  Projection:');
+    lines.push(`    Per day:  ${formatUsd(report.projections.avgCostPerDay)}`);
+    lines.push(`    Per month: ${formatUsd(report.projections.projectedMonthlyUsd)}`);
+    lines.push(`    Per year: ${formatUsd(report.projections.projectedYearlyUsd)}`);
+    // Per-model breakdown
+    if (report.byModel.length > 0) {
+        lines.push('');
+        lines.push('  By model:');
+        for (const m of report.byModel.slice(0, 10)) {
+            const name = shortModelName(m.model).padEnd(30);
+            const cost = formatUsd(m.costUsd).padStart(8);
+            const pct = `${m.percentOfTotal.toFixed(0)}%`.padStart(4);
+            const reqs = `${m.requests}req`.padStart(7);
+            lines.push(`    ${name}  ${cost}  ${pct}  ${reqs}`);
+        }
+    }
+    // Daily activity sparkline
+    if (report.daily.length > 0) {
+        const costs = report.daily.map(d => d.costUsd);
+        const requests = report.daily.map(d => d.requests);
+        lines.push('');
+        lines.push('  Daily activity:');
+        lines.push(`    Requests: ${sparkline(requests)}  ${report.daily[0].date} → ${report.daily[report.daily.length - 1].date}`);
+        lines.push(`    Cost:     ${sparkline(costs)}`);
+    }
+    lines.push('');
+    lines.push(sep);
+    lines.push('');
+    return lines.join('\n');
+}
+// Silence unused import warning
+void MODEL_PRICING;