@krtclcdy/tersio 2.25.4 → 2.25.6

package/dist/extensions/shared/agent-stats.js

@@ -0,0 +1,1198 @@
+// Read-only aggregate over the usage store; missing SQLite, table, or metric reads as zeros.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { sqliteRead } from './sqlite.js';
+import { usageDbPath } from './usage-store.js';
+export const RANGES = ['1h', '24h', '7d', '30d', '90d', 'all'];
+export function isRangeKey(v) {
+    return typeof v === 'string' && RANGES.includes(v);
+}
+export const AGENT_VIEWS = [
+    'all', 'overview', 'models', 'providers', 'costs', 'carbon', 'requests',
+    'errors', 'traces', 'tools', 'projects',
+];
+export function isAgentView(v) {
+    return typeof v === 'string' && AGENT_VIEWS.includes(v);
+}
+/** Query group names, matching the blocks readStatsDb issues. */
+const VIEW_PARTS = {
+    all: ['overall', 'byModel', 'byProvider', 'byAgentType', 'byProject', 'series', 'hourOfDay', 'recent', 'errors', 'traces',
+        'seriesByProvider', 'modelSeries', 'modelPerformance', 'tools', 'windows', 'providerHourly'],
+    overview: ['overall', 'byModel', 'byProvider', 'byAgentType', 'byProject', 'series', 'hourOfDay', 'recent',
+        'seriesByProvider', 'modelSeries'],
+    models: ['overall', 'byModel', 'modelSeries', 'modelPerformance', 'series'],
+    providers: ['overall', 'byProvider', 'series', 'seriesByProvider', 'providerHourly', 'windows'],
+    // `modelSeries` feeds the per-model stack, so the page's first paint is not an empty chart.
+    costs: ['overall', 'byModel', 'series', 'modelSeries'],
+    // The Carbon page needs the same two facts as Costs: per-model output tokens and the mix.
+    carbon: ['overall', 'byModel'],
+    requests: ['overall', 'recent'],
+    errors: ['errors', 'overall', 'byModel', 'recent'],
+    traces: ['traces'],
+    tools: ['overall', 'tools'],
+    projects: ['overall', 'byProject'],
+};
+/** Window length in ms. `all` has no cutoff, so it reads as 0. */
+const RANGE_MS = {
+    '1h': 3_600_000,
+    '24h': 86_400_000,
+    '7d': 604_800_000,
+    '30d': 2_592_000_000,
+    '90d': 7_776_000_000,
+    all: 0,
+};
+/** Bucket width per range, measured against the reference: 5 minutes, then 1 hour, then 1 day. */
+const BUCKET_MS = {
+    '1h': 300_000,
+    '24h': 3_600_000,
+    '7d': 86_400_000,
+    '30d': 86_400_000,
+    '90d': 86_400_000,
+    all: 86_400_000,
+};
+/** A series never renders more than this many buckets; a wider span coarsens the bucket. */
+const MAX_BUCKETS = 1500;
+const RECENT_LIMIT = 200;
+const ERROR_LIMIT = 300;
+const TRACE_LIMIT = 300;
+const TOOL_MODEL_LIMIT = 300;
+const SERIES_PROVIDERS = 8;
+const SERIES_MODELS = 12;
+/** The store every metric but subscription quota reads, kept in step by `tersio usage`. */
+export function statsDbPath() {
+    return process.env.TERSIO_AGENT_STATS_DB ?? usageDbPath();
+}
+/** Quota snapshots. Only omp records these, so this stays omp's own database. */
+export function agentDbPath() {
+    return process.env.TERSIO_AGENT_SESSIONS_DB ?? path.join(os.homedir(), '.omp', 'agent', 'agent.db');
+}
+/** The row shape every query groups by: a message joined to its file, since path and facts live apart. */
+const SOURCE = 'messages m JOIN files f ON f.id = m.file_id';
+/** The transcript path with any host-side row suffix removed, so one file groups as one session. */
+const FILE_KEY = `substr(f.path, 1, instr(f.path || '#', '#') - 1)`;
+/** Model-id spellings whose dashboard mark lives under another name; the first segment names the gateway. */
+const PROVIDER_ALIASES = {
+    'opencode-zen': 'opencode',
+    'opencode-go': 'opencode',
+    'gmi-cloud': 'gmicloud',
+    'charm-hyper': 'charmhyper',
+    'kimi-code': 'kimi',
+    'openai-codex': 'openai',
+    'github-copilot': 'githubcopilot',
+    'ollama-cloud': 'ollama',
+    'amd-radeon-cloud-cn': 'amd',
+    'google-antigravity': 'google',
+    devin: 'cognition',
+};
+/** SQL: the gateway a model id names, from its first segment. Empty when the id carries none, not a guess. */
+function providerExpr(model) {
+    const seg = `substr(${model}, 1, instr(${model} || '/', '/') - 1)`;
+    const named = `ltrim(${seg}, '~')`;
+    const cases = Object.entries(PROVIDER_ALIASES)
+        .map(([from, to]) => `WHEN '${from}' THEN '${to}'`)
+        .join(' ');
+    return `CASE WHEN instr(${model}, '/') = 0 THEN '' ELSE CASE ${named} ${cases} ELSE ${named} END END`;
+}
+/** SQL: the project a transcript belongs to, named by its session folder. A flat session tree uses its data dir. */
+function projectExpr(file) {
+    const marker = `instr(${file}, '/sessions/')`;
+    const seg = `substr(${file}, ${marker} + 10, instr(substr(${file}, ${marker} + 10) || '/', '/') - 1)`;
+    const base = `replace(${file}, rtrim(${file}, replace(${file}, '/', '')), '')`;
+    const dir = `substr(${file}, 1, length(${file}) - length(${base}) - 1)`;
+    const dirBase = `replace(${dir}, rtrim(${dir}, replace(${dir}, '/', '')), '')`;
+    return `CASE WHEN ${marker} > 0 THEN ${seg} ELSE ${dirBase} END`;
+}
+/** Every column a query reads, mapped to the store's schema in one place. */
+const COL = {
+    session: FILE_KEY,
+    entry: `COALESCE(m.id, '')`,
+    folder: projectExpr(FILE_KEY),
+    model: 'm.model',
+    provider: providerExpr('m.model'),
+    /** No route name is stored, and the Requests page reads one. */
+    api: "''",
+    timestamp: 'm.t',
+    // Bucketing form of the timestamp. REAL division does not floor, so the cast is needed.
+    bucket: 'CAST(COALESCE(m.t, 0) AS INTEGER)',
+    duration: 'm.d',
+    /** First-token latency. A host that records none leaves it NULL, which reads null, never zero. */
+    ttft: 'm.tf',
+    stopReason: `CASE m.st WHEN 'error' THEN 'error' WHEN 'aborted' THEN 'aborted' ELSE 'stop' END`,
+    errorMessage: 'm.note',
+    input: 'm.i',
+    output: 'm.o',
+    cacheRead: 'm.cr',
+    cacheWrite: 'm.cw',
+    total: '(m.i + m.o + m.cr + m.cw)',
+    /** The cost the host reported. A model the host priced nothing for reads $0.00 by design. */
+    costTotal: 'COALESCE(m.usd, 0)',
+    agentType: `COALESCE(m.a, 'main')`,
+    host: `COALESCE(m.h, '')`,
+    /** The store holds no per-component split, so the remainder rule below finds nothing to move. */
+    costInput: '0',
+    costCacheRead: '0',
+    costCacheWrite: '0',
+    /** No route is a subscription route here, so nothing is ever flagged unpriced. */
+    unpriced: '0',
+};
+/** Output cost is the remainder: omp prices the whole request and the three cache-side parts. */
+function costMixOf(f) {
+    const input = f.costInput;
+    const cacheRead = f.costCacheRead;
+    const cacheWrite = f.costCacheWrite;
+    return {
+        input,
+        cacheRead,
+        cacheWrite,
+        output: Math.max(0, f.costUsd - input - cacheRead - cacheWrite),
+        total: f.costUsd,
+    };
+}
+export function emptyAgentStats(range = '24h') {
+    return {
+        available: false,
+        range,
+        bucketMs: BUCKET_MS[range],
+        cutoff: 0,
+        generatedAt: Date.now(),
+        overall: {
+            requests: 0, failed: 0, successful: 0, errorRate: 0, cacheRate: 0,
+            costUsd: 0, unpricedRequests: 0,
+            avgDurationMs: 0, avgTtftMs: 0, avgTokensPerSecond: 0, maxDurationMs: null,
+            input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0,
+            costMix: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+            firstTs: null, lastTs: null,
+        },
+        byModel: [], byProvider: [], byProject: [], byAgentType: [],
+        series: [], seriesByProvider: [], modelSeries: [], modelPerformance: [], hourOfDay: [], topModels: [],
+        recent: [], errorGroups: [], errorModels: [], traces: [],
+        tools: [], toolsByModel: [], toolSeries: [],
+        usageSeries: [], windowInsights: [], providerHourly: [],
+        requestStats: {
+            requests: 0, failed: 0, aborted: 0, tokens: 0, costUsd: 0, unpriced: 0, shipped: 0,
+            medianDurationMs: 0, p95DurationMs: 0, medianTtftMs: 0, oldest: null, newest: null,
+        },
+        errors: [],
+    };
+}
+/** Rows from a read-only script, tab-separated: whichever engine this host has answers it. */
+export function sqliteScript(db, script) {
+    return sqliteRead(db, script);
+}
+/** One call per query: an unavailable table leaves its key absent, so a partial schema still reads. */
+function readBlocks(db, queries) {
+    const map = new Map();
+    for (const [name, sql] of queries) {
+        try {
+            map.set(name, sqliteScript(db, sql).split('\n').filter((line) => line.trim()).map((line) => line.split('\t')));
+        }
+        catch { /* an unavailable table leaves its key absent */ }
+    }
+    return map;
+}
+function tableColumns(db, table) {
+    try {
+        const out = sqliteScript(db, `SELECT name FROM pragma_table_info('${table}');\n`);
+        return new Set(out.split('\n').map((l) => l.trim()).filter(Boolean));
+    }
+    catch {
+        return new Set();
+    }
+}
+function num(v) {
+    const n = Number(v);
+    return Number.isFinite(n) ? n : 0;
+}
+function numOrNull(v) {
+    if (v === undefined || v === '')
+        return null;
+    const n = Number(v);
+    return Number.isFinite(n) ? n : null;
+}
+/** A text column must stay on one line: the parser splits rows on tabs and newlines. */
+function txt(column) {
+    return `replace(replace(replace(COALESCE(${column}, ''), char(10), ' '), char(13), ' '), char(9), ' ')`;
+}
+/** The unpriced rule, kept for callers that group by it: no route here is a subscription route. */
+function unpricedSql() {
+    return '0';
+}
+/** The additive facts every messages group reads. */
+function messageFacts() {
+    return [
+        'COUNT(*)',
+        `SUM(CASE WHEN ${COL.stopReason} = 'error' THEN 1 ELSE 0 END)`,
+        `SUM(${COL.input})`,
+        `SUM(${COL.output})`,
+        `SUM(${COL.cacheRead})`,
+        `SUM(${COL.cacheWrite})`,
+        `SUM(${COL.total})`,
+        `TOTAL(${COL.costTotal})`,
+        `TOTAL(${COL.costInput})`,
+        `TOTAL(${COL.costCacheRead})`,
+        `TOTAL(${COL.costCacheWrite})`,
+        `SUM(${COL.unpriced})`,
+        `TOTAL(${COL.duration})`,
+        `COUNT(${COL.duration})`,
+        `TOTAL(${COL.ttft})`,
+        `COUNT(${COL.ttft})`,
+        `TOTAL(CASE WHEN ${COL.duration} > 0 THEN ${COL.output} * 1000.0 / ${COL.duration} END)`,
+        `COUNT(CASE WHEN ${COL.duration} > 0 THEN 1 END)`,
+        `MIN(${COL.timestamp})`,
+        `MAX(${COL.timestamp})`,
+        `MAX(${COL.duration})`,
+    ].join(', ');
+}
+/** Column order of a recent or error row, matching `requestColumns` below. */
+const REQUEST_COLUMNS = [
+    COL.timestamp, COL.provider, COL.model, COL.folder, COL.api,
+    COL.input, COL.output, COL.cacheRead, COL.cacheWrite, COL.total,
+    COL.costTotal, COL.unpriced, COL.duration, COL.ttft, COL.stopReason, COL.errorMessage,
+    COL.agentType, COL.session, COL.entry,
+];
+function parseFacts(row, at) {
+    const g = (i) => num(row?.[at + i]);
+    return {
+        requests: g(0), failed: g(1),
+        input: g(2), output: g(3), cacheRead: g(4), cacheWrite: g(5), total: g(6),
+        costUsd: g(7),
+        costInput: g(8), costCacheRead: g(9), costCacheWrite: g(10),
+        unpriced: g(11),
+        durationSum: g(12), durationN: g(13), ttftSum: g(14), ttftN: g(15),
+        tpsSum: g(16), tpsN: g(17),
+        firstTs: numOrNull(row?.[at + 18]), lastTs: numOrNull(row?.[at + 19]),
+        maxDurationMs: numOrNull(row?.[at + 20]),
+    };
+}
+function mix(f) {
+    return { input: f.input, output: f.output, cacheRead: f.cacheRead, cacheWrite: f.cacheWrite, total: f.total };
+}
+const cacheRateOf = (f) => (f.input + f.cacheRead > 0 ? f.cacheRead / (f.input + f.cacheRead) : 0);
+function overallOf(f) {
+    return {
+        ...mix(f),
+        costMix: costMixOf(f),
+        requests: f.requests,
+        failed: f.failed,
+        successful: f.requests - f.failed,
+        errorRate: f.requests > 0 ? f.failed / f.requests : 0,
+        cacheRate: cacheRateOf(f),
+        costUsd: f.costUsd,
+        unpricedRequests: f.unpriced,
+        avgDurationMs: f.durationN > 0 ? f.durationSum / f.durationN : 0,
+        avgTtftMs: f.ttftN > 0 ? f.ttftSum / f.ttftN : 0,
+        avgTokensPerSecond: f.tpsN > 0 ? f.tpsSum / f.tpsN : 0,
+        maxDurationMs: f.maxDurationMs,
+        firstTs: f.firstTs,
+        lastTs: f.lastTs,
+    };
+}
+function rowOf(key, f, models, provider = '') {
+    return {
+        ...mix(f),
+        key,
+        provider,
+        costMix: costMixOf(f),
+        requests: f.requests,
+        failed: f.failed,
+        errorRate: f.requests > 0 ? f.failed / f.requests : 0,
+        cacheRate: cacheRateOf(f),
+        costUsd: f.costUsd,
+        unpricedRequests: f.unpriced,
+        avgDurationMs: f.durationN > 0 ? f.durationSum / f.durationN : 0,
+        avgTtftMs: f.ttftN > 0 ? f.ttftSum / f.ttftN : 0,
+        avgTokensPerSecond: f.tpsN > 0 ? f.tpsSum / f.tpsN : 0,
+        firstTs: f.firstTs,
+        lastTs: f.lastTs,
+        models,
+    };
+}
+function rangeWhere(cutoff, column = 'timestamp') {
+    return cutoff > 0 ? `WHERE ${column} >= ${Math.floor(cutoff)}` : '';
+}
+/** Utilization is a fraction with float noise; four decimals keep the payload small. */
+function round4(v) {
+    return v === null ? null : Math.round(v * 1e4) / 1e4;
+}
+function bucketSize(range, firstTs, lastTs) {
+    const base = BUCKET_MS[range];
+    if (firstTs === null || lastTs === null)
+        return base;
+    const span = Math.max(0, lastTs - firstTs);
+    if (span / base <= MAX_BUCKETS)
+        return base;
+    return Math.max(base, Math.ceil(span / MAX_BUCKETS / base) * base);
+}
+function readStatsDb(db, cutoff, bucketMs, parts, offset = 0) {
+    const where = rangeWhere(cutoff, COL.timestamp);
+    const errorWhere = `WHERE ${COL.stopReason} = 'error'${cutoff > 0 ? ` AND ${COL.timestamp} >= ${Math.floor(cutoff)}` : ''}`;
+    const from = SOURCE;
+    const out = readBlocks(db, [
+        ['overall', `SELECT ${messageFacts()} FROM ${from} ${where}`],
+        ['byModel', `SELECT ${COL.model}, ${COL.provider}, ${messageFacts()} FROM ${from} ${where} GROUP BY 1, 2 ORDER BY 3 DESC`],
+        ['byProvider', `SELECT ${COL.provider}, COUNT(DISTINCT ${COL.model}), ${messageFacts()} FROM ${from} ${where} GROUP BY 1 ORDER BY 3 DESC`],
+        ['byAgentType', `SELECT ${COL.agentType}, ${messageFacts()} FROM ${from} ${where} GROUP BY 1 ORDER BY 2 DESC`],
+        ['byProject', `SELECT ${COL.folder}, ${messageFacts()} FROM ${from} ${where} GROUP BY 1 ORDER BY 2 DESC`],
+        ['series', `SELECT (${COL.bucket} / ${bucketMs}) * ${bucketMs}, COUNT(*),
+        SUM(CASE WHEN ${COL.stopReason} = 'error' THEN 1 ELSE 0 END),
+        SUM(${COL.total}), TOTAL(${COL.costTotal}) FROM ${from} ${where} GROUP BY 1 ORDER BY 1`],
+        ['hourOfDay', `SELECT CAST(strftime('%H', ${COL.bucket} / 1000, 'unixepoch', 'localtime') AS INTEGER),
+        COUNT(*), SUM(CASE WHEN ${COL.stopReason} = 'error' THEN 1 ELSE 0 END), SUM(${COL.total}), TOTAL(${COL.costTotal})
+        FROM ${from} ${where} GROUP BY 1 ORDER BY 1`],
+        ['recent', `SELECT ${REQUEST_COLUMNS.join(', ')} FROM ${from} ${where} ORDER BY ${COL.timestamp} DESC LIMIT ${RECENT_LIMIT} OFFSET ${Math.max(0, Math.floor(offset))}`],
+        ['errors', `SELECT ${REQUEST_COLUMNS.join(', ')} FROM ${from} ${errorWhere} ORDER BY ${COL.timestamp} DESC LIMIT ${ERROR_LIMIT}`],
+        ['traces', `SELECT ${COL.session}, MAX(${COL.folder}),
+        COUNT(*), SUM(${COL.total}), TOTAL(${COL.costTotal}), SUM(${COL.unpriced}),
+        MIN(${COL.timestamp}), MAX(${COL.timestamp} + COALESCE(${COL.duration}, 0))
+        FROM ${from} ${where} GROUP BY 1 ORDER BY 8 DESC LIMIT ${TRACE_LIMIT}`],
+    ].filter(([name]) => parts.has(name)).map(([name, sql]) => [name, sql]));
+    // Models and tools are keyed by root, so a child outside the window still folds into its session.
+    const traceModels = readTraceModels(db);
+    const traceTools = readTraceToolCounts(db);
+    const traces = foldTraces((out.get('traces') ?? []).map((r) => {
+        // Both readers are keyed by root, so every file of a session reads the session's totals.
+        const root = rootSessionFile(r[0] ?? '');
+        return {
+            sessionFile: r[0] ?? '', project: r[1] ?? '', cwd: '', title: null,
+            requests: num(r[2]), tokens: num(r[3]), costUsd: num(r[4]), unpriced: num(r[5]),
+            models: traceModels.get(root) ?? [],
+            toolCalls: traceTools.get(root) ?? 0,
+            subagents: 0, firstTs: num(r[6]), lastTs: num(r[7]),
+        };
+    }));
+    applySessionMetadata(traces);
+    const requestRows = (rows) => rows.map((r) => ({
+        ts: num(r[0]),
+        provider: r[1] ?? '',
+        model: r[2] ?? '',
+        project: r[3] ?? '',
+        api: r[4] ?? '',
+        input: num(r[5]), output: num(r[6]), cacheRead: num(r[7]), cacheWrite: num(r[8]), totalTokens: num(r[9]),
+        costUsd: num(r[10]),
+        unpriced: num(r[11]) > 0,
+        durationMs: numOrNull(r[12]),
+        ttftMs: numOrNull(r[13]),
+        stopReason: r[14] ?? '',
+        errorMessage: r[15] || null,
+        agentType: r[16] ?? '',
+        sessionFile: r[17] ?? '',
+        entryId: r[18] ?? '',
+    }));
+    const errorRows = requestRows(out.get('errors') ?? []);
+    const errorCounts = new Map();
+    for (const row of errorRows) {
+        const key = `${row.model}\u0000${row.provider}`;
+        const hit = errorCounts.get(key);
+        if (hit)
+            hit.count += 1;
+        else
+            errorCounts.set(key, { model: row.model, provider: row.provider, count: 1 });
+    }
+    const byModel = (out.get('byModel') ?? [])
+        .map((r) => rowOf(r[0] ?? '', parseFacts(r, 2), 0, r[1] ?? ''));
+    return {
+        overall: overallOf(parseFacts(out.get('overall')?.[0], 0)),
+        byModel,
+        byProvider: (out.get('byProvider') ?? []).map((r) => rowOf(r[0] ?? '', parseFacts(r, 2), num(r[1]), r[0] ?? '')),
+        byProject: (out.get('byProject') ?? []).map((r) => rowOf(r[0] ?? '', parseFacts(r, 1), 0)),
+        byAgentType: (out.get('byAgentType') ?? []).map((r) => {
+            const f = parseFacts(r, 1);
+            return { ...mix(f), agentType: r[0] ?? '', requests: f.requests, costUsd: f.costUsd };
+        }),
+        series: (out.get('series') ?? []).map((r) => ({
+            ts: num(r[0]), requests: num(r[1]), errors: num(r[2]), tokens: num(r[3]), costUsd: num(r[4]),
+        })),
+        hourOfDay: (out.get('hourOfDay') ?? []).map((r) => ({
+            hour: num(r[0]), requests: num(r[1]), errors: num(r[2]), tokens: num(r[3]), costUsd: num(r[4]),
+        })),
+        recent: requestRows(out.get('recent') ?? []),
+        errorGroups: groupErrors(errorRows),
+        errors: errorRows,
+        errorModels: [...errorCounts.values()].toSorted((a, b) => b.count - a.count),
+        traces: traces,
+    };
+}
+/** Fold every child transcript into its root session, or a row per file would show one row per subagent. */
+function foldTraces(rows) {
+    const byRoot = new Map();
+    for (const row of rows) {
+        const rootFile = rootSessionFile(row.sessionFile);
+        const held = byRoot.get(rootFile);
+        if (!held) {
+            byRoot.set(rootFile, { ...row, sessionFile: rootFile, models: [...row.models] });
+            continue;
+        }
+        held.requests += row.requests;
+        held.tokens += row.tokens;
+        held.costUsd += row.costUsd;
+        held.unpriced += row.unpriced;
+        held.models = [...new Set([...held.models, ...row.models])].toSorted();
+        held.firstTs = Math.min(held.firstTs, row.firstTs);
+        held.lastTs = Math.max(held.lastTs, row.lastTs);
+        held.subagents += 1;
+    }
+    return [...byRoot.values()]
+        .map((row) => ({ ...row, models: row.models.toSorted() }))
+        .toSorted((a, b) => b.lastTs - a.lastTs);
+}
+/** The root session file for a transcript, which is itself when it is already a root. */
+export function rootSessionFile(sessionFile) {
+    const marker = '/sessions/';
+    const at = sessionFile.indexOf(marker);
+    if (at < 0)
+        return sessionFile;
+    const base = sessionFile.slice(0, at + marker.length);
+    const parts = sessionFile.slice(at + marker.length).split('/');
+    // `<project>/<root>.jsonl` is a root; `<project>/<root>/<child>.jsonl` belongs to that root.
+    if (parts.length < 3)
+        return sessionFile;
+    return `${base}${parts[0]}/${parts[1]}.jsonl`;
+}
+/** Same normalization as the reference: ids and counters collapse, an HTTP status does not. */
+const UUID_RE = /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi;
+const PREFIXED_ID_RE = /\b(?:req|msg|call|toolu|chatcmpl|resp|run|gen)[-_][A-Za-z0-9_-]{6,}/g;
+const HEX_RE = /\b[0-9a-f]{12,}\b/gi;
+const NUMBER_RE = /(?<![\w.-])\d+(?:\.\d+)?/g;
+const HTTP_STATUS_RE = /^[1-5]\d\d$/;
+const SIGNATURE_MAX = 180;
+export function errorSignature(message) {
+    if (!message?.trim())
+        return 'Unknown error';
+    const normalized = message
+        .replace(/\s+/g, ' ')
+        .trim()
+        .replace(UUID_RE, '<id>')
+        .replace(PREFIXED_ID_RE, '<id>')
+        .replace(HEX_RE, '<hex>')
+        .replace(NUMBER_RE, (n) => (HTTP_STATUS_RE.test(n) ? n : 'N'));
+    return normalized.length > SIGNATURE_MAX ? `${normalized.slice(0, SIGNATURE_MAX - 1)}…` : normalized;
+}
+function groupErrors(rows) {
+    const groups = new Map();
+    for (const row of rows) {
+        const signature = errorSignature(row.errorMessage);
+        const hit = groups.get(signature);
+        if (!hit) {
+            groups.set(signature, {
+                signature, count: 1, firstSeen: row.ts, lastSeen: row.ts, latest: row,
+                models: [{ model: row.model, provider: row.provider, count: 1 }],
+            });
+            continue;
+        }
+        hit.count += 1;
+        hit.firstSeen = Math.min(hit.firstSeen, row.ts);
+        hit.lastSeen = Math.max(hit.lastSeen, row.ts);
+        const model = hit.models.find((m) => m.model === row.model && m.provider === row.provider);
+        if (model)
+            model.count += 1;
+        else
+            hit.models.push({ model: row.model, provider: row.provider, count: 1 });
+        if (row.ts >= hit.latest.ts)
+            hit.latest = row;
+    }
+    return [...groups.values()]
+        .map((g) => ({ ...g, models: g.models.toSorted((a, b) => b.count - a.count) }))
+        .toSorted((a, b) => b.count - a.count || b.lastSeen - a.lastSeen);
+}
+function readProviderSeries(db, cutoff, bucketMs) {
+    const out = readBlocks(db, [['providerSeries', `SELECT ${COL.provider}, (${COL.bucket} / ${bucketMs}) * ${bucketMs},
+      COUNT(*), SUM(${COL.total}), TOTAL(${COL.costTotal})
+      FROM ${SOURCE} ${rangeWhere(cutoff, COL.timestamp)} GROUP BY 1, 2 ORDER BY 1, 2`]]);
+    const perProvider = new Map();
+    for (const r of out.get('providerSeries') ?? []) {
+        const provider = r[0] ?? '';
+        const held = perProvider.get(provider) ?? { cost: 0, points: [] };
+        const point = { ts: num(r[1]), requests: num(r[2]), errors: 0, tokens: num(r[3]), costUsd: num(r[4]) };
+        held.points.push(point);
+        held.cost += point.costUsd;
+        perProvider.set(provider, held);
+    }
+    return [...perProvider.entries()]
+        .toSorted((a, b) => b[1].cost - a[1].cost)
+        .slice(0, SERIES_PROVIDERS)
+        .map(([provider, held]) => ({ provider, points: held.points }));
+}
+/** Tool calls from each message's names array: a name is one whole call, so per-call sizes read as zero. */
+function readToolSeries(db, cutoff, bucketMs) {
+    const where = `WHERE ${COL.timestamp} >= ${Math.floor(cutoff)}`;
+    const names = `CASE WHEN m.tools LIKE '[%' THEN m.tools ELSE '[]' END`;
+    const from = `${SOURCE}, json_each(${names}) te`;
+    const facts = `
+    ${COL.timestamp},
+    te.value, ${COL.model}, ${COL.provider},
+    COUNT(*),
+    TOTAL(${COL.total}),
+    TOTAL(${COL.output}),
+    TOTAL(${COL.costTotal}),
+    MAX(${COL.timestamp})`;
+    const out = readBlocks(db, [
+        ['byTool', `SELECT ${facts} FROM ${from} ${where} GROUP BY te.value ORDER BY 5 DESC`],
+        ['byToolModel', `SELECT ${facts} FROM ${from} ${where} GROUP BY te.value, ${COL.model}, ${COL.provider}
+      ORDER BY 5 DESC LIMIT ${TOOL_MODEL_LIMIT}`],
+        ['toolSeries', `SELECT (${COL.bucket} / ${bucketMs}) * ${bucketMs}, te.value, COUNT(*),
+      SUM(CASE WHEN ${COL.stopReason} = 'error' THEN 1 ELSE 0 END)
+      FROM ${from} ${where} GROUP BY 1, 2 ORDER BY 1`],
+    ]);
+    const parseTool = (r) => ({
+        tool: r[1] ?? '',
+        calls: num(r[4]),
+        errors: 0,
+        argsChars: 0,
+        resultChars: 0,
+        totalTokensShare: num(r[5]),
+        outputTokensShare: num(r[6]),
+        costShare: num(r[7]),
+        unpricedShare: 0,
+        lastUsed: numOrNull(r[8]),
+        model: r[2] ?? '',
+        provider: r[3] ?? '',
+    });
+    return {
+        tools: (out.get('byTool') ?? []).map(parseTool),
+        toolsByModel: (out.get('byToolModel') ?? []).map(parseTool),
+        toolSeries: (out.get('toolSeries') ?? []).map((r) => ({
+            ts: num(r[0]), tool: r[1] ?? '', calls: num(r[2]), errors: num(r[3]),
+        })),
+    };
+}
+/** Tool calls per root session, with every child transcript folded in. */
+function readTraceToolCounts(db) {
+    const counts = new Map();
+    try {
+        const names = `CASE WHEN m.tools LIKE '[%' THEN m.tools ELSE '[]' END`;
+        const out = sqliteScript(db, `SELECT ${COL.session}, COUNT(*) FROM ${SOURCE}, json_each(${names}) te GROUP BY 1;\n`);
+        for (const line of out.split('\n')) {
+            if (!line.trim())
+                continue;
+            const [file, count] = line.split('\t');
+            if (!file)
+                continue;
+            const root = rootSessionFile(file);
+            counts.set(root, (counts.get(root) ?? 0) + num(count));
+        }
+    }
+    catch { /* no tool rows: keep zero */ }
+    return counts;
+}
+/** Distinct models per root session, with every child transcript folded in. */
+function readTraceModels(db) {
+    const models = new Map();
+    try {
+        const out = sqliteScript(db, `SELECT ${COL.session}, ${COL.model} FROM ${SOURCE} GROUP BY 1, 2;\n`);
+        for (const line of out.split('\n')) {
+            if (!line.trim())
+                continue;
+            const [file, model] = line.split('\t');
+            if (!file || !model)
+                continue;
+            const set = models.get(rootSessionFile(file)) ?? new Set();
+            set.add(model);
+            models.set(rootSessionFile(file), set);
+        }
+    }
+    catch { /* an unreadable table leaves the list empty */ }
+    return new Map([...models.entries()].map(([file, set]) => [file, [...set].toSorted()]));
+}
+/** A session's title and cwd: the `session` line carries the directory and the `title` line sits above it. */
+function applySessionMetadata(traces) {
+    for (const trace of traces) {
+        if (!trace.sessionFile.endsWith('.jsonl'))
+            continue;
+        let fd = null;
+        try {
+            fd = fs.openSync(trace.sessionFile, 'r');
+            const buffer = Buffer.alloc(32 * 1024);
+            const read = fs.readSync(fd, buffer, 0, buffer.length, 0);
+            for (const line of buffer.toString('utf8', 0, read).split('\n')) {
+                if (!line.trim())
+                    continue;
+                if (line.includes('"cwd"') && !trace.cwd) {
+                    const match = line.match(/"cwd"\s*:\s*"([^"]+)"/);
+                    if (match)
+                        trace.cwd = match[1];
+                }
+                if (line.includes('"title"') && !trace.title) {
+                    const match = line.match(/"title"\s*:\s*"([^"]*)"/);
+                    if (match)
+                        trace.title = match[1] || null;
+                }
+                if (trace.cwd && trace.title)
+                    break;
+            }
+        }
+        catch { /* a file that no longer reads keeps its empty metadata */ }
+        finally {
+            if (fd !== null)
+                fs.closeSync(fd);
+        }
+    }
+}
+/** Daily tokens and cost for the busiest models: the Models table sparkline. */
+function readModelSeries(db, cutoff, bucketMs) {
+    const scope = rangeWhere(cutoff, COL.timestamp);
+    const top = `${COL.model} IN (SELECT ${COL.model} FROM ${SOURCE} ${scope} GROUP BY ${COL.model} ORDER BY COUNT(*) DESC LIMIT ${SERIES_MODELS})`;
+    const clause = scope ? `${scope} AND ${top}` : `WHERE ${top}`;
+    const out = readBlocks(db, [['modelSeries', `SELECT ${COL.model}, (${COL.bucket} / ${bucketMs}) * ${bucketMs},
+      COUNT(*), SUM(${COL.total}), TOTAL(${COL.costTotal}) FROM ${SOURCE} ${clause} GROUP BY 1, 2 ORDER BY 1, 2`]]);
+    const perModel = new Map();
+    for (const r of out.get('modelSeries') ?? []) {
+        const model = r[0] ?? '';
+        const points = perModel.get(model) ?? [];
+        points.push({ ts: num(r[1]), requests: num(r[2]), errors: 0, tokens: num(r[3]), costUsd: num(r[4]) });
+        perModel.set(model, points);
+    }
+    return [...perModel.entries()].map(([model, points]) => ({ model, points }));
+}
+/** Per-bucket throughput and ttft for the busiest models; a null average means no request carried timing. */
+function readModelPerformance(db, cutoff, bucketMs) {
+    const scope = rangeWhere(cutoff, COL.timestamp);
+    const top = `${COL.model} IN (SELECT ${COL.model} FROM ${SOURCE} ${scope} GROUP BY ${COL.model} ORDER BY COUNT(*) DESC LIMIT ${SERIES_MODELS})`;
+    const clause = scope ? `${scope} AND ${top}` : `WHERE ${top}`;
+    const out = readBlocks(db, [['modelPerformance', `SELECT ${COL.model}, ${COL.provider}, (${COL.bucket} / ${bucketMs}) * ${bucketMs},
+      COUNT(*),
+      TOTAL(CASE WHEN ${COL.duration} > 0 THEN ${COL.output} * 1000.0 / ${COL.duration} END),
+      COUNT(CASE WHEN ${COL.duration} > 0 THEN 1 END),
+      TOTAL(${COL.ttft}),
+      COUNT(${COL.ttft})
+      FROM ${SOURCE} ${clause} GROUP BY 1, 2, 3 ORDER BY 1, 2, 3`]]);
+    const groups = new Map();
+    for (const r of out.get('modelPerformance') ?? []) {
+        const key = `${r[0] ?? ''}\u0000${r[1] ?? ''}`;
+        const group = groups.get(key) ?? { model: r[0] ?? '', provider: r[1] ?? '', points: [] };
+        const durationN = num(r[5]);
+        const ttftN = num(r[7]);
+        group.points.push({
+            ts: num(r[2]),
+            requests: num(r[3]),
+            avgTokensPerSecond: durationN > 0 ? num(r[4]) / durationN : null,
+            avgTtftMs: ttftN > 0 ? num(r[6]) / ttftN : null,
+        });
+        groups.set(key, group);
+    }
+    return [...groups.values()];
+}
+/** Reference constants for the quota half, copied from the omp implementation. */
+const WINDOW_RESET_DROP = 0.05;
+const WINDOW_MIN_EXTRAPOLATION = 0.1;
+const WINDOW_TARGET_PEAK = 0.9;
+const WINDOW_EXHAUSTED = 0.999;
+const WINDOW_MAX_POINTS = 400;
+/** Peak per bucket, so a utilization spike survives the cap. */
+function downsampleWindow(points) {
+    if (points.length <= WINDOW_MAX_POINTS)
+        return points;
+    const first = points[0].ts;
+    const last = points[points.length - 1].ts;
+    const bucket = Math.max(1, Math.ceil((last - first) / WINDOW_MAX_POINTS));
+    const out = [];
+    let mark = -1;
+    for (const point of points) {
+        const b = Math.floor((point.ts - first) / bucket);
+        if (b !== mark) {
+            out.push(point);
+            mark = b;
+            continue;
+        }
+        const held = out[out.length - 1];
+        if ((point.usedFraction ?? -1) >= (held.usedFraction ?? -1))
+            out[out.length - 1] = point;
+    }
+    return out;
+}
+/** Peak summed quota across accounts, forward-filling last known fractions (1.7 = 1.7 windows held). */
+function peakConcurrent(samples) {
+    const events = samples.filter((sample) => sample.usedFraction !== null).toSorted((a, b) => a.ts - b.ts);
+    const current = new Map();
+    let sum = 0;
+    let peak = 0;
+    for (const event of events) {
+        const fraction = event.usedFraction ?? 0;
+        sum += fraction - (current.get(event.accountKey) ?? 0);
+        current.set(event.accountKey, fraction);
+        if (sum > peak)
+            peak = sum;
+    }
+    return peak;
+}
+/** The limit label, plus the window label when it adds information. */
+function windowDisplayLabel(sample) {
+    if (!sample.windowLabel || sample.label.toLowerCase().includes(sample.windowLabel.toLowerCase()))
+        return sample.label;
+    return `${sample.label} · ${sample.windowLabel}`;
+}
+/** Quota snapshots from agent.db, oldest first. Windows group by provider and limit id. */
+function readWindowSamples(cutoff) {
+    const db = agentDbPath();
+    if (!fs.existsSync(db) || tableColumns(db, 'usage_history').size === 0)
+        return [];
+    const out = readBlocks(db, [['windows', `SELECT ${txt('provider')}, ${txt('account_key')},
+      ${txt('email')}, ${txt('account_id')}, ${txt('limit_id')}, ${txt('label')}, ${txt('window_label')},
+      used_fraction, status, recorded_at
+      FROM usage_history ${rangeWhere(cutoff, 'recorded_at')} ORDER BY recorded_at`]]);
+    return (out.get('windows') ?? []).map((r) => {
+        const usedFraction = numOrNull(r[7]);
+        const status = r[8] || null;
+        return {
+            provider: r[0] ?? '',
+            accountKey: r[1] ?? '',
+            accountLabel: r[2] || r[3] || r[1] || '',
+            limitId: r[4] ?? '',
+            label: r[5] ?? '',
+            windowLabel: r[6] ?? '',
+            ts: num(r[9]),
+            usedFraction,
+            exhausted: status === 'exhausted' || (usedFraction !== null && usedFraction >= WINDOW_EXHAUSTED),
+        };
+    });
+}
+/** Window utilization; a window is one `(provider, limitId)` pair, since limits can share a duration. */
+function computeWindows(samples, tokensByProvider) {
+    const groups = new Map();
+    for (const sample of samples) {
+        const key = `${sample.provider}\u0000${sample.limitId}`;
+        const held = groups.get(key);
+        if (held)
+            held.push(sample);
+        else
+            groups.set(key, [sample]);
+    }
+    const usageSeries = [];
+    const windowInsights = [];
+    for (const group of groups.values()) {
+        const first = group[0];
+        const windowLabel = windowDisplayLabel(group[group.length - 1]);
+        const accounts = new Map();
+        for (const sample of group) {
+            const held = accounts.get(sample.accountKey);
+            if (held)
+                held.push(sample);
+            else
+                accounts.set(sample.accountKey, [sample]);
+        }
+        let fractionConsumed = 0;
+        let cycles = 0;
+        let exhaustedEvents = 0;
+        for (const [accountKey, accountSamples] of accounts) {
+            usageSeries.push({
+                provider: first.provider,
+                accountKey,
+                accountLabel: accountSamples[accountSamples.length - 1].accountLabel,
+                windowKey: first.limitId,
+                windowLabel,
+                points: downsampleWindow(accountSamples.map((sample) => ({
+                    ts: sample.ts,
+                    usedFraction: round4(sample.usedFraction),
+                    exhausted: sample.exhausted,
+                }))),
+            });
+            let previous = null;
+            let wasExhausted = false;
+            for (const sample of accountSamples) {
+                if (sample.exhausted && !wasExhausted)
+                    exhaustedEvents += 1;
+                wasExhausted = sample.exhausted;
+                if (sample.usedFraction === null)
+                    continue;
+                if (previous !== null) {
+                    const delta = sample.usedFraction - previous;
+                    if (delta > 0)
+                        fractionConsumed += delta;
+                    else if (delta < -WINDOW_RESET_DROP)
+                        cycles += 1;
+                }
+                previous = sample.usedFraction;
+            }
+        }
+        const providerTokens = tokensByProvider.get(first.provider) ?? 0;
+        const peak = peakConcurrent(group);
+        windowInsights.push({
+            provider: first.provider,
+            windowKey: first.limitId,
+            windowLabel,
+            accounts: accounts.size,
+            cycles,
+            fractionConsumed,
+            estTokensPerWindow: providerTokens > 0 && fractionConsumed >= WINDOW_MIN_EXTRAPOLATION
+                ? Math.round(providerTokens / fractionConsumed)
+                : null,
+            peakConcurrentFraction: peak,
+            idealAccounts: Math.max(1, Math.ceil(peak / WINDOW_TARGET_PEAK)),
+            exhaustedEvents,
+        });
+    }
+    usageSeries.sort((a, b) => a.provider.localeCompare(b.provider) ||
+        a.windowKey.localeCompare(b.windowKey) ||
+        a.accountLabel.localeCompare(b.accountLabel));
+    windowInsights.sort((a, b) => a.provider.localeCompare(b.provider) || b.fractionConsumed - a.fractionConsumed);
+    return { usageSeries, windowInsights };
+}
+/** Tokens per provider over the range: the currency a window insight extrapolates in. */
+function readProviderTokens(db, cutoff) {
+    const out = readBlocks(db, [['providerTokens', `SELECT ${COL.provider}, SUM(${COL.total})
+      FROM ${SOURCE} ${rangeWhere(cutoff, COL.timestamp)} GROUP BY 1`]]);
+    return new Map((out.get('providerTokens') ?? []).map((r) => [r[0] ?? '', num(r[1])]));
+}
+/** Peak burn hours: one row per provider per local hour, the shape the reference charts. */
+function readProviderHourly(db, cutoff) {
+    const out = readBlocks(db, [['providerHourly', `SELECT ${COL.provider},
+      CAST(strftime('%H', ${COL.bucket} / 1000, 'unixepoch', 'localtime') AS INTEGER),
+      SUM(${COL.total}), SUM(${COL.output}), COUNT(*)
+      FROM ${SOURCE} ${rangeWhere(cutoff, COL.timestamp)} GROUP BY 1, 2`]]);
+    return (out.get('providerHourly') ?? []).map((r) => ({
+        provider: r[0] ?? '',
+        hour: num(r[1]),
+        totalTokens: num(r[2]),
+        outputTokens: num(r[3]),
+        requests: num(r[4]),
+    }));
+}
+/** Middle value, ignoring nulls. The Requests page summarises latency this way. */
+function median(values) {
+    const nums = values.filter((v) => typeof v === 'number' && Number.isFinite(v)).toSorted((a, b) => a - b);
+    if (nums.length === 0)
+        return 0;
+    const mid = nums.length >> 1;
+    return nums.length % 2 ? nums[mid] : (nums[mid - 1] + nums[mid]) / 2;
+}
+/** Requests summary; percentiles stay over the capped slice, so a p95 of 200 of 2,400 describes those 200. */
+function computeRequestStats(rows, range) {
+    const durations = rows.map((row) => row.durationMs);
+    const sorted = durations.filter((v) => typeof v === 'number' && Number.isFinite(v)).toSorted((a, b) => a - b);
+    const pick = (q) => (sorted.length === 0 ? 0 : sorted[Math.min(sorted.length - 1, Math.floor(q * sorted.length))]);
+    const times = rows.map((row) => row.ts);
+    return {
+        requests: range ? range.requests : rows.length,
+        failed: range ? range.failed : rows.filter((row) => row.stopReason === 'error').length,
+        aborted: rows.filter((row) => row.stopReason === 'aborted').length,
+        tokens: range ? range.total : rows.reduce((sum, row) => sum + row.totalTokens, 0),
+        costUsd: range ? range.costUsd : rows.reduce((sum, row) => sum + row.costUsd, 0),
+        unpriced: range ? range.unpricedRequests : rows.filter((row) => row.unpriced).length,
+        shipped: rows.length,
+        medianDurationMs: median(durations),
+        p95DurationMs: pick(0.95),
+        medianTtftMs: median(rows.map((row) => row.ttftMs)),
+        oldest: range ? range.firstTs : times.length ? Math.min(...times) : null,
+        newest: range ? range.lastTs : times.length ? Math.max(...times) : null,
+    };
+}
+/** How many spans one trace ships. A long session holds thousands; the transcript virtualises. */
+const TRACE_SPAN_LIMIT = 6000;
+/** How much of a message body a span carries: enough for one transcript line. */
+const TRACE_DETAIL_MAX = 120;
+/** First non-empty line of a message body, for the span's detail line. */
+function firstLine(parts) {
+    const text = parts
+        .map((part) => String(part.text ?? part.thinking ?? ''))
+        .map((value) => value.replace(/\s+/g, ' ').trim())
+        .find(Boolean);
+    return text ? text.slice(0, TRACE_DETAIL_MAX) : '';
+}
+/** How a request stopped, read from the assistant message's stop reason. */
+function stopState(stopReason) {
+    if (stopReason === 'error')
+        return 'failed';
+    if (stopReason === 'aborted')
+        return 'aborted';
+    return 'completed';
+}
+/** Tool names that hand the work to another agent, for the Agents figure. */
+const AGENT_TOOLS = new Set(['task', 'subagent']);
+/** One transcript as spans, tracks and markers: a model span runs `ts - duration` to `ts`. */
+export function readSessionTrace(sessionFile, limit = TRACE_SPAN_LIMIT) {
+    const project = sessionFile.split('/sessions/')[1]?.split('/')[0] ?? '';
+    const empty = {
+        sessionFile, project, title: '', cwd: project, startedAt: 0, endedAt: 0,
+        tracks: [], markers: [], summary: emptyTraceSummary(), toolStats: [], truncated: false,
+    };
+    if (!sessionFile.endsWith('.jsonl') || !fs.existsSync(sessionFile))
+        return empty;
+    let text;
+    try {
+        text = fs.readFileSync(sessionFile, 'utf8');
+    }
+    catch {
+        return empty;
+    }
+    const raw = [];
+    const markers = [];
+    let title = '';
+    let truncated = false;
+    for (const line of text.split('\n')) {
+        if (!line.trim())
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const entryId = String(parsed.id ?? '');
+        // The line's stamp is when the entry landed; the message's own stamp, a number, is when it began.
+        const ts = Date.parse(String(parsed.timestamp ?? '')) || 0;
+        const own = parsed.message?.timestamp;
+        const startAt = typeof own === 'number' && Number.isFinite(own) ? own : null;
+        if (parsed.type !== 'message') {
+            const marker = markerFor(entryId, ts, parsed);
+            if (marker)
+                markers.push(marker);
+            if (parsed.type === 'title' && typeof parsed.title === 'string')
+                title = parsed.title;
+            continue;
+        }
+        const message = (parsed.message ?? {});
+        const content = Array.isArray(message.content) ? message.content : [];
+        const usage = (message.usage ?? {});
+        const cost = (usage.cost ?? {});
+        raw.push({
+            entryId,
+            ts,
+            role: String(message.role ?? ''),
+            tool: String(message.toolName ?? ''),
+            detail: firstLine(content),
+            model: String(message.model ?? ''),
+            provider: String(message.provider ?? ''),
+            tokens: num(String(usage.totalTokens ?? 0)),
+            costUsd: num(String(cost.total ?? 0)),
+            durationMs: typeof message.duration === 'number' ? message.duration : null,
+            startAt,
+            isError: message.isError === true,
+            stopped: stopState(String(message.stopReason ?? '')),
+            callId: String(message.toolCallId ?? ''),
+            calls: content
+                .filter((part) => part.type === 'toolCall')
+                .map((part) => ({ id: String(part.id ?? ''), name: String(part.name ?? 'tool') })),
+        });
+    }
+    // A tool result closes the call it names, so the call's span runs to it.
+    const resultAt = new Map();
+    const callIds = new Set();
+    for (const row of raw) {
+        for (const call of row.calls)
+            if (call.id)
+                callIds.add(call.id);
+        if (row.role === 'toolResult' && row.callId && !resultAt.has(row.callId))
+            resultAt.set(row.callId, row);
+    }
+    const built = [];
+    let turnOpen = null;
+    for (const row of raw) {
+        const base = {
+            model: row.model, provider: row.provider, tokens: row.tokens, costUsd: row.costUsd,
+            isError: row.isError, entryId: row.entryId,
+        };
+        if (row.role === 'assistant') {
+            // A model call runs from its own start stamp to the line's stamp; the duration is the cross-check.
+            const start = row.startAt !== null && row.startAt < row.ts ? row.startAt : row.durationMs && row.durationMs > 0 ? row.ts - row.durationMs : row.ts;
+            if (turnOpen)
+                turnOpen.end = start;
+            turnOpen = null;
+            built.push({ ...base, id: row.entryId || `model-${built.length}`, kind: 'model', label: row.model || 'assistant',
+                detail: row.detail, start, end: row.ts, tool: '', stopped: row.stopped });
+            row.calls.forEach((call, index) => {
+                const result = call.id ? resultAt.get(call.id) : undefined;
+                const end = result ? Math.max(result.ts, row.ts) : row.ts;
+                built.push({ ...base, id: `${row.entryId}#${index}`, kind: 'tool', label: call.name, detail: result?.detail ?? '',
+                    start: row.ts, end, tool: call.name, isError: result ? result.isError : base.isError, stopped: 'completed' });
+            });
+            continue;
+        }
+        if (row.role === 'toolResult') {
+            // A result whose call was compacted away still ran: draw it as a point.
+            if (row.callId && callIds.has(row.callId))
+                continue;
+            built.push({ ...base, id: row.entryId || `tool-${built.length}`, kind: 'tool', label: row.tool || 'tool',
+                detail: row.detail, start: row.ts, end: row.ts, tool: row.tool, stopped: 'completed' });
+            continue;
+        }
+        if (row.role === 'user') {
+            if (turnOpen)
+                turnOpen.end = row.ts;
+            turnOpen = { ...base, id: `turn-${built.length}`, kind: 'turn', label: 'Prompt', detail: row.detail,
+                start: row.ts, end: row.ts, tool: '', stopped: 'completed' };
+            built.push(turnOpen);
+            continue;
+        }
+        built.push({ ...base, id: row.entryId || `bg-${built.length}`, kind: 'background', label: row.role || 'system',
+            detail: row.detail, start: row.ts, end: row.ts, tool: '', stopped: 'completed' });
+    }
+    const lastEnd = built.reduce((max, span) => Math.max(max, span.end), 0);
+    if (turnOpen)
+        turnOpen.end = Math.max(turnOpen.end, lastEnd);
+    // A session longer than the cap keeps its newest spans: the opening minutes are the least useful.
+    const spans = built.length > limit ? built.slice(-limit) : built;
+    if (built.length > limit)
+        truncated = true;
+    spans.sort((a, b) => a.start - b.start);
+    const startedAt = spans.length ? Math.min(...spans.map((span) => span.start)) : 0;
+    const endedAt = spans.length ? Math.max(...spans.map((span) => span.end)) : 0;
+    return {
+        sessionFile, project, title, cwd: project, startedAt, endedAt,
+        tracks: [{ id: 'main', label: 'Session', parentId: null, spans }],
+        markers: markers.toSorted((a, b) => a.ts - b.ts),
+        summary: summarizeTrace(spans, startedAt, endedAt),
+        toolStats: buildToolStats(spans),
+        truncated,
+    };
+}
+/** A non-message journal entry, when it marks a change worth a diamond on the timeline. */
+function markerFor(entryId, ts, parsed) {
+    const kind = String(parsed.type ?? '');
+    if (kind === 'model_change')
+        return { id: entryId || `model-${ts}`, ts, kind: 'model', label: String(parsed.model ?? 'model') };
+    if (kind === 'thinking_level_change') {
+        return { id: entryId || `think-${ts}`, ts, kind: 'think', label: String(parsed.level ?? 'thinking') };
+    }
+    if (kind === 'session')
+        return { id: entryId || `session-${ts}`, ts, kind: 'session', label: 'session started' };
+    // Only the changes ride along: a session fires hundreds of events that would bury the diamonds.
+    return null;
+}
+/** The empty summary, for a file that no longer reads. */
+function emptyTraceSummary() {
+    return { wallMs: 0, modelMs: 0, toolMs: 0, idleMs: 0, turns: 0, requests: 0, toolCalls: 0, agents: 0, totalTokens: 0, costUsd: 0 };
+}
+/** The nine figures: wall time split into model, tool, and idle, then the work counts. */
+function summarizeTrace(spans, startedAt, endedAt) {
+    const wallMs = endedAt > startedAt ? endedAt - startedAt : 0;
+    let modelMs = 0;
+    let toolMs = 0;
+    let totalTokens = 0;
+    let costUsd = 0;
+    for (const span of spans) {
+        const held = Math.max(0, span.end - span.start);
+        if (span.kind === 'model')
+            modelMs += held;
+        if (span.kind === 'tool')
+            toolMs += held;
+        if (span.kind === 'model')
+            totalTokens += span.tokens;
+        if (span.kind === 'model')
+            costUsd += span.costUsd;
+    }
+    return {
+        wallMs,
+        modelMs,
+        toolMs,
+        // Idle is what no span covered: wall time minus the time a model or a tool held.
+        idleMs: Math.max(0, wallMs - modelMs - toolMs),
+        turns: spans.filter((span) => span.kind === 'turn').length,
+        requests: spans.filter((span) => span.kind === 'model').length,
+        toolCalls: spans.filter((span) => span.kind === 'tool').length,
+        agents: spans.filter((span) => span.kind === 'tool' && AGENT_TOOLS.has(span.tool)).length,
+        totalTokens,
+        costUsd,
+    };
+}
+/** Per-tool duration totals, longest first. */
+function buildToolStats(spans) {
+    const byTool = new Map();
+    for (const span of spans) {
+        if (span.kind !== 'tool')
+            continue;
+        const held = Math.max(0, span.end - span.start);
+        const list = byTool.get(span.tool || 'tool') ?? [];
+        list.push(held);
+        byTool.set(span.tool || 'tool', list);
+    }
+    return [...byTool.entries()]
+        .map(([tool, held]) => {
+        const sorted = held.toSorted((a, b) => a - b);
+        const totalMs = sorted.reduce((sum, value) => sum + value, 0);
+        return {
+            tool,
+            calls: held.length,
+            errors: spans.filter((span) => span.kind === 'tool' && (span.tool || 'tool') === tool && span.isError).length,
+            totalMs,
+            avgMs: totalMs / Math.max(1, sorted.length),
+            maxMs: sorted[held.length - 1] ?? 0,
+        };
+    })
+        .toSorted((a, b) => b.totalMs - a.totalMs);
+}
+/** The payload a request with no readable entry returns, so the route always answers with one shape. */
+export function emptyRequestEntry() {
+    return { entry: null, output: null, messageRole: '', agent: { model: null, thinkingLevel: null, mode: null, fallback: null } };
+}
+/** One request's journal payload; empty when the entry journals nothing or its session is gone. */
+export function readAgentRequestEntry(sessionFile, entryId) {
+    const empty = emptyRequestEntry();
+    if (!entryId || !sessionFile.endsWith('.jsonl') || !fs.existsSync(sessionFile))
+        return empty;
+    let text;
+    try {
+        text = fs.readFileSync(sessionFile, 'utf8');
+    }
+    catch {
+        return empty;
+    }
+    const agent = { ...empty.agent };
+    for (const line of text.split('\n')) {
+        if (!line.trim())
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (String(parsed.id ?? '') !== entryId) {
+            // A change entry updates the state every later request sees.
+            if (parsed.type === 'model_change') {
+                agent.model = String(parsed.model ?? '') || null;
+                agent.fallback = parsed.resolvedModelIsFallback === true;
+            }
+            else if (parsed.type === 'thinking_level_change') {
+                agent.thinkingLevel = String(parsed.thinkingLevel ?? '') || null;
+            }
+            else if (parsed.type === 'mode_change') {
+                agent.mode = String(parsed.mode ?? '') || null;
+            }
+            continue;
+        }
+        const message = (parsed.message ?? null);
+        return { entry: parsed, output: message, messageRole: message ? String(message.role ?? '') : '', agent };
+    }
+    return empty;
+}
+/** Reads the usage store; the caller runs `syncUsageDb`, so a poll never pays for a sync it did not start. */
+export function readAgentStats(range = '24h', view = 'all', now = Date.now(), offset = 0) {
+    const span = RANGE_MS[range];
+    const cutoff = span > 0 ? now - span : 0;
+    const parts = new Set(VIEW_PARTS[view]);
+    const stats = emptyAgentStats(range);
+    stats.cutoff = cutoff;
+    const db = statsDbPath();
+    const cols = fs.existsSync(db) ? tableColumns(db, 'messages') : new Set();
+    if (cols.size === 0) {
+        if (parts.has('windows'))
+            Object.assign(stats, computeWindows(readWindowSamples(cutoff), new Map()));
+        return stats;
+    }
+    // The bucket width depends on the span, so the bounds come first.
+    const bounds = readBlocks(db, [['bounds', `SELECT MIN(${COL.timestamp}), MAX(${COL.timestamp}) FROM ${SOURCE} ${rangeWhere(cutoff, COL.timestamp)}`]]);
+    const [firstTs, lastTs] = bounds.get('bounds')?.[0] ?? [];
+    stats.bucketMs = bucketSize(range, numOrNull(firstTs), numOrNull(lastTs));
+    Object.assign(stats, readStatsDb(db, cutoff, stats.bucketMs, parts, offset));
+    if (parts.has('seriesByProvider'))
+        stats.seriesByProvider = readProviderSeries(db, cutoff, stats.bucketMs);
+    if (parts.has('modelSeries'))
+        stats.modelSeries = readModelSeries(db, cutoff, stats.bucketMs);
+    if (parts.has('modelPerformance'))
+        stats.modelPerformance = readModelPerformance(db, cutoff, stats.bucketMs);
+    if (parts.has('tools'))
+        Object.assign(stats, readToolSeries(db, cutoff, stats.bucketMs));
+    if (stats.byModel.length > 0)
+        stats.topModels = stats.byModel.slice(0, 12);
+    if (parts.has('providerHourly'))
+        stats.providerHourly = readProviderHourly(db, cutoff);
+    if (parts.has('recent'))
+        stats.requestStats = computeRequestStats(stats.recent, stats.overall);
+    if (parts.has('windows')) {
+        Object.assign(stats, computeWindows(readWindowSamples(cutoff), readProviderTokens(db, cutoff)));
+    }
+    stats.available = true;
+    return stats;
+}