@krtclcdy/tersio 2.25.3 → 2.25.5

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

@@ -0,0 +1,1262 @@
+// extensions/shared/agent-stats.ts: read-only aggregate over the agent statistics databases.
+// Today that is omp's stats.db and agent.db, so the naming stays host-neutral. Every metric
+// matches @oh-my-pi/omp-stats: same SQL facts, same rules. Missing sqlite3 or a
+// missing table degrades to zeros, never to a thrown error.
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { SQLITE_READ_BUFFER } from './usage-ledger.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: ['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;
+export function statsDbPath() {
+    return process.env.TERSIO_AGENT_STATS_DB ?? path.join(os.homedir(), '.omp', 'stats.db');
+}
+export function agentDbPath() {
+    return process.env.TERSIO_AGENT_SESSIONS_DB ?? path.join(os.homedir(), '.omp', 'agent', 'agent.db');
+}
+/** 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,
+            medianDurationMs: 0, p95DurationMs: 0, medianTtftMs: 0, oldest: null, newest: null,
+        },
+        errors: [],
+    };
+}
+// ---------------------------------------------------------------- sqlite access
+/**
+ * The omp databases run in WAL mode. Ordered fallbacks, each verified against the live pair:
+ * `-readonly` needs the `-shm` side file, `immutable=1` silently ignores a WAL, and a copy of
+ * db + wal + shm replays the log to the same row count the running server reports.
+ */
+export function sqliteScript(db, script) {
+    if (!fs.existsSync(db))
+        throw new Error(`missing database: ${db}`);
+    const opts = {
+        encoding: 'utf8',
+        timeout: 30_000,
+        stdio: ['pipe', 'pipe', 'ignore'],
+        maxBuffer: SQLITE_READ_BUFFER,
+        input: script,
+    };
+    try {
+        return execFileSync('sqlite3', ['-separator', '\t', '-readonly', db], opts);
+    }
+    catch { /* the side files may be gone; try the next rung */ }
+    if (!fs.existsSync(`${db}-wal`)) {
+        try {
+            return execFileSync('sqlite3', ['-separator', '\t', `file:${db}?immutable=1`], opts);
+        }
+        catch { /* fall through to the copy */ }
+    }
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'tersio-omp-'));
+    const target = path.join(dir, path.basename(db));
+    try {
+        fs.copyFileSync(db, target);
+        for (const suffix of ['-wal', '-shm']) {
+            if (fs.existsSync(`${db}${suffix}`))
+                fs.copyFileSync(`${db}${suffix}`, `${target}${suffix}`);
+        }
+        return execFileSync('sqlite3', ['-separator', '\t', '-readonly', target], opts);
+    }
+    finally {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+}
+const BLOCK = '@@blk@@';
+function blocks(out) {
+    const map = new Map();
+    let current = null;
+    for (const line of out.split('\n')) {
+        if (!line)
+            continue;
+        if (line.startsWith(BLOCK)) {
+            current = [];
+            map.set(line.slice(BLOCK.length), current);
+            continue;
+        }
+        if (current)
+            current.push(line.split('\t'));
+    }
+    return map;
+}
+/**
+ * One sqlite3 call for a group of queries. A failing statement aborts the script, so the
+ * partial output is kept and only the missing blocks re-run one at a time.
+ */
+function readBlocks(db, queries) {
+    const script = queries.map(([name, sql]) => `SELECT '${BLOCK}${name}';\n${sql};\n`).join('');
+    try {
+        return blocks(sqliteScript(db, script));
+    }
+    catch (error) {
+        // A failing statement aborts the script, so its stdout holds every block that ran.
+        if (!error || typeof error !== 'object' || !('stdout' in error) || typeof error.stdout !== 'string')
+            throw error;
+        const merged = blocks(error.stdout);
+        for (const [name, sql] of queries) {
+            if (merged.has(name))
+                continue;
+            try {
+                for (const [k, rows] of blocks(sqliteScript(db, `SELECT '${BLOCK}${name}';\n${sql};\n`)))
+                    merged.set(k, rows);
+            }
+            catch { /* an unavailable table leaves its key absent */ }
+        }
+        return merged;
+    }
+}
+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), ' ')`;
+}
+// ------------------------------------------------------------------- sql builders
+/** The unpriced rule, copied from the reference: a subscription route with no price is not "free". */
+function unpricedSql(p = '') {
+    return `CASE WHEN ${p}total_tokens > 0 AND ${p}cost_total = 0
+    AND (${p}provider = 'xai-oauth' OR ${p}cost_unpriced = 1) THEN 1 ELSE 0 END`;
+}
+/** The additive facts every messages group reads. */
+function messageFacts(p = '') {
+    return [
+        'COUNT(*)',
+        `SUM(CASE WHEN ${p}stop_reason = 'error' THEN 1 ELSE 0 END)`,
+        `SUM(${p}input_tokens)`,
+        `SUM(${p}output_tokens)`,
+        `SUM(${p}cache_read_tokens)`,
+        `SUM(${p}cache_write_tokens)`,
+        `SUM(${p}total_tokens)`,
+        `TOTAL(${p}cost_total)`,
+        `TOTAL(${p}cost_input)`,
+        `TOTAL(${p}cost_cache_read)`,
+        `TOTAL(${p}cost_cache_write)`,
+        `SUM(${unpricedSql(p)})`,
+        `TOTAL(${p}duration)`,
+        `COUNT(${p}duration)`,
+        `TOTAL(${p}ttft)`,
+        `COUNT(${p}ttft)`,
+        `TOTAL(CASE WHEN ${p}duration > 0 THEN ${p}output_tokens * 1000.0 / ${p}duration END)`,
+        `COUNT(CASE WHEN ${p}duration > 0 THEN 1 END)`,
+        `MIN(${p}timestamp)`,
+        `MAX(${p}timestamp)`,
+        `MAX(${p}duration)`,
+    ].join(', ');
+}
+/** The zero and null literals an older omp schema needs in place of a named column. */
+const SHIMS = [
+    ['stop_reason', "''"],
+    ['cost_no_cache_input', '0'],
+    ['cost_input', '0'],
+    ['cost_cache_read', '0'],
+    ['cost_cache_write', '0'],
+    ['cost_unpriced', '0'],
+    ['provider', "''"],
+    ['folder', "''"],
+    ['agent_type', "''"],
+];
+/** Applies the shims: a column the table does not hold reads as its literal. */
+function withShims(sql, cols) {
+    let out = sql;
+    for (const [column, literal] of SHIMS) {
+        if (cols.has(column))
+            continue;
+        out = out.split(column).join(literal);
+    }
+    return out;
+}
+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;
+}
+// ------------------------------------------------------------------- the aggregate
+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);
+}
+// ------------------------------------------------------------------- the aggregate
+function readStatsDb(db, cutoff, bucketMs, cols, parts) {
+    const where = rangeWhere(cutoff);
+    const errCol = cols.has('error_message') ? txt('error_message') : "''";
+    const apiCol = cols.has('api') ? txt('api') : "''";
+    const errorWhere = `WHERE stop_reason = 'error'${cutoff > 0 ? ` AND timestamp >= ${Math.floor(cutoff)}` : ''}`;
+    const requestColumns = `timestamp, ${txt('provider')}, ${txt('model')}, ${txt('folder')}, ${apiCol},
+    input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, total_tokens,
+    cost_total, ${unpricedSql()}, duration, ttft, ${txt('stop_reason')}, ${errCol},
+    ${txt('agent_type')}, ${txt('session_file')}, ${txt('entry_id')}`;
+    const out = readBlocks(db, [
+        ['overall', `SELECT ${messageFacts()} FROM messages ${where}`],
+        ['byModel', `SELECT ${txt('model')}, ${txt('provider')}, ${messageFacts()} FROM messages ${where} GROUP BY model, provider ORDER BY 3 DESC`],
+        ['byProvider', `SELECT ${txt('provider')}, COUNT(DISTINCT model), ${messageFacts()} FROM messages ${where} GROUP BY provider ORDER BY 3 DESC`],
+        ['byAgentType', `SELECT ${txt('agent_type')}, ${messageFacts()} FROM messages ${where} GROUP BY 1 ORDER BY 2 DESC`],
+        ['byProject', `SELECT ${txt('folder')}, ${messageFacts()} FROM messages ${where} GROUP BY 1 ORDER BY 2 DESC`],
+        ['series', `SELECT (timestamp / ${bucketMs}) * ${bucketMs}, COUNT(*),
+        SUM(CASE WHEN stop_reason = 'error' THEN 1 ELSE 0 END),
+        SUM(total_tokens), TOTAL(cost_total) FROM messages ${where} GROUP BY 1 ORDER BY 1`],
+        ['hourOfDay', `SELECT CAST(strftime('%H', timestamp / 1000, 'unixepoch', 'localtime') AS INTEGER),
+        COUNT(*), SUM(CASE WHEN stop_reason = 'error' THEN 1 ELSE 0 END), SUM(total_tokens), TOTAL(cost_total)
+        FROM messages ${where} GROUP BY 1 ORDER BY 1`],
+        ['recent', `SELECT ${requestColumns} FROM messages ${where} ORDER BY timestamp DESC LIMIT ${RECENT_LIMIT}`],
+        ['errors', `SELECT ${requestColumns} FROM messages ${errorWhere} ORDER BY timestamp DESC LIMIT ${ERROR_LIMIT}`],
+        ['traces', `SELECT ${txt('session_file')}, MAX(${txt('folder')}),
+        COUNT(*), SUM(total_tokens), TOTAL(cost_total), SUM(${unpricedSql()}),
+        MIN(timestamp), MAX(timestamp + COALESCE(duration, 0))
+        FROM messages ${where} GROUP BY session_file ORDER BY 8 DESC LIMIT ${TRACE_LIMIT}`],
+    ].filter(([name]) => parts.has(name)).map(([name, sql]) => [name, withShims(sql, cols)]));
+    // The trace rows are read per file, then folded per root. The model list and the tool counts are
+    // read across every transcript and keyed by root, so a child that fell outside the window still
+    // folds into the session it belongs to.
+    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, the way the reference lists them.
+ *
+ * A subagent writes its own file under its root's folder, so a row grouped by file alone would
+ * show one row per subagent. Each root holds its children's requests, tokens, cost, models, and
+ * time, counts the children folded in, and keeps the row even when its own file is gone.
+ */
+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 ${txt('provider')}, (timestamp / ${bucketMs}) * ${bucketMs},
+      COUNT(*), SUM(total_tokens), TOTAL(cost_total)
+      FROM messages ${rangeWhere(cutoff)} 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 }));
+}
+function readToolSeries(db, cutoff, bucketMs) {
+    const cols = tableColumns(db, 'tool_calls');
+    if (!cols.has('tool_name'))
+        return {};
+    const join = 'LEFT JOIN messages m ON m.session_file = t.session_file AND m.entry_id = t.entry_id';
+    const where = `WHERE t.timestamp >= ${Math.floor(cutoff)}`;
+    const facts = (bucket, extra) => `
+    ${bucket},
+    ${txt('t.tool_name')}, ${txt('t.model')}, ${txt('t.provider')},
+    COUNT(*),
+    SUM(CASE WHEN t.is_error = 1 THEN 1 ELSE 0 END),
+    SUM(t.args_chars),
+    SUM(COALESCE(t.result_chars, 0)),
+    TOTAL(COALESCE(m.total_tokens, 0) * 1.0 / t.calls_in_turn),
+    TOTAL(COALESCE(m.output_tokens, 0) * 1.0 / t.calls_in_turn),
+    TOTAL(COALESCE(m.cost_total, 0) / t.calls_in_turn),
+    TOTAL(CASE WHEN COALESCE(m.total_tokens, 0) > 0 AND COALESCE(m.cost_total, 0) = 0
+      AND (m.provider = 'xai-oauth' OR m.cost_unpriced = 1) THEN 1 ELSE 0 END * 1.0 / t.calls_in_turn),
+    MAX(t.timestamp)${extra}`;
+    const out = readBlocks(db, [
+        ['byTool', `SELECT ${facts("'-'", '')} FROM tool_calls t ${join} ${where} GROUP BY t.tool_name ORDER BY 5 DESC`],
+        ['byToolModel', `SELECT ${facts("'-'", ', t.model, t.provider')} FROM tool_calls t ${join} ${where}
+      GROUP BY t.tool_name, t.model, t.provider ORDER BY 5 DESC LIMIT ${TOOL_MODEL_LIMIT}`],
+        ['toolSeries', `SELECT (t.timestamp / ${bucketMs}) * ${bucketMs}, ${txt('t.tool_name')}, COUNT(*),
+      SUM(CASE WHEN t.is_error = 1 THEN 1 ELSE 0 END) FROM tool_calls t ${where} GROUP BY 1, 2 ORDER BY 1`],
+    ]);
+    const parseTool = (r, at) => ({
+        tool: r[1] ?? '',
+        calls: num(r[4]),
+        errors: num(r[5]),
+        argsChars: num(r[6]),
+        resultChars: num(r[7]),
+        totalTokensShare: num(r[8]),
+        outputTokensShare: num(r[9]),
+        costShare: num(r[10]),
+        unpricedShare: num(r[11]),
+        lastUsed: numOrNull(r[12]),
+        model: r[at] ?? '',
+        provider: r[at + 1] ?? '',
+    });
+    return {
+        tools: (out.get('byTool') ?? []).map((r) => parseTool(r, 13)),
+        toolsByModel: (out.get('byToolModel') ?? []).map((r) => parseTool(r, 13)),
+        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 out = sqliteScript(db, 'SELECT session_file, COUNT(*) FROM tool_calls 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 session_file, model FROM messages GROUP BY session_file, model;\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()]));
+}
+/**
+ * Each root session's own title and working directory, read from the head of its transcript.
+ *
+ * The `session` line carries the working directory and the `title` line sits above it, so one head
+ * read answers both. A rotated or unreadable file leaves the row's folder and file name to speak.
+ */
+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);
+    const top = `model IN (SELECT model FROM messages ${scope} GROUP BY model ORDER BY COUNT(*) DESC LIMIT ${SERIES_MODELS})`;
+    const clause = scope ? `${scope} AND ${top}` : `WHERE ${top}`;
+    const out = readBlocks(db, [['modelSeries', `SELECT ${txt('model')}, (timestamp / ${bucketMs}) * ${bucketMs},
+      COUNT(*), SUM(total_tokens), TOTAL(cost_total) FROM messages ${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 }));
+}
+/**
+ * Throughput and first-token latency per bucket for the busiest models, the chart behind a
+ * model's expanded row. Both averages are null in a bucket where no request carried the timing,
+ * because a non-null zero would draw a flat line through a real gap.
+ */
+function readModelPerformance(db, cutoff, bucketMs) {
+    const scope = rangeWhere(cutoff);
+    const top = `model IN (SELECT model FROM messages ${scope} GROUP BY model ORDER BY COUNT(*) DESC LIMIT ${SERIES_MODELS})`;
+    const clause = scope ? `${scope} AND ${top}` : `WHERE ${top}`;
+    const out = readBlocks(db, [['modelPerformance', `SELECT ${txt('model')}, ${txt('provider')}, (timestamp / ${bucketMs}) * ${bucketMs},
+      COUNT(*),
+      TOTAL(CASE WHEN duration > 0 THEN output_tokens * 1000.0 / duration END),
+      COUNT(CASE WHEN duration > 0 THEN 1 END),
+      TOTAL(ttft),
+      COUNT(ttft)
+      FROM messages ${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()];
+}
+// ------------------------------------------------------------ subscription windows
+/** 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 of the sum across accounts at any sampled instant, forward filling each account's last
+ * known fraction. A peak of 1.7 means demand simultaneously held 1.7 windows of quota.
+ */
+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),
+        };
+    });
+}
+/**
+ * Utilization series and per-window insights. A window is one `(provider, limitId)` pair: distinct
+ * limits can share a duration label, and merging them interleaves unrelated fractions per account.
+ */
+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 ${txt('provider')}, SUM(total_tokens)
+      FROM messages ${rangeWhere(cutoff)} 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 ${txt('provider')},
+      CAST(strftime('%H', timestamp / 1000, 'unixepoch', 'localtime') AS INTEGER),
+      SUM(total_tokens), SUM(output_tokens), COUNT(*)
+      FROM messages ${rangeWhere(cutoff)} 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;
+}
+/** The Requests page summary, computed over the rows the payload carries. */
+function computeRequestStats(rows) {
+    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: rows.length,
+        failed: rows.filter((row) => row.stopReason === 'error').length,
+        aborted: rows.filter((row) => row.stopReason === 'aborted').length,
+        tokens: rows.reduce((sum, row) => sum + row.totalTokens, 0),
+        costUsd: rows.reduce((sum, row) => sum + row.costUsd, 0),
+        unpriced: rows.filter((row) => row.unpriced).length,
+        medianDurationMs: median(durations),
+        p95DurationMs: pick(0.95),
+        medianTtftMs: median(rows.map((row) => row.ttftMs)),
+        oldest: times.length ? Math.min(...times) : null,
+        newest: 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 session transcript as spans, tracks, markers, and totals.
+ *
+ * An assistant message stamps its completion and its `duration` says when the call began, so a
+ * model span runs `ts - duration` to `ts`. A tool call is emitted by the message requesting it and
+ * closed by the `toolResult` with the same call id, so the two bound a tool span. A user message
+ * opens a turn the next user message closes, and everything that is not a message rides along as a
+ * marker, since it happened at a point in time rather than across one.
+ */
+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, read on demand by the request drawer. `entry` is the raw
+ * journal line, `output` is the message that line carries, and `agent` is the agent state in
+ * force when the request ran. All are empty when the entry journals nothing: a `model_usage`
+ * row carries no message, and a deleted session cannot be re-read.
+ */
+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 both omp databases. `available` is false when stats.db holds no `messages` table. */
+export function readAgentStats(range = '24h', view = 'all', now = Date.now()) {
+    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(timestamp), MAX(timestamp) FROM messages ${rangeWhere(cutoff)}`]]);
+    const [firstTs, lastTs] = bounds.get('bounds')?.[0] ?? [];
+    stats.bucketMs = bucketSize(range, numOrNull(firstTs), numOrNull(lastTs));
+    Object.assign(stats, readStatsDb(db, cutoff, stats.bucketMs, cols, parts));
+    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);
+    if (parts.has('windows')) {
+        Object.assign(stats, computeWindows(readWindowSamples(cutoff), readProviderTokens(db, cutoff)));
+    }
+    stats.available = true;
+    return stats;
+}