opencode-usage-insights 0.0.0-stage → 0.1.1

package/dist/tui.js

@@ -0,0 +1,3515 @@
+// @bun
+// src/tui.tsx
+import { use as _$use2 } from "@opentui/solid";
+import { createElement as _$createElement3 } from "@opentui/solid";
+import { createComponent as _$createComponent3 } from "@opentui/solid";
+import { Plugin } from "@opencode/plugin/tui";
+import { StyledText, fg } from "@opentui/core";
+import { Show, createMemo as createMemo3, createRenderEffect as createRenderEffect2, createSignal as createSignal2 } from "solid-js";
+
+// src/core.ts
+var PROMPT_BOUNDARIES = new Set(["user", "synthetic", "system"]);
+function transcriptTail(messages, count) {
+  const segments = [];
+  let current = [];
+  for (let index = messages.length - 1;index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message.type === "assistant") {
+      current.unshift(message);
+      continue;
+    }
+    if (!PROMPT_BOUNDARIES.has(message.type))
+      continue;
+    if (current.length === 0)
+      continue;
+    segments.unshift({ assistants: current, prompt: message });
+    if (segments.length >= count)
+      return segments;
+    current = [];
+  }
+  if (current.length > 0 && segments.length < count)
+    segments.unshift({ assistants: current, prompt: undefined });
+  return segments;
+}
+function tokenCounts(message) {
+  const tokens = message.tokens;
+  return {
+    input: tokens?.input ?? 0,
+    output: tokens?.output ?? 0,
+    reasoning: tokens?.reasoning ?? 0,
+    read: tokens?.cache?.read ?? 0,
+    write: tokens?.cache?.write ?? 0
+  };
+}
+function totalize(steps) {
+  const totals = { input: 0, cached: 0, output: 0, reasoning: 0, cacheWrite: 0, cost: 0, steps: steps.length };
+  for (const step of steps) {
+    const counts = tokenCounts(step);
+    totals.input += counts.input;
+    totals.cached += counts.read;
+    totals.output += counts.output;
+    totals.reasoning += counts.reasoning;
+    totals.cacheWrite += counts.write;
+    totals.cost += step.cost ?? 0;
+  }
+  return totals;
+}
+function identityKey(model) {
+  if (!model)
+    return;
+  return `${model.providerID}/${model.id}${model.variant ? `#${model.variant}` : ""}`;
+}
+function cacheRead(message) {
+  return message?.tokens?.cache?.read ?? 0;
+}
+function stepCreated(message) {
+  return message?.time?.created;
+}
+function stepEnd(message) {
+  const time = message?.time;
+  if (!time)
+    return;
+  return time.completed ?? time.streamed ?? time.created;
+}
+function cacheDrop(reference, current, scope = "provider") {
+  if (!reference)
+    return;
+  const before = reference.model;
+  const after = current.model;
+  if (!before || !after)
+    return;
+  if (scope === "provider" && before.providerID !== after.providerID)
+    return;
+  if (before.id !== after.id || (before.variant ?? "") !== (after.variant ?? "")) {
+    return;
+  }
+  const drop = cacheRead(reference) - cacheRead(current);
+  if (isNoiseDrop(after.providerID, drop))
+    return;
+  return drop > 0 ? drop : undefined;
+}
+function stepGap(reference, current) {
+  const ended = stepEnd(reference);
+  const started = stepCreated(current);
+  if (ended === undefined || started === undefined)
+    return;
+  return Math.max(0, started - ended);
+}
+function tokensPerSecond(produced, from, to) {
+  if (from === undefined || to === undefined || to <= from)
+    return;
+  if (produced <= 0)
+    return;
+  return produced / (to - from) * 1000;
+}
+var DROP_EXEMPT_PROVIDERS = new Set(["openai"]);
+function isSettledStep(message) {
+  if (message.time?.completed !== undefined)
+    return true;
+  return message.finish !== undefined && message.finish !== null;
+}
+function computeTurn(messages, session) {
+  const segments = transcriptTail(messages, 2);
+  const last = segments[segments.length - 1];
+  if (!last)
+    return;
+  const previous = segments[segments.length - 2];
+  const lastStep = last.assistants[last.assistants.length - 1];
+  if (!lastStep)
+    return;
+  if (!isSettledStep(lastStep))
+    return;
+  const previousStep = previous?.assistants[previous.assistants.length - 1];
+  const settled = last.assistants.filter(isSettledStep);
+  const drops = [];
+  let reference = previousStep !== undefined && isSettledStep(previousStep) ? previousStep : undefined;
+  for (const step of settled) {
+    const drop = cacheDrop(reference, step);
+    if (drop !== undefined) {
+      drops.push({
+        messageID: step.id,
+        tokens: drop,
+        prevCached: cacheRead(reference),
+        gapMs: stepGap(reference, step)
+      });
+    }
+    reference = step;
+  }
+  const provider = lastStep.model?.providerID;
+  const previousProvider = previousStep?.model?.providerID;
+  const key = identityKey(lastStep.model);
+  const previousKey = identityKey(previousStep?.model);
+  return {
+    endAt: stepEnd(lastStep),
+    startAt: stepCreated(settled[0] ?? lastStep),
+    promptAt: last.prompt?.time?.created,
+    promptGapMs: promptGap(last.prompt, previous?.prompt),
+    providerID: provider,
+    modelID: lastStep.model?.id,
+    variant: lastStep.model?.variant,
+    providerChanged: previousProvider !== undefined && provider !== undefined && previousProvider !== provider,
+    modelChanged: previousKey !== undefined && key !== undefined && previousKey !== key && previousProvider === provider,
+    totals: totalize(settled),
+    latest: totalize([lastStep]),
+    session,
+    drops,
+    cacheDropTokens: drops.reduce((sum, drop) => sum + drop.tokens, 0),
+    cacheExpired: drops.length > 0,
+    steps: settled.length
+  };
+}
+function promptGap(current, previous) {
+  const now = current?.time?.created;
+  const before = previous?.time?.created;
+  if (now === undefined || before === undefined)
+    return;
+  return Math.max(0, now - before);
+}
+function isNoiseDrop(providerID, drop) {
+  if (providerID === undefined)
+    return false;
+  return DROP_EXEMPT_PROVIDERS.has(providerID) && drop >= 1024 && drop <= 2048;
+}
+var DEFAULT_LABELS = {
+  delta: "\u0394",
+  turn: "",
+  session: "sess",
+  step: "step",
+  steps: "steps",
+  input: "in",
+  cached: "cached",
+  output: "out",
+  reasoning: "reason",
+  cost: "cost",
+  cacheExpired: "cache expired",
+  providerChanged: "changed",
+  modelChanged: "model changed"
+};
+var DEFAULT_FIELDS = {
+  clock: true,
+  delta: true,
+  model: true,
+  variant: true,
+  turn: true,
+  session: true,
+  reasoning: false,
+  cost: true,
+  cacheExpiry: true
+};
+function formatClock(ms) {
+  const date = new Date(ms);
+  const pad = (value) => String(value).padStart(2, "0");
+  return `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+}
+function formatDuration(ms) {
+  const totalSeconds = Math.max(0, Math.floor(ms / 1000));
+  const seconds = totalSeconds % 60;
+  const minutes = Math.floor(totalSeconds / 60) % 60;
+  const hours = Math.floor(totalSeconds / 3600) % 24;
+  const days = Math.floor(totalSeconds / 86400);
+  if (days > 0)
+    return `${days}d${hours}h`;
+  if (hours > 0)
+    return `${hours}h${String(minutes).padStart(2, "0")}m`;
+  if (minutes > 0)
+    return `${minutes}m${String(seconds).padStart(2, "0")}s`;
+  return `${seconds}s`;
+}
+function formatTokens(value) {
+  const n = Math.max(0, Math.round(value));
+  if (n < 1000)
+    return String(n);
+  if (n < 999500) {
+    const k = n / 1000;
+    return `${trimZeros(k.toFixed(k < 10 ? 2 : 1))}k`;
+  }
+  if (n < 999500000) {
+    const m = n / 1e6;
+    return `${trimZeros(m.toFixed(m < 10 ? 2 : 1))}M`;
+  }
+  return `${Math.round(n / 1e6)}M`;
+}
+function trimZeros(value) {
+  return value.includes(".") ? value.replace(/0+$/, "").replace(/\.$/, "") : value;
+}
+function formatCost(value) {
+  if (value <= 0)
+    return "$0";
+  if (value < 1)
+    return `$${value.toFixed(4)}`;
+  return `$${value.toFixed(2)}`;
+}
+function displayTotals(totals) {
+  const prompt = totals.input + totals.cached + totals.cacheWrite;
+  return {
+    input: prompt - totals.cached,
+    cached: totals.cached,
+    cacheWrite: totals.cacheWrite,
+    output: totals.output + totals.reasoning,
+    reasoning: totals.reasoning,
+    cost: totals.cost,
+    steps: totals.steps,
+    prompt
+  };
+}
+function totalsText(prefix, totals, labels, fields, stepCount = 0, cost = totals.cost) {
+  const display = displayTotals(totals);
+  const input = display.prompt === display.input ? `${labels.input} ${formatTokens(display.input)}` : `${labels.input} ${formatTokens(display.input)} (${formatTokens(display.prompt)})`;
+  const parts = [
+    input,
+    `${labels.cached} ${formatTokens(display.cached)}`,
+    `${labels.output} ${formatTokens(display.output)}`
+  ];
+  if (fields.reasoning)
+    parts.push(`${labels.reasoning} ${formatTokens(display.reasoning)}`);
+  if (fields.cost && cost > 0)
+    parts.push(`${labels.cost} ${formatCost(cost)}`);
+  const steps = stepCount > 1 ? `${stepCount} ${stepCount === 1 ? labels.step : labels.steps}` : "";
+  const head = [prefix, steps].filter((piece) => piece !== "").join(" ");
+  const numbers = parts.join(", ");
+  if (head === "")
+    return numbers;
+  return stepCount > 1 ? `${head} \xB7 ${numbers}` : `${head} ${numbers}`;
+}
+function formatLineSegments(stats, options) {
+  const labels = { ...DEFAULT_LABELS, ...options?.labels };
+  const fields = { ...DEFAULT_FIELDS, ...options?.fields };
+  const turnTotals = options?.turnTotals ?? "latest";
+  const segments = [];
+  if (fields.clock && stats.endAt !== undefined) {
+    segments.push({ text: formatClock(stats.endAt), tone: "muted" });
+  }
+  if (fields.delta && stats.promptGapMs !== undefined) {
+    segments.push({ text: `${labels.delta} ${formatDuration(stats.promptGapMs)}`, tone: "muted" });
+  }
+  if (stats.providerID !== undefined) {
+    let text = stats.providerID;
+    if (fields.model && stats.modelID !== undefined)
+      text += `/${stats.modelID}`;
+    if (fields.variant && stats.variant)
+      text += ` ${stats.variant}`;
+    segments.push({ text, tone: stats.providerChanged ? "warning" : "base" });
+    if (stats.providerChanged)
+      segments.push({ text: labels.providerChanged, tone: "warning" });
+    else if (stats.modelChanged)
+      segments.push({ text: labels.modelChanged, tone: "muted" });
+  }
+  if (fields.turn && stats.totals.steps > 0) {
+    const totals = turnTotals === "sum" ? stats.totals : stats.latest;
+    segments.push({
+      text: totalsText(labels.turn, totals, labels, fields, turnTotals === "sum" ? stats.totals.steps : stats.steps, stats.totals.cost),
+      tone: "base"
+    });
+  }
+  if (fields.session && stats.session) {
+    segments.push({ text: totalsText(labels.session, stats.session, labels, fields, 0, stats.session.cost), tone: "muted" });
+  }
+  if (fields.cacheExpiry && stats.cacheExpired) {
+    const count = stats.drops.length > 1 ? `\xD7${stats.drops.length}` : "";
+    segments.push({ text: `\u26A0 ${labels.cacheExpired} (\u2212${formatTokens(stats.cacheDropTokens)}${count})`, tone: "warning" });
+  }
+  return segments;
+}
+function formatLine(stats, options) {
+  return formatLineSegments(stats, options).map((segment) => segment.text).join(" \xB7 ");
+}
+
+// src/text.ts
+var TEXT_LIMIT = 512;
+function sanitizeText(value, limit = TEXT_LIMIT) {
+  if (limit <= 0)
+    return "";
+  let cleaned = "";
+  for (const character of value) {
+    const code = character.codePointAt(0) ?? 0;
+    if (code <= 31 || code === 127 || code >= 128 && code <= 159)
+      continue;
+    cleaned += character;
+    if (cleaned.length >= limit)
+      break;
+  }
+  return cleaned;
+}
+function sanitizeLabel(value, limit = TEXT_LIMIT) {
+  return sanitizeText(value, limit).trim();
+}
+var TOKEN = /^[A-Za-z0-9][A-Za-z0-9._:/-]*$/;
+function isToken(value, limit = 64) {
+  return value.length > 0 && value.length <= limit && TOKEN.test(value);
+}
+
+// src/line.ts
+function toTranscript(messages) {
+  const transcript = [];
+  for (const message of messages) {
+    if (typeof message.id !== "string" || typeof message.type !== "string")
+      continue;
+    if (message.type !== "assistant") {
+      transcript.push({ type: message.type, id: message.id, time: message.time });
+      continue;
+    }
+    transcript.push({
+      type: "assistant",
+      id: message.id,
+      time: message.time,
+      model: toModelRef(message.model),
+      tokens: message.tokens,
+      cost: message.cost,
+      finish: message.finish ?? undefined,
+      rawFinish: message.rawFinish ?? undefined
+    });
+  }
+  return transcript;
+}
+function toTranscriptTail(messages, segments = 2) {
+  const wanted = Math.max(2, segments);
+  const tail = [];
+  let collected = 0;
+  let closed = 0;
+  for (let index = messages.length - 1;index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message.type === "assistant") {
+      tail.push(message);
+      collected += 1;
+      continue;
+    }
+    if (message.type === undefined || !PROMPT_BOUNDARIES.has(message.type))
+      continue;
+    if (collected === 0)
+      continue;
+    tail.push(message);
+    collected = 0;
+    closed += 1;
+    if (closed >= wanted)
+      break;
+  }
+  tail.reverse();
+  return toTranscript(tail);
+}
+function toModelRef(model) {
+  if (model === undefined || model.providerID === undefined || model.id === undefined)
+    return;
+  if (model.variant === undefined)
+    return { providerID: model.providerID, id: model.id };
+  return { providerID: model.providerID, id: model.id, variant: model.variant };
+}
+function sessionTotals(info) {
+  if (info === undefined)
+    return;
+  const tokens = info.tokens;
+  return {
+    input: tokens?.input ?? 0,
+    cached: tokens?.cache?.read ?? 0,
+    output: tokens?.output ?? 0,
+    reasoning: tokens?.reasoning ?? 0,
+    cacheWrite: tokens?.cache?.write ?? 0,
+    cost: info.cost ?? 0,
+    steps: 0
+  };
+}
+function lineParts(stats, options) {
+  if (stats === undefined)
+    return [];
+  const parts = [];
+  const segments = formatLineSegments(stats, options);
+  segments.forEach((segment, index) => {
+    if (index > 0)
+      parts.push({ text: " \xB7 ", tone: "muted" });
+    parts.push({ text: sanitizeLabel(segment.text), tone: segment.tone });
+  });
+  return parts;
+}
+function lineText(parts) {
+  return parts.map((part) => part.text).join("");
+}
+
+// src/stats/queries.ts
+var COMPACTION_KIND = "compaction";
+var DEFAULT_TTL_HINT_MS = 10 * 60 * 1000;
+var STEP_TIME = "COALESCE(created_at, recorded_at)";
+var MODEL_KEY_SQL = "COALESCE(model_id, '(unknown)') || '#' || COALESCE(variant, '')";
+function modelKey(modelID, variant) {
+  return `${modelID}#${variant ?? ""}`;
+}
+function modelLabel(modelID, variant) {
+  return variant === undefined ? modelID : `${modelID} ${variant}`;
+}
+var USAGE_SELECT = `COUNT(*) AS steps,
+       COALESCE(SUM(input_tokens), 0) AS input,
+       COALESCE(SUM(cache_read), 0) AS cached,
+       COALESCE(SUM(cache_write), 0) AS cacheWrite,
+       COALESCE(SUM(output_tokens), 0) AS output,
+       COALESCE(SUM(reasoning_tokens), 0) AS reasoning,
+       COALESCE(SUM(cost), 0) AS cost`;
+function usageFrom(row) {
+  return {
+    steps: row.steps ?? 0,
+    input: row.input ?? 0,
+    cached: row.cached ?? 0,
+    cacheWrite: row.cacheWrite ?? 0,
+    output: row.output ?? 0,
+    reasoning: row.reasoning ?? 0,
+    cost: row.cost ?? 0
+  };
+}
+function rangeWhere(range, column = STEP_TIME) {
+  const clauses = [];
+  const params = [];
+  if (range?.from !== undefined) {
+    clauses.push(`${column} >= ?`);
+    params.push(range.from);
+  }
+  if (range?.to !== undefined) {
+    clauses.push(`${column} < ?`);
+    params.push(range.to);
+  }
+  return { where: clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "", params };
+}
+function buildWhere(range, filters, column = STEP_TIME) {
+  const rangeClause = rangeWhere(range, column);
+  const clauses = rangeClause.where === "" ? [] : [rangeClause.where.slice("WHERE ".length)];
+  const params = [...rangeClause.params];
+  if (filters?.modelID !== undefined && filters.modelID !== "") {
+    clauses.push("model_id = ?");
+    params.push(filters.modelID);
+  }
+  if (filters?.modelKey !== undefined && filters.modelKey !== "") {
+    clauses.push(`${MODEL_KEY_SQL} = ?`);
+    params.push(filters.modelKey);
+  }
+  if (filters?.provider !== undefined && filters.provider !== "") {
+    clauses.push("provider_id = ?");
+    params.push(filters.provider);
+  }
+  if (filters?.sessionID !== undefined && filters.sessionID !== "") {
+    clauses.push("session_id = ?");
+    params.push(filters.sessionID);
+  }
+  return { where: clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "", params };
+}
+function cacheHitRatio(usage) {
+  const total = usage.cached + usage.input + usage.cacheWrite;
+  return total > 0 ? usage.cached / total : undefined;
+}
+function overview(db, range, filters) {
+  const steps = buildWhere(range, filters);
+  const row = db.query(`SELECT ${USAGE_SELECT},
+              COUNT(DISTINCT session_id) AS sessions,
+              MIN(${STEP_TIME}) AS firstAt,
+              MAX(COALESCE(completed_at, ${STEP_TIME})) AS lastAt,
+              COALESCE(SUM(CASE WHEN streamed_at > created_at THEN output_tokens + reasoning_tokens ELSE 0 END), 0) AS produced,
+              COALESCE(SUM(CASE WHEN streamed_at > created_at THEN streamed_at - created_at ELSE 0 END), 0) AS window
+       FROM steps ${steps.where}`).get(...steps.params);
+  const prompts = rangeWhere(range, "created_at");
+  const promptRow = db.query(`SELECT COUNT(*) AS prompts FROM prompts ${prompts.where}`).get(...prompts.params);
+  const usage = usageFrom(row ?? { steps: 0, input: 0, cached: 0, cacheWrite: 0, output: 0, reasoning: 0, cost: 0 });
+  return {
+    ...usage,
+    sessions: row?.sessions ?? 0,
+    prompts: promptRow?.prompts ?? 0,
+    firstAt: row?.firstAt ?? undefined,
+    lastAt: row?.lastAt ?? undefined,
+    cacheHitRatio: cacheHitRatio(usage),
+    tps: row === null ? undefined : tokensPerSecond(row.produced ?? 0, 0, row.window ?? 0)
+  };
+}
+function models(db, range, filters) {
+  const filter = buildWhere(range, filters);
+  const rows = db.query(`SELECT provider_id, model_id, variant,
+              ${USAGE_SELECT},
+              MIN(${STEP_TIME}) AS first_at,
+              MAX(COALESCE(completed_at, recorded_at)) AS last_at
+       FROM steps ${filter.where}
+       GROUP BY provider_id, model_id, variant
+       ORDER BY steps DESC, cached DESC`).all(...filter.params);
+  const models = new Map;
+  for (const row of rows) {
+    const modelID = row.model_id ?? "(unknown)";
+    const variant = row.variant ?? undefined;
+    const key = `${modelID}#${variant ?? ""}`;
+    let model = models.get(key);
+    if (!model) {
+      model = { modelID, variant, providers: [], totals: emptyUsage() };
+      models.set(key, model);
+    }
+    const usage = usageFrom(row);
+    model.providers.push({
+      ...usage,
+      providerID: row.provider_id ?? "(unknown)",
+      firstAt: row.first_at ?? undefined,
+      lastAt: row.last_at ?? undefined
+    });
+    addUsage(model.totals, usage);
+  }
+  return [...models.values()].sort((a, b) => billedTokens(b.totals) - billedTokens(a.totals));
+}
+function emptyUsage() {
+  return { steps: 0, input: 0, cached: 0, cacheWrite: 0, output: 0, reasoning: 0, cost: 0 };
+}
+function addUsage(target, source) {
+  target.steps += source.steps;
+  target.input += source.input;
+  target.cached += source.cached;
+  target.cacheWrite += source.cacheWrite;
+  target.output += source.output;
+  target.reasoning += source.reasoning;
+  target.cost += source.cost;
+}
+function billedTokens(usage) {
+  return usage.input + usage.cached + usage.output;
+}
+function percentile(values, p) {
+  if (values.length === 0)
+    return;
+  const sorted = [...values].sort((a, b) => a - b);
+  const rank = Math.ceil(p / 100 * sorted.length);
+  const index = Math.min(sorted.length - 1, Math.max(0, rank - 1));
+  return sorted[index];
+}
+function latencyStats(values) {
+  return {
+    count: values.length,
+    p50: percentile(values, 50),
+    p90: percentile(values, 90),
+    p99: percentile(values, 99)
+  };
+}
+function sessions(db, options) {
+  if (options?.sessionIDs !== undefined && options.sessionIDs.length === 0)
+    return [];
+  const range = options?.range;
+  const filter = buildWhere(range, options?.filters, "COALESCE(st.created_at, st.recorded_at)");
+  const limit = options?.limit ?? 20;
+  const clauses = filter.where === "" ? [] : [filter.where.slice("WHERE ".length)];
+  const params = [...filter.params];
+  if (options?.sessionIDs !== undefined) {
+    const ids = options.sessionIDs.slice(0, 500);
+    clauses.push(`st.session_id IN (${ids.map(() => "?").join(", ")})`);
+    params.push(...ids);
+  }
+  const rows = db.query(`SELECT st.session_id, s.title, s.directory, s.parent_id,
+              GROUP_CONCAT(DISTINCT st.provider_id) AS providers,
+              GROUP_CONCAT(DISTINCT st.model_id) AS models,
+              (SELECT COUNT(*) FROM prompts p WHERE p.session_id = st.session_id) AS prompts,
+              COUNT(*) AS steps,
+              COALESCE(SUM(st.input_tokens), 0) AS input,
+              COALESCE(SUM(st.cache_read), 0) AS cached,
+              COALESCE(SUM(st.cache_write), 0) AS cacheWrite,
+              COALESCE(SUM(st.output_tokens), 0) AS output,
+              COALESCE(SUM(st.reasoning_tokens), 0) AS reasoning,
+              COALESCE(SUM(st.cost), 0) AS cost,
+              MIN(COALESCE(st.created_at, st.recorded_at)) AS first_at,
+              MAX(COALESCE(st.completed_at, st.created_at, st.recorded_at)) AS last_at
+       FROM steps st
+       LEFT JOIN sessions s ON s.session_id = st.session_id
+       ${clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : ""}
+       GROUP BY st.session_id
+       ORDER BY last_at DESC
+       LIMIT ?`).all(...params, limit);
+  return rows.map((row) => {
+    const usage = usageFrom(row);
+    return {
+      ...usage,
+      sessionID: row.session_id,
+      parentID: row.parent_id ?? undefined,
+      title: row.title ?? undefined,
+      directory: row.directory ?? undefined,
+      providers: row.providers ? row.providers.split(",").filter(Boolean) : [],
+      models: row.models ? row.models.split(",").filter(Boolean) : [],
+      prompts: row.prompts ?? 0,
+      firstAt: row.first_at ?? undefined,
+      lastAt: row.last_at ?? undefined,
+      cacheHitRatio: cacheHitRatio(usage)
+    };
+  });
+}
+function childSessionIDs(db, parentID) {
+  return db.query("SELECT session_id FROM sessions WHERE parent_id = ? ORDER BY session_id").all(parentID).map((row) => row.session_id);
+}
+function sessionUsageOf(db, sessionIDs) {
+  return sessions(db, { sessionIDs, limit: sessionIDs.length });
+}
+function turnFinished(finish) {
+  return finish !== null && finish !== "" && finish !== "tool-calls";
+}
+function stepUsage(row) {
+  return {
+    steps: 1,
+    input: row.input_tokens ?? 0,
+    cached: row.cache_read ?? 0,
+    cacheWrite: row.cache_write ?? 0,
+    output: row.output_tokens ?? 0,
+    reasoning: row.reasoning_tokens ?? 0,
+    cost: row.cost ?? 0
+  };
+}
+function stepMessage(row) {
+  return {
+    type: "assistant",
+    id: row.message_id,
+    time: { created: row.created_at ?? row.recorded_at, completed: row.completed_at ?? undefined },
+    model: row.provider_id !== null && row.model_id !== null ? { providerID: row.provider_id, id: row.model_id, variant: row.variant ?? undefined } : undefined,
+    tokens: {
+      input: row.input_tokens ?? 0,
+      output: row.output_tokens ?? 0,
+      reasoning: row.reasoning_tokens ?? 0,
+      cache: { read: row.cache_read ?? 0, write: row.cache_write ?? 0 }
+    },
+    finish: row.finish ?? undefined
+  };
+}
+function turns(db, options) {
+  const limit = options?.limit ?? 50;
+  const filter = buildWhere(options?.range, options?.filters);
+  const clauses = filter.where === "" ? [] : [filter.where.slice("WHERE ".length)];
+  const params = [...filter.params];
+  if (options?.sessionID !== undefined) {
+    clauses.push("session_id = ?");
+    params.push(options.sessionID);
+  }
+  const floor = options?.sessionID === undefined ? undefined : promptFloor(db, options.sessionID, limit + 1);
+  if (floor !== undefined) {
+    clauses.push(`${STEP_TIME} >= ?`);
+    params.push(floor);
+  }
+  const steps = db.query(`SELECT message_id, session_id, provider_id, model_id, variant,
+              input_tokens, cache_read, cache_write, output_tokens, reasoning_tokens, cost,
+              created_at, streamed_at, recorded_at, completed_at, finish
+         FROM steps ${clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : ""}
+        ORDER BY session_id, ${STEP_TIME}`).all(...params);
+  const promptClause = options?.sessionID === undefined ? "" : `WHERE session_id = ?${floor === undefined ? "" : " AND created_at >= ?"}`;
+  const promptParams = options?.sessionID === undefined ? [] : floor === undefined ? [options.sessionID] : [options.sessionID, floor];
+  const promptRows = db.query(`SELECT session_id, created_at FROM prompts ${promptClause} ORDER BY session_id, created_at`).all(...promptParams);
+  const promptsBySession = new Map;
+  for (const row of promptRows) {
+    if (row.created_at === null)
+      continue;
+    const list = promptsBySession.get(row.session_id) ?? [];
+    list.push(row.created_at);
+    promptsBySession.set(row.session_id, list);
+  }
+  const result = [];
+  let sessionID;
+  let bucket = [];
+  let promptIndex = -2;
+  let promptAt;
+  let previousPromptAt;
+  function close() {
+    const last = bucket[bucket.length - 1];
+    if (last === undefined || !turnFinished(last.finish)) {
+      bucket = [];
+      return;
+    }
+    const totals = emptyUsage();
+    for (const row of bucket)
+      addUsage(totals, stepUsage(row));
+    const drops = [];
+    let reference;
+    for (const row of bucket) {
+      const message = stepMessage(row);
+      const drop = cacheDrop(reference, message);
+      if (drop !== undefined) {
+        drops.push({ messageID: row.message_id, tokens: drop, gapMs: stepGap(reference, message) });
+      }
+      reference = message;
+    }
+    const providerID = last.provider_id ?? undefined;
+    const modelID = last.model_id ?? undefined;
+    const variant = last.variant ?? undefined;
+    let produced = 0;
+    let window = 0;
+    for (const row of bucket) {
+      if (row.created_at === null || row.streamed_at === null || row.streamed_at <= row.created_at)
+        continue;
+      produced += (row.output_tokens ?? 0) + (row.reasoning_tokens ?? 0);
+      window += row.streamed_at - row.created_at;
+    }
+    const previous = result.length > 0 && result[result.length - 1].sessionID === last.session_id ? result[result.length - 1] : undefined;
+    result.push({
+      sessionID: last.session_id,
+      promptAt,
+      endAt: last.completed_at ?? last.created_at ?? last.recorded_at,
+      promptGapMs: promptAt !== undefined && previousPromptAt !== undefined ? Math.max(0, promptAt - previousPromptAt) : undefined,
+      providerID,
+      modelID,
+      variant,
+      providerChanged: previous?.providerID !== undefined && providerID !== undefined && previous.providerID !== providerID,
+      modelChanged: previous !== undefined && previous.providerID === providerID && `${previous.modelID ?? ""}#${previous.variant ?? ""}` !== `${modelID ?? ""}#${variant ?? ""}`,
+      steps: bucket.length,
+      latest: stepUsage(last),
+      totals,
+      drops,
+      finish: last.finish ?? undefined,
+      tps: tokensPerSecond(produced, 0, window)
+    });
+    bucket = [];
+  }
+  for (const row of steps) {
+    if (row.session_id !== sessionID) {
+      close();
+      sessionID = row.session_id;
+      promptIndex = -2;
+      promptAt = undefined;
+      previousPromptAt = undefined;
+    }
+    const time = row.created_at ?? row.recorded_at;
+    const prompts = promptsBySession.get(row.session_id) ?? [];
+    let index = -1;
+    for (let candidate = prompts.length - 1;candidate >= 0; candidate -= 1) {
+      if ((prompts[candidate] ?? Number.POSITIVE_INFINITY) <= time) {
+        index = candidate;
+        break;
+      }
+    }
+    if (index !== promptIndex) {
+      close();
+      promptIndex = index;
+      promptAt = index >= 0 ? prompts[index] : undefined;
+      previousPromptAt = index >= 1 ? prompts[index - 1] : undefined;
+    }
+    bucket.push(row);
+  }
+  close();
+  return result.reverse().slice(0, limit);
+}
+function promptFloor(db, sessionID, count) {
+  const rows = db.query("SELECT created_at FROM prompts WHERE session_id = ? AND created_at IS NOT NULL ORDER BY created_at DESC LIMIT ?").all(sessionID, count);
+  return rows.length === count ? rows[count - 1].created_at : undefined;
+}
+function filterOptions(db) {
+  const pick = (column) => db.query(`SELECT ${column} AS value, COUNT(*) AS steps FROM steps WHERE ${column} IS NOT NULL GROUP BY ${column} ORDER BY steps DESC`).all().map((row) => ({ value: row.value, steps: row.steps }));
+  return { models: pick("model_id"), providers: pick("provider_id") };
+}
+
+// src/panel-data.ts
+var PANEL_NAME = "usage-insights";
+var PANEL_VIEWS = ["overview", "models", "providers", "cache", "periods", "latency", "sessions", "turns", "db"];
+var RANGE_KEYS = ["session", "today", "7d", "30d", "all"];
+var GRANULARITIES = ["day", "week", "month"];
+function parseArgs(input) {
+  const parsed = {};
+  for (const token of (input ?? "").split(/\s+/)) {
+    const value = token.trim().toLowerCase();
+    if (value === "")
+      continue;
+    if (PANEL_VIEWS.includes(value))
+      parsed.view = value;
+    else if (RANGE_KEYS.includes(value))
+      parsed.range = value;
+  }
+  return parsed;
+}
+function rangeLabel(key) {
+  switch (key) {
+    case "session":
+      return "this session";
+    case "today":
+      return "today";
+    case "7d":
+      return "7 days";
+    case "30d":
+      return "30 days";
+    case "all":
+      return "all time";
+  }
+}
+function nextIn(values, current, step) {
+  const index = values.indexOf(current);
+  if (index === -1)
+    return values[0];
+  return values[(index + step + values.length) % values.length];
+}
+var DEFAULT_SETTINGS = {
+  view: "overview",
+  range: "all",
+  sort: "",
+  sortDesc: true,
+  granularity: "day",
+  turnsScope: "session",
+  modelID: "",
+  providerID: ""
+};
+function sanitizeSettings(raw) {
+  const settings = { ...DEFAULT_SETTINGS, ...raw ?? {} };
+  return {
+    view: PANEL_VIEWS.includes(settings.view) ? settings.view : DEFAULT_SETTINGS.view,
+    range: RANGE_KEYS.includes(settings.range) ? settings.range : DEFAULT_SETTINGS.range,
+    sort: typeof settings.sort === "string" ? settings.sort : DEFAULT_SETTINGS.sort,
+    sortDesc: settings.sortDesc === true,
+    granularity: GRANULARITIES.includes(settings.granularity) ? settings.granularity : DEFAULT_SETTINGS.granularity,
+    turnsScope: settings.turnsScope === "all" ? "all" : "session",
+    modelID: typeof settings.modelID === "string" ? settings.modelID : "",
+    providerID: typeof settings.providerID === "string" ? settings.providerID : ""
+  };
+}
+function formatPercent(value, digits = 1) {
+  return value === undefined ? "\u2013" : `${(value * 100).toFixed(digits)}%`;
+}
+function formatCount(value) {
+  return Math.round(value).toLocaleString("en-US");
+}
+function formatMs(value) {
+  if (value === undefined)
+    return "\u2013";
+  if (value < 1000)
+    return `${Math.round(value)}ms`;
+  if (value < 60000)
+    return `${(value / 1000).toFixed(1)}s`;
+  return formatDuration(value);
+}
+function formatTps(value) {
+  return value === undefined ? "\u2013" : `${value.toFixed(1)}/s`;
+}
+function formatTpsCompact(value) {
+  if (value === undefined)
+    return "\u2013";
+  return value >= 10 ? `${Math.round(value)}/s` : `${value.toFixed(1)}/s`;
+}
+function formatGap(value) {
+  if (value === undefined)
+    return "\u2013";
+  if (value < 60000)
+    return `${Math.round(value / 1000)}s`;
+  if (value < 3600000)
+    return `${Math.round(value / 60000)}m`;
+  if (value < 86400000)
+    return `${(value / 3600000).toFixed(1)}h`;
+  return `${(value / 86400000).toFixed(1)}d`;
+}
+function truncate(value, width) {
+  if (width <= 1)
+    return "";
+  const clean = sanitizeText(value);
+  if (clean.length <= width)
+    return clean;
+  return `${clean.slice(0, width - 1).trimEnd()}\u2026`;
+}
+function truncateMiddle(value, width) {
+  if (width <= 1)
+    return "";
+  const clean = sanitizeText(value);
+  if (clean.length <= width)
+    return clean;
+  const head = Math.ceil((width - 1) / 2);
+  const tail = width - 1 - head;
+  return `${clean.slice(0, head)}\u2026${clean.slice(clean.length - tail)}`;
+}
+function tableWidths(width, layouts) {
+  for (const layout of layouts) {
+    const total = layout.reduce((sum, column) => sum + column, 0) + layout.length - 1;
+    if (total <= width)
+      return [...layout];
+  }
+  const last = layouts[layouts.length - 1];
+  return last === undefined ? [] : [...last];
+}
+function modelCell(modelID, variant, width) {
+  return truncateMiddle(variant === undefined ? modelID : `${modelID} ${variant}`, width);
+}
+function padCell(value, width, align = "left") {
+  if (value.length >= width)
+    return value;
+  const padding = " ".repeat(width - value.length);
+  return align === "right" ? `${padding}${value}` : `${value}${padding}`;
+}
+function formatTableRow(cells, widths, aligns) {
+  const parts = [];
+  for (let index = 0;index < cells.length; index += 1) {
+    const width = widths[index] ?? 8;
+    const align = aligns?.[index] ?? "left";
+    parts.push(padCell(truncate(cells[index] ?? "", width), width, align));
+  }
+  return parts.join(" ");
+}
+function count(n, singular, plural = `${singular}s`) {
+  return `${formatCount(n)} ${n === 1 ? singular : plural}`;
+}
+function kvGrid(pairs, width) {
+  const lines = [];
+  const label = 11;
+  const column = Math.floor(width / 2);
+  for (let index = 0;index < pairs.length; index += 2) {
+    const left = pairs[index];
+    const right = pairs[index + 1];
+    const leftText = `${padCell(left[0], label)}${left[1]}`;
+    if (right === undefined) {
+      lines.push({ text: leftText, tone: "base" });
+      continue;
+    }
+    const rightText = `${padCell(right[0], label)}${right[1]}`;
+    const gap = Math.max(2, column - leftText.length);
+    if (leftText.length + gap + rightText.length <= width) {
+      lines.push({ text: `${leftText}${" ".repeat(gap)}${rightText}`, tone: "base" });
+    } else {
+      lines.push({ text: leftText, tone: "base" });
+      lines.push({ text: rightText, tone: "base" });
+    }
+  }
+  return lines;
+}
+var HEADER_TONE = "accent";
+var SPARK = ["\u2581", "\u2582", "\u2583", "\u2584", "\u2585", "\u2586", "\u2587", "\u2588"];
+function reduceSeries(values, maxBars = 48) {
+  if (values.length <= maxBars)
+    return [...values];
+  const group = Math.ceil(values.length / maxBars);
+  const reduced = [];
+  for (let index = 0;index < values.length; index += group) {
+    reduced.push(values.slice(index, index + group).reduce((sum, value) => sum + value, 0));
+  }
+  return reduced;
+}
+function sparkline(values, maxBars = 48) {
+  if (values.length === 0)
+    return "";
+  const series = reduceSeries(values, maxBars);
+  const max = Math.max(...series);
+  if (max <= 0)
+    return SPARK[0].repeat(series.length);
+  return series.map((value) => SPARK[Math.min(SPARK.length - 1, Math.max(0, Math.round(value / max * (SPARK.length - 1))))]).join("");
+}
+function usageBuckets(usage) {
+  const prompt = usage.input + usage.cached + usage.cacheWrite;
+  return {
+    steps: usage.steps,
+    input: prompt - usage.cached,
+    prompt,
+    cached: usage.cached,
+    cacheWrite: usage.cacheWrite,
+    output: usage.output + usage.reasoning,
+    reasoning: usage.reasoning,
+    cost: usage.cost,
+    hit: prompt > 0 ? usage.cached / prompt : undefined
+  };
+}
+function viewBar(view, width = 200) {
+  const key = (index) => String((index + 1) % 10);
+  const full = PANEL_VIEWS.map((name, index) => name === view ? `[${key(index)} ${name}]` : `${key(index)} ${name}`);
+  const candidates = [full, PANEL_VIEWS.map((name, index) => name === view ? `[${key(index)} ${name}]` : `${key(index)} ${name.slice(0, 3)}`)];
+  for (const parts of candidates) {
+    const text = parts.join("  ");
+    if (text.length <= width)
+      return { text, tone: "muted" };
+  }
+  return { text: `[${PANEL_VIEWS.indexOf(view) + 1} ${view}] \xB7 1-9 or [ ] to switch`, tone: "muted" };
+}
+function keysFor(of) {
+  if (of === "db")
+    return "\u2191\u2193 pick a retention \xB7 enter prune (asks first) \xB7 v vacuum \xB7 r refresh \xB7 1-9 view \xB7 ? help";
+  if (of === "periods")
+    return "\u2191\u2193 move \xB7 enter drill \xB7 b bucket \xB7 t range \xB7 m/p filter \xB7 x clear \xB7 1-9 view \xB7 ? help";
+  if (of === "turns")
+    return "\u2191\u2193 move \xB7 a scope \xB7 t range \xB7 m/p filter \xB7 x clear \xB7 1-9 view \xB7 ? help";
+  return "\u2191\u2193 move \xB7 enter drill \xB7 s sort \xB7 t range \xB7 m/p filter \xB7 x clear \xB7 1-9 view \xB7 ? help";
+}
+function filterSummary(filters) {
+  const parts = [];
+  if (filters.modelID !== undefined && filters.modelID !== "")
+    parts.push(`model=${filters.modelID}`);
+  if (filters.providerID !== undefined && filters.providerID !== "")
+    parts.push(`provider=${filters.providerID}`);
+  return parts.length > 0 ? parts.join(" \xB7 ") : undefined;
+}
+function granularityLabel(granularity) {
+  return granularity === "day" ? "per day" : granularity === "week" ? "per week" : "per month";
+}
+function helpLines(width) {
+  const lines = [
+    { text: "keys", tone: HEADER_TONE },
+    { text: "  \u2191 \u2193 j k      move the cursor \xB7 enter drills in \xB7 backspace goes back" },
+    { text: "  1-9 [ ]      choose a view \xB7 cycle views (9 is db)" },
+    { text: "  t shift+t    previous / next range" },
+    { text: "  s shift+s    cycle sort column \xB7 reverse" },
+    { text: "  b            periods bucket: day \u2192 week \u2192 month" },
+    { text: "  a            turns scope: this session \u2194 all sessions" },
+    { text: "  m p          filter by model / provider (x clears)" },
+    { text: "  r            re-read the database \xB7 f full screen \xB7 escape close" },
+    { text: "" },
+    { text: "numbers \xB7 the same buckets as the live line", tone: HEADER_TONE },
+    { text: "  prompt    everything the provider saw: cached + fresh + writes" },
+    { text: "  in        the uncached part: fresh input + cache writes" },
+    { text: "  cached    prompt read from the provider prompt cache" },
+    { text: "  write     part of `in`: prompt written into that cache" },
+    { text: "  hit       cached / prompt, weighted over the selection" },
+    { text: "  hit p50   median of the per-step hit: spots a split pattern" },
+    { text: "  out       everything generated: visible output + reasoning" },
+    { text: "  reasoning part of `out`" },
+    { text: "  cost      money, not tokens: a turn sums every step; $0 is left out" },
+    { text: "  wall      request \u2192 completed step \xB7 stream request \u2192 last chunk" },
+    { text: "  tps       out / streaming seconds, shown as p50" },
+    { text: "  switches  how often a step's model or provider differs from the step" },
+    { text: "            before it in the same session (the models view's detail), with" },
+    { text: "            the cache a provider switch cost" },
+    { text: "" },
+    { text: "identity", tone: HEADER_TONE },
+    { text: "  provider  the provider the model ran through, as OpenCode is configured" },
+    { text: "            (opencode, opencode-go, deepseek, \u2026). A gateway may re-route" },
+    { text: "            a request, but the upstream that ran the inference is not" },
+    { text: "            observable, so the provider is the identity every view shows." },
+    { text: "" },
+    { text: "database", tone: HEADER_TONE },
+    { text: "  the db view shows where the file lives, what it holds and how much" },
+    { text: "  of it is old: \u2191\u2193 pick a retention, enter prunes from its cutoff date," },
+    { text: "  v gives the space back" },
+    { text: "  local time \xB7 SQLite in the OpenCode state directory" }
+  ];
+  return lines.map((line) => ({ ...line, text: truncate(line.text, width) }));
+}
+function usagePairs(usage) {
+  if (usage === undefined)
+    return [];
+  const buckets = usageBuckets(usage);
+  const pairs = [
+    ["steps", formatCount(buckets.steps)],
+    ["in", formatTokens(buckets.input)],
+    ["prompt", formatTokens(buckets.prompt)],
+    ["cached", formatTokens(buckets.cached)],
+    ["hit", formatPercent(buckets.hit)],
+    ["out", formatTokens(buckets.output)],
+    ["write", formatTokens(buckets.cacheWrite)]
+  ];
+  if (buckets.reasoning > 0)
+    pairs.push(["reasoning", formatTokens(buckets.reasoning)]);
+  pairs.push(["cost", formatCost(buckets.cost)]);
+  if ("tps" in usage && usage.tps !== undefined)
+    pairs.push(["tps", formatTps(usage.tps)]);
+  return pairs;
+}
+function overviewLines(data, width) {
+  const lines = [];
+  lines.push({
+    text: `${rangeLabel(data.range)} \xB7 ${count(data.usage.steps, "step")} \xB7 ${count(data.usage.sessions, "session")} \xB7 ${count(data.usage.prompts, "prompt")}`,
+    tone: "muted"
+  });
+  lines.push(...kvGrid(buildOverviewPairs(data.usage, "all"), width));
+  if (data.activity !== undefined && data.activity.length > 1) {
+    const series = reduceSeries(data.activity);
+    lines.push({ text: "", tone: "muted" });
+    lines.push({ text: `activity ${sparkline(series)}  ${count(series.length, "bucket")}`, tone: "muted" });
+  }
+  if (data.session !== undefined) {
+    lines.push({ text: "", tone: "muted" });
+    lines.push({ text: "this session", tone: HEADER_TONE });
+    lines.push(...kvGrid(buildOverviewPairs(data.session, "session"), width));
+    if (data.subagents !== undefined && data.subagents.length > 0) {
+      const steps = data.subagents.reduce((sum, row) => sum + row.steps, 0);
+      const cost = data.subagents.reduce((sum, row) => sum + row.cost, 0);
+      lines.push({
+        text: `  subagents  ${count(data.subagents.length, "session")} \xB7 ${count(steps, "step")} \xB7 ${formatCost(cost)} (their own sessions)`,
+        tone: "muted"
+      });
+    }
+  }
+  if (data.coverage !== undefined) {
+    lines.push({ text: "", tone: "muted" });
+    lines.push({ text: "data coverage", tone: HEADER_TONE });
+    lines.push(...kvGrid(coveragePairs(data.coverage), width));
+  }
+  return lines;
+}
+function buildOverviewPairs(usage, scope) {
+  const pairs = usagePairs(usage);
+  if (scope === "all") {
+    pairs.push(["first", usage.firstAt === undefined ? "\u2013" : new Date(usage.firstAt).toLocaleString("en-GB")]);
+    pairs.push(["last", usage.lastAt === undefined ? "\u2013" : new Date(usage.lastAt).toLocaleString("en-GB")]);
+  }
+  return pairs;
+}
+function coveragePairs(coverage) {
+  const share = (missing) => coverage.steps === 0 ? "\u2013" : `${(missing / coverage.steps * 100).toFixed(1)}%`;
+  return [
+    ["models", `${formatCount(coverage.models)} \xB7 unknown ${share(coverage.missingModel)}`],
+    ["providers", formatCount(coverage.providers)],
+    ["unsettled", `${formatCount(coverage.unsettled)} \xB7 no tps ${share(coverage.missingTps)}`],
+    [
+      "window",
+      `${coverage.firstAt === undefined ? "\u2013" : new Date(coverage.firstAt).toLocaleString("en-GB")} \u2192 ${coverage.lastAt === undefined ? "\u2013" : new Date(coverage.lastAt).toLocaleString("en-GB")}`
+    ]
+  ];
+}
+function modelColumns(width) {
+  const layouts = [
+    { model: 30, steps: 6, prompt: 10, cached: 10, hit: 7, out: 9, cost: 9, spread: 24 },
+    { model: 26, steps: 6, prompt: 9, cached: 9, hit: 7, out: 8, cost: 8, spread: 20 },
+    { model: 20, steps: 6, prompt: 9, cached: 9, hit: 6, out: 8, cost: 8, spread: 0 },
+    { model: 18, steps: 5, prompt: 8, cached: 8, hit: 0, out: 7, cost: 8, spread: 0 },
+    { model: 14, steps: 5, prompt: 8, cached: 8, hit: 0, out: 7, cost: 0, spread: 0 }
+  ];
+  for (const layout of layouts) {
+    const total = Object.values(layout).reduce((sum, column) => sum + column, 0) + Object.values(layout).filter((column) => column > 0).length - 1;
+    if (total <= width)
+      return layout;
+  }
+  return layouts[layouts.length - 1];
+}
+function modelsLines(rows, width, extras, limit = 40) {
+  const columns = modelColumns(width);
+  const widths = [columns.model, columns.steps, columns.prompt, columns.cached];
+  const aligns = ["left", "right", "right", "right"];
+  const header = ["model", "steps", "prompt", "cached"];
+  if (columns.hit > 0) {
+    widths.push(columns.hit);
+    aligns.push("right");
+    header.push("hit");
+  }
+  widths.push(columns.out);
+  aligns.push("right");
+  header.push("out");
+  if (columns.cost > 0) {
+    widths.push(columns.cost);
+    aligns.push("right");
+    header.push("cost");
+  }
+  if (columns.spread > 0) {
+    widths.push(columns.spread);
+    aligns.push("left");
+    header.push("providers");
+  }
+  const lines = [{ text: formatTableRow(header, widths, aligns), tone: HEADER_TONE }];
+  for (const model of rows.slice(0, limit)) {
+    const key = modelKey(model.modelID, model.variant);
+    const name = modelCell(model.modelID, model.variant, columns.model);
+    const buckets = usageBuckets(model.totals);
+    const providers = unique(model.providers.map((provider) => provider.providerID));
+    const cache = extras?.cache?.get(key);
+    const switches = extras?.switches?.get(key);
+    const cells = [name, formatCount(buckets.steps), formatTokens(buckets.prompt), formatTokens(buckets.cached)];
+    if (columns.hit > 0)
+      cells.push(formatPercent(cache?.hit ?? buckets.hit));
+    cells.push(formatTokens(buckets.output));
+    if (columns.cost > 0)
+      cells.push(formatCost(buckets.cost));
+    if (columns.spread > 0)
+      cells.push(providers.join(", "));
+    lines.push({
+      text: formatTableRow(cells, widths, aligns),
+      tone: "base",
+      row: { kind: "model", value: model.modelID, ...model.variant !== undefined ? { variant: model.variant } : {} }
+    });
+    const details = [];
+    if (cache !== undefined)
+      details.push(`p50 hit ${formatPercent(cache.hitP50)}`);
+    if (switches !== undefined && switches.changes > 0) {
+      const scope = switches.providerChanges > 0 ? ` (${formatCount(switches.providerChanges)} provider)` : "";
+      details.push(`${count(switches.changes, "switch", "switches")}${scope}`);
+      if (switches.cacheLost > 0)
+        details.push(`${formatTokens(switches.cacheLost)} lost on a switch`);
+    }
+    if (details.length > 0) {
+      lines.push({ text: truncate(`${" ".repeat(columns.model + 1)}${details.join(" \xB7 ")}`, width), tone: "muted" });
+    }
+  }
+  if (rows.length > limit)
+    lines.push({ text: `\u2026 ${count(rows.length - limit, "more model")} \xB7 narrow the range or filter`, tone: "muted" });
+  if (rows.length === 0)
+    lines.push({ text: "no usage recorded for this range", tone: "muted" });
+  return lines;
+}
+function unique(values) {
+  return [...new Set(values)];
+}
+var tableWidth = (columns) => columns.reduce((sum, column) => sum + column.width, 0) + columns.length - 1;
+function fitColumns(columns, width) {
+  const chosen = [...columns];
+  while (chosen.length > 1 && tableWidth(chosen) > width) {
+    const optional = [...chosen].reverse().findIndex((column) => column.optional === true);
+    if (optional === -1)
+      break;
+    chosen.splice(chosen.length - 1 - optional, 1);
+  }
+  return chosen;
+}
+function renderTable(rows, columns, width, options) {
+  const chosen = fitColumns(columns, width);
+  const widths = chosen.map((column) => column.width);
+  const aligns = chosen.map((column) => column.align ?? "left");
+  const alignsTyped = aligns;
+  const lines = [{ text: formatTableRow(chosen.map((column) => column.header), widths, alignsTyped), tone: HEADER_TONE }];
+  if (rows.length === 0)
+    lines.push({ text: options.empty, tone: "muted" });
+  for (const row of rows.slice(0, options.limit)) {
+    const identity = options.row?.(row);
+    lines.push({
+      text: formatTableRow(chosen.map((column) => column.cell(row)), widths, alignsTyped),
+      tone: options.tone?.(row) ?? "base",
+      ...identity === undefined ? {} : { row: identity }
+    });
+  }
+  if (rows.length > options.limit)
+    lines.push({ text: `\u2026 ${count(rows.length - options.limit, "more row")}`, tone: "muted" });
+  return lines;
+}
+function providerSummaryLines(rows, width, limit = 40) {
+  const lines = renderTable(rows, [
+    { header: "provider", width: 24, cell: (row) => truncate(row.provider ?? "\u2013 (unknown)", 24) },
+    { header: "models", width: 13, align: "right", optional: true, cell: (row) => formatCount(row.models.length) },
+    { header: "steps", width: 6, align: "right", cell: (row) => formatCount(row.usage.steps) },
+    { header: "share", width: 6, align: "right", optional: true, cell: (row) => formatPercent(row.share, 0) },
+    { header: "prompt", width: 10, align: "right", cell: (row) => formatTokens(row.cache.prompt) },
+    { header: "cached", width: 10, align: "right", cell: (row) => formatTokens(row.cache.cached) },
+    { header: "hit", width: 7, align: "right", optional: true, cell: (row) => formatPercent(row.cache.hit) },
+    { header: "tps p50", width: 8, align: "right", optional: true, cell: (row) => formatTps(row.tps) },
+    { header: "wall", width: 8, align: "right", optional: true, cell: (row) => formatMs(row.wall) },
+    { header: "cost", width: 9, align: "right", optional: true, cell: (row) => formatCost(row.usage.cost) }
+  ], width, {
+    limit,
+    empty: "no usage recorded for this range",
+    row: (row) => row.provider === undefined ? undefined : { kind: "provider", value: row.provider },
+    tone: (row) => row.provider === undefined ? "muted" : "base"
+  });
+  return lines;
+}
+function providerLines(rows, width, limit = 40) {
+  return renderTable(rows, [
+    { header: "model", width: 26, cell: (row) => modelCell(row.modelID, row.variant, 26) },
+    { header: "provider", width: 22, cell: (row) => truncate(row.provider ?? "\u2013 (unknown)", 22) },
+    { header: "steps", width: 6, align: "right", cell: (row) => formatCount(row.usage.steps) },
+    { header: "share", width: 6, align: "right", optional: true, cell: (row) => formatPercent(row.share, 0) },
+    { header: "prompt", width: 10, align: "right", cell: (row) => formatTokens(row.cache.prompt) },
+    { header: "cached", width: 10, align: "right", cell: (row) => formatTokens(row.cache.cached) },
+    { header: "hit", width: 7, align: "right", optional: true, cell: (row) => formatPercent(row.cache.hit) },
+    { header: "tps p50", width: 8, align: "right", optional: true, cell: (row) => formatTps(row.tps) },
+    { header: "wall", width: 8, align: "right", optional: true, cell: (row) => formatMs(row.wall) },
+    { header: "cost", width: 9, align: "right", optional: true, cell: (row) => formatCost(row.usage.cost) }
+  ], width, {
+    limit,
+    empty: "no usage recorded for this range",
+    row: (row) => ({ kind: "model", value: row.modelID, ...row.variant !== undefined ? { variant: row.variant } : {} }),
+    tone: (row) => row.provider === undefined ? "muted" : "base"
+  });
+}
+function cacheLines(data, width) {
+  const lines = [];
+  const total = data.drops.reduce((sum, drop) => sum + drop.tokens, 0);
+  lines.push({ text: `reuse losses  ${count(data.drops.length, "event")} \xB7 ${formatTokens(total)} tokens`, tone: total > 0 ? "warning" : "base" });
+  for (const reason of ["expired", "compaction", "unknown"]) {
+    const group = data.drops.filter((drop) => drop.reason === reason);
+    if (group.length === 0)
+      continue;
+    const tokens = group.reduce((sum, drop) => sum + drop.tokens, 0);
+    lines.push({ text: `  ${padCell(reason, 11)}${formatCount(group.length)} \xB7 ${formatTokens(tokens)}`, tone: reason === "expired" ? "warning" : "muted" });
+  }
+  if (data.drops.length === 0)
+    lines.push({ text: "  none: prompt cache held through every gap", tone: "muted" });
+  if (data.models !== undefined && data.models.length > 0) {
+    lines.push({ text: "", tone: "muted" });
+    lines.push({ text: "reuse by model", tone: HEADER_TONE });
+    const widths = width >= 100 ? [30, 7, 11, 10, 8, 8, 10] : [18, 6, 9, 9, 7, 7, 9];
+    lines.push({ text: formatTableRow(["model", "steps", "prompt", "cached", "write", "hit", "hit p50"], widths, ["left", "right", "right", "right", "right", "right", "right"]), tone: "muted" });
+    for (const row of data.models.slice(0, 10)) {
+      const name = modelCell(row.usage.modelID, row.usage.variant, widths[0]);
+      lines.push({
+        text: formatTableRow([name, formatCount(row.cache.steps), formatTokens(row.cache.prompt), formatTokens(row.cache.cached), formatTokens(row.cache.cacheWrite), formatPercent(row.cache.hit), formatPercent(row.cache.hitP50)], widths, ["left", "right", "right", "right", "right", "right", "right"]),
+        tone: "base",
+        row: { kind: "model", value: row.usage.modelID, ...row.usage.variant !== undefined ? { variant: row.usage.variant } : {} }
+      });
+    }
+  }
+  if (data.gap !== undefined && data.gap.samples > 0) {
+    lines.push({ text: "", tone: "muted" });
+    lines.push({ text: "cache survival against idle time", tone: HEADER_TONE });
+    const widths = [9, 8, 9, 9, 10];
+    lines.push({ text: formatTableRow(["gap", "pairs", "kept", "drops", "lost"], widths, ["left", "right", "right", "right", "right"]), tone: "muted" });
+    for (const bucket of data.gap.buckets) {
+      if (bucket.samples === 0)
+        continue;
+      lines.push({
+        text: formatTableRow([bucket.label, formatCount(bucket.samples), formatPercent(bucket.retainedRatio, 0), formatCount(bucket.drops), formatTokens(bucket.lostTokens)], widths, ["left", "right", "right", "right", "right"]),
+        tone: bucket.drops > 0 ? "warning" : "base"
+      });
+    }
+    if (data.gap.providers.length > 1) {
+      lines.push({ text: "", tone: "muted" });
+      lines.push({ text: "reuse kept, by provider", tone: HEADER_TONE });
+      const providerWidths = [26, 8, 9, 9];
+      lines.push({ text: formatTableRow(["provider", "pairs", "kept", "lost"], providerWidths, ["left", "right", "right", "right"]), tone: "muted" });
+      for (const row of data.gap.providers.slice(0, 8)) {
+        lines.push({
+          text: formatTableRow([row.provider, formatCount(row.samples), formatPercent(row.retainedRatio, 0), formatTokens(row.lostTokens)], providerWidths, ["left", "right", "right", "right"]),
+          tone: "base"
+        });
+      }
+    }
+  }
+  lines.push({ text: "", tone: "muted" });
+  lines.push({ text: "observed cache TTL bounds", tone: HEADER_TONE });
+  if (data.evidence.length === 0) {
+    lines.push({ text: "  no comparable step pairs yet", tone: "muted" });
+  } else {
+    const widths = [Math.max(18, Math.floor(width * 0.4)), 14, 12, 9];
+    lines.push({ text: formatTableRow(["model", "hits up to", "drops from", "samples"], widths, ["left", "right", "right", "right"]), tone: "muted" });
+    for (const row of data.evidence.slice(0, 10)) {
+      lines.push({
+        text: formatTableRow([`${row.providerID}/${row.modelID}`, formatGap(row.maxHitGapMs), formatGap(row.minDropGapMs), formatCount(row.samples)], widths, ["left", "right", "right", "right"]),
+        tone: "base"
+      });
+    }
+  }
+  if (data.drops.length > 0) {
+    lines.push({ text: "", tone: "muted" });
+    lines.push({ text: "recent losses", tone: HEADER_TONE });
+    for (const drop of [...data.drops].sort((a, b) => b.at - a.at).slice(0, 8)) {
+      const when = new Date(drop.at).toLocaleTimeString("en-GB");
+      lines.push({
+        text: formatTableRow([when, `${drop.providerID ?? ""}/${drop.modelID ?? ""}`, `\u2212${formatTokens(drop.tokens)}`, `${formatGap(drop.gapMs)} idle \xB7 ${drop.reason}`], [10, Math.max(20, Math.floor(width * 0.42)), 10, 24], ["left", "left", "right", "left"]),
+        tone: drop.reason === "expired" ? "warning" : "base"
+      });
+    }
+  }
+  return lines;
+}
+function periodLines(rows, width, granularity, limit = 40) {
+  const lines = [];
+  const totals = rows.reduce((sum, row) => {
+    sum.steps += row.usage.steps;
+    sum.sessions += row.sessions;
+    sum.input += row.usage.input;
+    sum.cached += row.usage.cached;
+    sum.cacheWrite += row.usage.cacheWrite;
+    sum.output += row.usage.output;
+    sum.reasoning += row.usage.reasoning;
+    sum.cost += row.usage.cost;
+    return sum;
+  }, { steps: 0, sessions: 0, input: 0, cached: 0, cacheWrite: 0, output: 0, reasoning: 0, cost: 0 });
+  const overall = usageBuckets(totals);
+  lines.push({
+    text: `${granularityLabel(granularity)} \xB7 ${count(rows.length, "period")} \xB7 ${count(totals.steps, "step")} \xB7 hit ${formatPercent(overall.hit)}`,
+    tone: "muted"
+  });
+  if (rows.length > 1) {
+    lines.push({ text: `steps   ${sparkline(rows.map((row) => row.usage.steps))}`, tone: "muted" });
+    lines.push({ text: `cached  ${sparkline(rows.map((row) => row.usage.cached))}`, tone: "muted" });
+    lines.push({ text: `cost    ${sparkline(rows.map((row) => Math.round(row.usage.cost * 1e4)))}`, tone: "muted" });
+  }
+  const withSessions = tableWidths(width, [[12, 7, 7, 11, 10, 7, 9, 9]]).length === 8;
+  const widths = withSessions ? [12, 7, 7, 11, 10, 7, 9, 9] : [12, 7, 11, 10, 7, 9, 9];
+  const aligns = widths.map((_, index) => index === 0 ? "left" : "right");
+  const header = withSessions ? ["period", "steps", "sess", "prompt", "cached", "hit", "out", "cost"] : ["period", "steps", "prompt", "cached", "hit", "out", "cost"];
+  lines.push({ text: formatTableRow(header, widths, aligns), tone: HEADER_TONE });
+  const newest = [...rows].sort((left, right) => right.at - left.at).slice(0, limit);
+  for (const row of newest) {
+    const buckets = usageBuckets(row.usage);
+    const cells = [
+      row.label,
+      formatCount(row.steps),
+      ...withSessions ? [formatCount(row.sessions)] : [],
+      formatTokens(buckets.prompt),
+      formatTokens(buckets.cached),
+      formatPercent(buckets.hit, 0),
+      formatTokens(buckets.output),
+      formatCost(buckets.cost)
+    ];
+    lines.push({ text: formatTableRow(cells, widths, aligns), tone: "base", row: { kind: "period", value: row.key } });
+  }
+  lines.push({ text: "", tone: "muted" });
+  lines.push({
+    text: formatTableRow([
+      "total",
+      formatCount(totals.steps),
+      ...withSessions ? [formatCount(totals.sessions)] : [],
+      formatTokens(overall.prompt),
+      formatTokens(overall.cached),
+      formatPercent(overall.hit, 0),
+      formatTokens(overall.output),
+      formatCost(overall.cost)
+    ], widths, aligns),
+    tone: HEADER_TONE
+  });
+  if (rows.length === 0)
+    lines.push({ text: "no usage recorded for this range", tone: "muted" });
+  return lines;
+}
+function latencyLines(report, width, groups, limit = 12) {
+  const lines = [];
+  lines.push({
+    text: formatTableRow(["wall", "p50", formatMs(report.wall.p50), "p90", formatMs(report.wall.p90), "p99", formatMs(report.wall.p99), `n ${formatCount(report.wall.count)}`], [10, 4, 9, 4, 9, 4, 9, 12]),
+    tone: "base"
+  });
+  lines.push({
+    text: formatTableRow(["stream", "p50", formatMs(report.stream.p50), "p90", formatMs(report.stream.p90), "p99", formatMs(report.stream.p99)], [10, 4, 9, 4, 9, 4, 9]),
+    tone: "base"
+  });
+  lines.push({
+    text: formatTableRow(["throughput", "p50", formatTps(report.tps.p50), "p90", formatTps(report.tps.p90), "p99", formatTps(report.tps.p99)], [10, 4, 9, 4, 9, 4, 9]),
+    tone: "base"
+  });
+  lines.push({ text: "", tone: "muted" });
+  lines.push({
+    text: truncate("wall = request to completed \xB7 stream = request to last chunk \xB7 throughput = output+reasoning tokens/s", width),
+    tone: "muted"
+  });
+  if (report.wall.count === 0)
+    lines.push({ text: "no completed steps for this range", tone: "muted" });
+  if (groups !== undefined && groups.length > 0) {
+    lines.push({ text: "", tone: "muted" });
+    lines.push({ text: "by group", tone: HEADER_TONE });
+    const widths = width >= 110 ? [24, 6, 9, 9, 9, 9, 9, 9] : [16, 5, 8, 8, 8, 8, 8, 8];
+    const aligns = ["left", "right", "right", "right", "right", "right", "right", "right"];
+    lines.push({ text: formatTableRow(["group", "n", "wall p50", "wall p90", "stream", "tps p50", "tps p90", "cost"], widths, aligns), tone: "muted" });
+    for (const row of groups.slice(0, limit)) {
+      const thin = row.count < 5;
+      lines.push({
+        text: formatTableRow([row.label, formatCount(row.count), formatMs(row.wall.p50), formatMs(row.wall.p90), formatMs(row.stream.p50), formatTps(row.tps.p50), formatTps(row.tps.p90), formatCost(row.usage.cost)], widths, aligns),
+        tone: thin ? "muted" : "base",
+        row: { kind: "model", value: row.key }
+      });
+    }
+    lines.push({ text: "n < 5 is dimmed: too few samples to compare", tone: "muted" });
+  }
+  return lines;
+}
+function sessionsLines(rows, width, options) {
+  const limit = options?.limit ?? 20;
+  const widths = [Math.max(18, Math.floor(width * 0.36)), 7, 11, 10, 7, 9, 9];
+  const aligns = ["left", "right", "right", "right", "right", "right", "right"];
+  const lines = [
+    { text: formatTableRow(["title", "steps", "prompt", "cached", "hit", "out", "cost"], widths, aligns), tone: HEADER_TONE }
+  ];
+  const byID = new Map(rows.map((row) => [row.sessionID, row]));
+  const ordered = rows.filter((row) => row.parentID === undefined || !byID.has(row.parentID));
+  const children = rows.filter((row) => row.parentID !== undefined && byID.has(row.parentID));
+  const orderedAll = [...ordered, ...children];
+  for (const row of orderedAll.slice(0, limit)) {
+    const child = row.parentID !== undefined && byID.has(row.parentID);
+    const title = truncate(row.title ?? row.sessionID, Math.max(8, widths[0] - (child ? 2 : 0)));
+    const buckets = usageBuckets(row);
+    lines.push({
+      text: formatTableRow([
+        `${child ? "\u21B3 " : ""}${title}`,
+        formatCount(buckets.steps),
+        formatTokens(buckets.prompt),
+        formatTokens(buckets.cached),
+        formatPercent(buckets.hit, 0),
+        formatTokens(buckets.output),
+        formatCost(buckets.cost)
+      ], widths, aligns),
+      tone: child ? "muted" : "base",
+      row: { kind: "session", value: row.sessionID }
+    });
+    const details = [row.directory ?? "", row.models.length > 1 ? count(row.models.length, "model") : ""].filter((part) => part !== "").join(" \xB7 ");
+    lines.push({ text: truncate(`${" ".repeat(child ? 2 : 0)}  ${details}`, width), tone: "muted" });
+  }
+  if (options?.rollup !== undefined && options.rollup.subagentSteps > 0) {
+    const share = rows.reduce((sum, row) => sum + row.steps, 0);
+    lines.push({ text: "", tone: "muted" });
+    lines.push({
+      text: `subagents ${formatCount(options.rollup.subagentSteps)} steps (${formatPercent(share > 0 ? options.rollup.subagentSteps / share : undefined)}) \xB7 ${formatCost(options.rollup.subagentCost)}`,
+      tone: "muted"
+    });
+  }
+  if (rows.length > limit)
+    lines.push({ text: `\u2026 ${count(rows.length - limit, "more session")} \xB7 narrow the range`, tone: "muted" });
+  if (rows.length === 0)
+    lines.push({ text: "no sessions recorded for this range", tone: "muted" });
+  return lines;
+}
+function dbLines(data, width) {
+  const lines = [];
+  const size = (bytes) => `${(bytes / 1048576).toFixed(1)} MB`;
+  lines.push({ text: truncate(data.info.path, width), tone: "base" });
+  lines.push({
+    text: `${size(data.info.bytes)}${data.info.walBytes === undefined ? "" : ` + ${size(data.info.walBytes)} wal`} \xB7 schema v${data.info.schemaVersion}`,
+    tone: "muted"
+  });
+  lines.push({ text: "", tone: "muted" });
+  lines.push({ text: "what it holds", tone: HEADER_TONE });
+  for (const table of data.info.tables) {
+    lines.push({ text: `  ${padCell(table.name, 12)}${formatCount(table.rows)} rows`, tone: table.rows === 0 ? "muted" : "base" });
+  }
+  lines.push({
+    text: `  window      ${data.info.firstAt === undefined ? "\u2013" : new Date(data.info.firstAt).toLocaleDateString("en-GB")} \u2192 ${data.info.lastAt === undefined ? "\u2013" : new Date(data.info.lastAt).toLocaleDateString("en-GB")}`,
+    tone: "muted"
+  });
+  lines.push({ text: "", tone: "muted" });
+  lines.push({ text: "clean up", tone: HEADER_TONE });
+  lines.push({ text: truncate("  \u2191\u2193 pick a retention \xB7 enter prunes the steps older than it (asks first) \xB7 v gives the space back", width), tone: "muted" });
+  const widths = [10, 13, 10];
+  lines.push({ text: formatTableRow(["keep", "prunes", "older than"], widths, ["left", "right", "left"]), tone: "muted" });
+  for (const option of data.info.removable) {
+    const before = new Date(data.now - option.days * 24 * 60 * 60 * 1000).toLocaleDateString("en-GB");
+    lines.push({
+      text: formatTableRow([`${option.days} days`, `${formatCount(option.steps)} steps`, before], widths, ["left", "right", "left"]),
+      tone: option.steps === 0 ? "muted" : "base",
+      row: { kind: "prune", value: String(option.days) }
+    });
+  }
+  if (data.busy === true) {
+    lines.push({ text: "", tone: "muted" });
+    lines.push({ text: "the recorder is writing: try the vacuum again in a moment", tone: "warning" });
+  }
+  return lines;
+}
+function turnStats(turn) {
+  return {
+    endAt: turn.endAt,
+    startAt: turn.promptAt ?? turn.endAt,
+    promptAt: turn.promptAt,
+    promptGapMs: turn.promptGapMs,
+    providerID: turn.providerID,
+    modelID: turn.modelID,
+    variant: turn.variant,
+    providerChanged: turn.providerChanged,
+    modelChanged: turn.modelChanged,
+    totals: turn.totals,
+    latest: turn.latest,
+    session: undefined,
+    drops: turn.drops.map((drop) => ({ messageID: drop.messageID, tokens: drop.tokens, prevCached: 0, gapMs: drop.gapMs })),
+    cacheDropTokens: turn.drops.reduce((sum, drop) => sum + drop.tokens, 0),
+    cacheExpired: turn.drops.length > 0,
+    steps: turn.steps
+  };
+}
+function turnsLines(rows, width, options) {
+  const lines = [];
+  const warning = rows.filter((turn) => turn.drops.length > 0).length;
+  lines.push({
+    text: `${count(rows.length, "turn")} \xB7 newest first${warning > 0 ? ` \xB7 ${count(warning, "turn")} with a cache loss` : ""}`,
+    tone: "muted"
+  });
+  const showSession = options?.sessionTitles !== undefined;
+  for (const turn of rows) {
+    const line = formatLine(turnStats(turn), {
+      ...options,
+      fields: { ...options?.fields, session: false }
+    });
+    const title = showSession ? `${truncate(options.sessionTitles.get(turn.sessionID) ?? turn.sessionID, 18)}  ` : "";
+    lines.push({
+      text: truncate(`${title}${line}`, width),
+      tone: turn.drops.length > 0 || turn.providerChanged ? "warning" : "base",
+      row: { kind: "turn", value: turn.sessionID }
+    });
+  }
+  if (rows.length === 0)
+    lines.push({ text: "no finished turns for this range", tone: "muted" });
+  return lines;
+}
+function sessionSummaryLines(usage, budget = 34) {
+  const buckets = usageBuckets(usage);
+  const steps = formatCount(buckets.steps);
+  const input = formatTokens(buckets.input);
+  const cached = formatTokens(buckets.cached);
+  const out = formatTokens(buckets.output);
+  const hit = formatPercent(buckets.hit);
+  const tps = formatTpsCompact(usage.tps);
+  const cost = formatCost(buckets.cost);
+  const first = [
+    `  ${steps} steps \xB7 in ${input}`,
+    `  ${steps} steps`
+  ].find((text) => text.length <= budget);
+  const second = [
+    `  cached ${cached} \xB7 out ${out}`,
+    `  cached ${cached}`
+  ].find((text) => text.length <= budget);
+  const last = [
+    `  hit ${hit} \xB7 ${tps} \xB7 ${cost}`,
+    `  hit ${hit} \xB7 ${cost}`,
+    `  ${cost}`
+  ].find((text) => text.length <= budget);
+  return [
+    { text: truncate("session", budget), tone: HEADER_TONE },
+    { text: truncate(first ?? `  ${steps} steps`, budget), tone: "muted" },
+    { text: truncate(second ?? `  cached ${cached}`, budget), tone: "base" },
+    { text: truncate(last ?? `  ${cost}`, budget), tone: "base" },
+    { text: "", tone: "muted" }
+  ];
+}
+function sidebarLines(rows, options) {
+  const budget = options?.budget ?? 34;
+  const labels = { input: options?.labels?.input ?? "in", output: options?.labels?.output ?? "out" };
+  const lines = [];
+  for (const [index, turn] of rows.entries()) {
+    const clock = turn.endAt !== undefined ? formatClock(turn.endAt).slice(0, 5) : "--:--";
+    const provider = turn.providerID ?? "unknown";
+    const display = displayTotals(turn.latest);
+    const input = formatTokens(display.input);
+    const prompt = formatTokens(display.prompt);
+    const output = formatTokens(display.output);
+    const cost = formatCost(turn.totals.cost);
+    const hit = formatPercent(display.prompt > 0 ? display.cached / display.prompt : undefined).replace(/\.0%$/, "%");
+    const tps = turn.tps === undefined ? undefined : formatTpsCompact(turn.tps);
+    const suffix = turn.drops.length > 0 ? " \xB7 \u26A0" : "";
+    const volumes = [
+      `  ${labels.input} ${input} (${prompt}) \xB7 ${labels.output} ${output}`,
+      `  ${labels.input} ${input} \xB7 ${labels.output} ${output}`,
+      `  ${labels.input} ${input}`
+    ];
+    const facts = [
+      `  hit ${hit}${tps === undefined ? "" : ` \xB7 ${tps}`} \xB7 ${cost}${suffix}`,
+      `  hit ${hit}${tps === undefined ? "" : ` \xB7 ${tps}`}${suffix}`,
+      `  ${tps === undefined ? "" : `${tps} \xB7 `}${cost}${suffix}`,
+      `  hit ${hit}${suffix}`
+    ];
+    lines.push({ text: truncate(`${clock} ${provider}`, budget), tone: turn.providerChanged ? "warning" : "base" });
+    const edge = index === 0 || index === rows.length - 1;
+    if (edge || turn.modelChanged || turn.providerChanged) {
+      const model = turn.modelID === undefined ? "unknown" : `${turn.modelID}${turn.variant === undefined ? "" : ` ${turn.variant}`}`;
+      lines.push({ text: truncate(`  ${model}`, budget), tone: "muted" });
+    }
+    lines.push({
+      text: truncate(volumes.find((text) => text.length <= budget) ?? volumes[volumes.length - 1], budget),
+      tone: "muted"
+    });
+    lines.push({
+      text: truncate(facts.find((text) => text.length <= budget) ?? facts[facts.length - 1], budget),
+      tone: turn.drops.length > 0 ? "warning" : "muted"
+    });
+  }
+  if (rows.length === 0)
+    lines.push({ text: "no finished turns yet", tone: "muted" });
+  return lines;
+}
+
+// src/panel.tsx
+import { effect as _$effect } from "@opentui/solid";
+import { insertNode as _$insertNode } from "@opentui/solid";
+import { insert as _$insert } from "@opentui/solid";
+import { createComponent as _$createComponent } from "@opentui/solid";
+import { use as _$use } from "@opentui/solid";
+import { setProp as _$setProp } from "@opentui/solid";
+import { createElement as _$createElement } from "@opentui/solid";
+import { TextAttributes } from "@opentui/core";
+import { For, createMemo, createRenderEffect, createSignal } from "solid-js";
+
+// src/stats/aggregates.ts
+var STEP_AT = "COALESCE(created_at, recorded_at)";
+function normalize(rows, optional) {
+  for (const row of rows) {
+    for (const key of optional)
+      if (row[key] === null)
+        row[key] = undefined;
+  }
+  return rows;
+}
+function groupBy(items, key) {
+  const groups = new Map;
+  for (const item of items) {
+    const group = key(item);
+    const list = groups.get(group);
+    if (list !== undefined)
+      list.push(item);
+    else
+      groups.set(group, [item]);
+  }
+  return groups;
+}
+var STEP_COLUMNS = `message_id AS messageID, session_id AS sessionID, provider_id AS providerID,
+       model_id AS modelID, variant,
+       COALESCE(input_tokens, 0) AS input, COALESCE(cache_read, 0) AS cached, COALESCE(cache_write, 0) AS cacheWrite,
+       COALESCE(output_tokens, 0) AS output, COALESCE(reasoning_tokens, 0) AS reasoning, COALESCE(cost, 0) AS cost,
+       created_at AS createdAt, streamed_at AS streamedAt, completed_at AS completedAt, ${STEP_AT} AS at`;
+var STEP_OPTIONAL = ["providerID", "modelID", "variant", "createdAt", "streamedAt", "completedAt"];
+var PAIR_COLUMNS = STEP_COLUMNS.replace("COALESCE(output_tokens, 0) AS output, COALESCE(reasoning_tokens, 0) AS reasoning, ", "");
+function stepRows(db, options) {
+  const filter = buildWhere(options?.range, options?.filters);
+  const rows = db.query(`SELECT ${STEP_COLUMNS} FROM steps ${filter.where}`).all(...filter.params);
+  return normalize(rows, STEP_OPTIONAL);
+}
+function cachePairs(db, options) {
+  const filter = buildWhere(options?.range, options?.filters);
+  const rows = normalize(db.query(`SELECT ${PAIR_COLUMNS} FROM steps ${filter.where} ORDER BY session_id, ${STEP_AT}, message_id`).all(...filter.params), STEP_OPTIONAL);
+  const from = options?.range?.from;
+  if (from === undefined || rows.length === 0)
+    return rows;
+  const seek = db.query(`SELECT ${PAIR_COLUMNS} FROM steps
+      WHERE session_id = ? AND COALESCE(created_at, recorded_at) < ?
+      ORDER BY COALESCE(created_at, recorded_at) DESC, message_id DESC LIMIT 1`);
+  for (const sessionID of new Set(rows.map((row) => row.sessionID))) {
+    const boundary = seek.get(sessionID, from);
+    if (boundary === null)
+      continue;
+    const step = normalize([boundary], STEP_OPTIONAL)[0];
+    step.boundary = true;
+    rows.push(step);
+  }
+  rows.sort((left, right) => {
+    if (left.sessionID !== right.sessionID)
+      return left.sessionID < right.sessionID ? -1 : 1;
+    if (left.at !== right.at)
+      return left.at - right.at;
+    return left.messageID < right.messageID ? -1 : left.messageID > right.messageID ? 1 : 0;
+  });
+  return rows;
+}
+function message(step) {
+  return {
+    type: "assistant",
+    id: step.messageID,
+    ...step.modelID === undefined ? {} : { model: { providerID: step.providerID ?? "", id: step.modelID, ...step.variant === undefined ? {} : { variant: step.variant } } },
+    tokens: { cache: { read: step.cached } },
+    time: {
+      ...step.createdAt === undefined ? {} : { created: step.createdAt },
+      ...step.streamedAt === undefined ? {} : { streamed: step.streamedAt },
+      ...step.completedAt === undefined ? {} : { completed: step.completedAt }
+    }
+  };
+}
+function pairsOf(rows) {
+  const pairs = [];
+  for (let index = 1;index < rows.length; index += 1) {
+    const previous = rows[index - 1];
+    const current = rows[index];
+    if (previous.sessionID !== current.sessionID)
+      continue;
+    pairs.push({ previous, current });
+  }
+  return pairs;
+}
+function usageOf(steps) {
+  const usage = { steps: 0, input: 0, cached: 0, cacheWrite: 0, output: 0, reasoning: 0, cost: 0 };
+  for (const step of steps) {
+    usage.steps += 1;
+    usage.input += step.input;
+    usage.cached += step.cached;
+    usage.cacheWrite += step.cacheWrite;
+    usage.output += step.output;
+    usage.reasoning += step.reasoning;
+    usage.cost += step.cost;
+  }
+  return usage;
+}
+function coverageOf(db, options) {
+  const filter = buildWhere(options?.range, options?.filters);
+  const row = db.query(`SELECT COUNT(*) AS steps,
+              COUNT(DISTINCT CASE WHEN model_id IS NOT NULL THEN model_id || '#' || COALESCE(variant, '') END) AS models,
+              COUNT(DISTINCT provider_id) AS providers,
+              COALESCE(SUM(CASE WHEN model_id IS NULL THEN 1 ELSE 0 END), 0) AS missingModel,
+              COALESCE(SUM(CASE WHEN completed_at IS NOT NULL OR finish IS NOT NULL THEN 0 ELSE 1 END), 0) AS unsettled,
+              COALESCE(SUM(CASE WHEN (output_tokens + reasoning_tokens) > 0 AND created_at IS NOT NULL AND streamed_at IS NOT NULL AND streamed_at > created_at THEN 0 ELSE 1 END), 0) AS missingTps,
+              MIN(${STEP_AT}) AS firstAt,
+              MAX(${STEP_AT}) AS lastAt
+         FROM steps ${filter.where}`).get(...filter.params);
+  return {
+    steps: row.steps,
+    models: row.models,
+    providers: row.providers,
+    missingModel: row.missingModel,
+    unsettled: row.unsettled,
+    missingTps: row.missingTps,
+    firstAt: row.firstAt ?? undefined,
+    lastAt: row.lastAt ?? undefined
+  };
+}
+function groupedRows(db, options) {
+  const filter = buildWhere(options?.range, options?.filters);
+  const rows = db.query(`SELECT ${STEP_COLUMNS} FROM steps ${filter.where}`).all(...filter.params);
+  return normalize(rows, STEP_OPTIONAL);
+}
+function timingOf(step) {
+  const wall = step.createdAt !== undefined && step.completedAt !== undefined ? step.completedAt - step.createdAt : undefined;
+  const stream = step.createdAt !== undefined && step.streamedAt !== undefined && step.streamedAt > step.createdAt ? step.streamedAt - step.createdAt : undefined;
+  return { wall, stream, tps: tokensPerSecond(step.output + step.reasoning, step.createdAt, step.streamedAt) };
+}
+function timingRows(db, options) {
+  return groupedRows(db, options);
+}
+function latencyOf(rows) {
+  const wall = [];
+  const stream = [];
+  const tps = [];
+  for (const step of rows) {
+    const timing = timingOf(step);
+    if (timing.wall !== undefined)
+      wall.push(timing.wall);
+    if (timing.stream !== undefined)
+      stream.push(timing.stream);
+    if (timing.tps !== undefined)
+      tps.push(timing.tps);
+  }
+  return { wall: latencyStats(wall), stream: latencyStats(stream), tps: latencyStats(tps) };
+}
+function latencyGroupsOf(rows, by) {
+  const key = (step) => by === "model" ? modelKey(step.modelID ?? "(unknown)", step.variant) : step.providerID ?? "(unknown)";
+  const groups = [];
+  for (const [group, steps] of groupBy(rows, key)) {
+    const wall = [];
+    const stream = [];
+    const tps = [];
+    for (const step of steps) {
+      const timing = timingOf(step);
+      if (timing.wall !== undefined)
+        wall.push(timing.wall);
+      if (timing.stream !== undefined)
+        stream.push(timing.stream);
+      if (timing.tps !== undefined)
+        tps.push(timing.tps);
+    }
+    const [modelID, variant] = group.split("#");
+    groups.push({
+      key: group,
+      label: by === "model" ? variant === undefined || variant === "" ? modelID : `${modelID} ${variant}` : group,
+      count: steps.length,
+      usage: usageOf(steps),
+      wall: latencyStats(wall),
+      stream: latencyStats(stream),
+      tps: latencyStats(tps)
+    });
+  }
+  return groups.sort((left, right) => right.count - left.count || left.key.localeCompare(right.key));
+}
+var EMPTY_CACHE = { steps: 0, input: 0, cached: 0, cacheWrite: 0, prompt: 0, hit: undefined, hitP50: undefined };
+function cacheStatsOfSteps(steps) {
+  let input = 0;
+  let cached = 0;
+  let cacheWrite = 0;
+  const ratios = [];
+  for (const step of steps) {
+    input += step.input;
+    cached += step.cached;
+    cacheWrite += step.cacheWrite;
+    const prompt = step.input + step.cached + step.cacheWrite;
+    if (prompt > 0)
+      ratios.push(step.cached / prompt);
+  }
+  const prompt = input + cached + cacheWrite;
+  return { steps: steps.length, input, cached, cacheWrite, prompt, hit: prompt > 0 ? cached / prompt : undefined, hitP50: percentile(ratios, 50) };
+}
+function cacheStatsOf(db, options) {
+  const rows = stepRows(db, options);
+  return rows.length === 0 ? EMPTY_CACHE : cacheStatsOfSteps(rows);
+}
+function cacheStatsByModel(rows) {
+  const out = [];
+  const inRange = rows.filter((row) => row.boundary !== true);
+  for (const [, group] of groupBy(inRange, (row) => modelKey(row.modelID ?? "(unknown)", row.variant))) {
+    out.push({ modelID: group[0].modelID ?? "(unknown)", variant: group[0].variant, cache: cacheStatsOfSteps(group) });
+  }
+  return out.sort((left, right) => right.cache.cached - left.cache.cached || left.modelID.localeCompare(right.modelID));
+}
+function switchesOf(rows) {
+  const perModel = new Map;
+  const totals = { pairs: 0, changes: 0, cacheLost: 0, cacheLostEvents: 0 };
+  for (const { previous, current } of pairsOf(rows)) {
+    if (previous.modelID === undefined || current.modelID === undefined)
+      continue;
+    const key = modelKey(current.modelID, current.variant);
+    const row = perModel.get(key) ?? {
+      modelID: current.modelID,
+      variant: current.variant,
+      steps: 0,
+      pairs: 0,
+      changes: 0,
+      modelChanges: 0,
+      providerChanges: 0,
+      cacheLost: 0,
+      cacheLostEvents: 0
+    };
+    row.steps += 1;
+    row.pairs += 1;
+    totals.pairs += 1;
+    const modelChanged = key !== modelKey(previous.modelID, previous.variant);
+    const providerChanged = previous.providerID !== undefined && current.providerID !== undefined && previous.providerID !== current.providerID;
+    if (modelChanged)
+      row.modelChanges += 1;
+    if (providerChanged)
+      row.providerChanges += 1;
+    if (modelChanged || providerChanged) {
+      row.changes += 1;
+      totals.changes += 1;
+      const lost = cacheDrop(message(previous), message(current), "model");
+      if (lost !== undefined) {
+        row.cacheLost += lost;
+        row.cacheLostEvents += 1;
+        totals.cacheLost += lost;
+        totals.cacheLostEvents += 1;
+      }
+    }
+    perModel.set(key, row);
+  }
+  return {
+    rows: [...perModel.values()].sort((left, right) => right.changes - left.changes || right.steps - left.steps || left.modelID.localeCompare(right.modelID)),
+    totals
+  };
+}
+var GAP_BUCKETS = [
+  ["<1m", 0, 60000],
+  ["1\u20135m", 60000, 5 * 60000],
+  ["5\u201315m", 5 * 60000, 15 * 60000],
+  ["15\u201360m", 15 * 60000, 60 * 60000],
+  ["1\u20136h", 60 * 60000, 6 * 60 * 60000],
+  [">6h", 6 * 60 * 60000, undefined]
+];
+function bucketFor(gapMs) {
+  const index = GAP_BUCKETS.findIndex(([, from, to]) => gapMs >= from && (to === undefined || gapMs < to));
+  return index === -1 ? GAP_BUCKETS.length - 1 : index;
+}
+function gapReportOf(rows) {
+  const buckets = GAP_BUCKETS.map(([label]) => ({ label, samples: 0, retained: 0, drops: 0, lostTokens: 0, retainedRatio: undefined }));
+  const providers = new Map;
+  let samples = 0;
+  for (const { previous, current } of pairsOf(rows)) {
+    if (previous.modelID === undefined || current.modelID === undefined)
+      continue;
+    if (modelKey(previous.modelID, previous.variant) !== modelKey(current.modelID, current.variant))
+      continue;
+    if ((previous.providerID ?? "") !== (current.providerID ?? ""))
+      continue;
+    const gap = stepGap(message(previous), message(current));
+    if (gap === undefined)
+      continue;
+    const lost = cacheDrop(message(previous), message(current));
+    const bucket = buckets[bucketFor(gap)];
+    bucket.samples += 1;
+    samples += 1;
+    if (lost === undefined)
+      bucket.retained += 1;
+    else {
+      bucket.drops += 1;
+      bucket.lostTokens += lost;
+    }
+    const provider = current.providerID ?? previous.providerID ?? "(unknown)";
+    const row = providers.get(provider) ?? { provider, samples: 0, retained: 0, drops: 0, lostTokens: 0, retainedRatio: undefined };
+    row.samples += 1;
+    if (lost === undefined)
+      row.retained += 1;
+    else {
+      row.drops += 1;
+      row.lostTokens += lost;
+    }
+    providers.set(provider, row);
+  }
+  for (const bucket of buckets)
+    bucket.retainedRatio = bucket.samples > 0 ? bucket.retained / bucket.samples : undefined;
+  for (const row of providers.values())
+    row.retainedRatio = row.samples > 0 ? row.retained / row.samples : undefined;
+  return {
+    buckets,
+    providers: [...providers.values()].sort((left, right) => right.samples - left.samples || left.provider.localeCompare(right.provider)),
+    samples
+  };
+}
+function ttlEvidenceOf(rows) {
+  const evidence = new Map;
+  for (const { previous, current } of pairsOf(rows)) {
+    if (previous.modelID === undefined || current.modelID === undefined)
+      continue;
+    const key = `${current.providerID ?? ""}/${current.modelID}`;
+    const before = `${previous.providerID ?? ""}/${previous.modelID}#${previous.variant ?? ""}`;
+    const after = `${current.providerID ?? ""}/${current.modelID}#${current.variant ?? ""}`;
+    if (before !== after)
+      continue;
+    const row = evidence.get(key) ?? {
+      providerID: current.providerID ?? "(unknown)",
+      modelID: current.modelID,
+      samples: 0,
+      maxHitGapMs: undefined,
+      minDropGapMs: undefined
+    };
+    row.samples += 1;
+    const gapMs = stepGap(message(previous), message(current));
+    if (gapMs !== undefined) {
+      const lost = cacheDrop(message(previous), message(current));
+      if (lost === undefined)
+        row.maxHitGapMs = row.maxHitGapMs === undefined ? gapMs : Math.max(row.maxHitGapMs, gapMs);
+      else
+        row.minDropGapMs = row.minDropGapMs === undefined ? gapMs : Math.min(row.minDropGapMs, gapMs);
+    }
+    evidence.set(key, row);
+  }
+  return [...evidence.values()].sort((left, right) => right.samples - left.samples || `${left.providerID}/${left.modelID}`.localeCompare(`${right.providerID}/${right.modelID}`));
+}
+function cacheDropsOf(db, rows, options) {
+  const ttlHint = options?.ttlHintMs ?? DEFAULT_TTL_HINT_MS;
+  const losses = [];
+  for (const { previous, current } of pairsOf(rows)) {
+    const tokens = cacheDrop(message(previous), message(current), "model");
+    if (tokens === undefined)
+      continue;
+    losses.push({ previous, current, tokens, gapMs: stepGap(message(previous), message(current)) });
+  }
+  if (losses.length === 0)
+    return [];
+  const compactions = new Map;
+  const sessionIDs = [...new Set(losses.map((loss) => loss.current.sessionID))];
+  const events = db.query(`SELECT session_id, at FROM events
+        WHERE kind = 'compaction' AND at IS NOT NULL AND session_id IN (${sessionIDs.map(() => "?").join(", ")})
+        ORDER BY at`).all(...sessionIDs);
+  for (const event of events) {
+    const list = compactions.get(event.session_id);
+    if (list !== undefined)
+      list.push(event.at);
+    else
+      compactions.set(event.session_id, [event.at]);
+  }
+  return losses.map((loss) => {
+    const ended = loss.previous.completedAt ?? loss.previous.streamedAt ?? loss.previous.createdAt;
+    const compacted = (compactions.get(loss.current.sessionID) ?? []).some((time) => ended !== undefined && time >= ended && time <= loss.current.at);
+    const reason = compacted ? "compaction" : loss.gapMs !== undefined && loss.gapMs >= ttlHint ? "expired" : "unknown";
+    return {
+      sessionID: loss.current.sessionID,
+      messageID: loss.current.messageID,
+      providerID: loss.current.providerID,
+      modelID: loss.current.modelID,
+      variant: loss.current.variant,
+      at: loss.current.at,
+      tokens: loss.tokens,
+      gapMs: loss.gapMs,
+      prevCached: loss.previous.cached,
+      reason
+    };
+  }).sort((left, right) => left.at - right.at);
+}
+function groupValues(steps) {
+  const wall = [];
+  const tps = [];
+  for (const step of steps) {
+    const timing = timingOf(step);
+    if (timing.wall !== undefined)
+      wall.push(timing.wall);
+    if (timing.tps !== undefined)
+      tps.push(timing.tps);
+  }
+  return { cache: cacheStatsOfSteps(steps), tps: latencyStats(tps).p50, wall: latencyStats(wall).p50 };
+}
+function providerOf(steps, models) {
+  const values = groupValues(steps);
+  const times = steps.map((step) => step.at);
+  return {
+    provider: steps[0].providerID,
+    models: models.split("\x00"),
+    share: 0,
+    usage: usageOf(steps),
+    cache: values.cache,
+    tps: values.tps,
+    wall: values.wall,
+    firstAt: times.length > 0 ? Math.min(...times) : undefined,
+    lastAt: times.length > 0 ? Math.max(...times) : undefined
+  };
+}
+var modelNames = (steps) => [...new Set(steps.map((step) => modelKey(step.modelID ?? "(unknown)", step.variant)))].map((key) => modelLabel(key.slice(0, key.indexOf("#")), key.slice(key.indexOf("#") + 1) || undefined)).join("\x00");
+function providerSummaryOf(rows) {
+  const out = [];
+  for (const steps of groupBy(rows, (step) => step.providerID ?? "").values()) {
+    const summary = providerOf(steps, modelNames(steps));
+    out.push({ ...summary, share: rows.length === 0 ? 0 : steps.length / rows.length });
+  }
+  return out.sort((left, right) => right.usage.steps - left.usage.steps || (left.provider ?? "").localeCompare(right.provider ?? ""));
+}
+function providerBreakdownOf(rows) {
+  const out = [];
+  for (const [model, modelRows] of groupBy(rows, (step) => modelKey(step.modelID ?? "(unknown)", step.variant))) {
+    for (const steps of groupBy(modelRows, (step) => step.providerID ?? "").values()) {
+      const [modelID, variant] = [model.slice(0, model.indexOf("#")), model.slice(model.indexOf("#") + 1)];
+      out.push({
+        ...providerOf(steps, modelNames(steps)),
+        modelID,
+        variant: variant === "" ? undefined : variant,
+        share: steps.length / modelRows.length
+      });
+    }
+  }
+  return out.sort((left, right) => right.usage.steps - left.usage.steps || right.cache.cached - left.cache.cached);
+}
+function isoWeek(date) {
+  const monday = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+  monday.setDate(monday.getDate() - (monday.getDay() + 6) % 7);
+  const thursday = new Date(monday.getFullYear(), monday.getMonth(), monday.getDate() + 3);
+  const firstThursday = new Date(thursday.getFullYear(), 0, 4);
+  firstThursday.setDate(firstThursday.getDate() - (firstThursday.getDay() + 6) % 7 + 3);
+  const week = 1 + Math.round((thursday.getTime() - firstThursday.getTime()) / (7 * 24 * 60 * 60 * 1000));
+  return { year: thursday.getFullYear(), week, monday };
+}
+function periodStart(at, granularity) {
+  const date = new Date(at);
+  const pad = (value) => String(value).padStart(2, "0");
+  if (granularity === "month") {
+    const start = new Date(date.getFullYear(), date.getMonth(), 1);
+    return { key: `${start.getFullYear()}-${pad(start.getMonth() + 1)}`, label: `${start.getFullYear()}-${pad(start.getMonth() + 1)}`, start: start.getTime() };
+  }
+  if (granularity === "week") {
+    const { year, week, monday } = isoWeek(date);
+    return { key: `${year}-W${pad(week)}`, label: `${year}-W${pad(week)}`, start: monday.getTime() };
+  }
+  const start = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+  const key = `${start.getFullYear()}-${pad(start.getMonth() + 1)}-${pad(start.getDate())}`;
+  return { key, label: key, start: start.getTime() };
+}
+function periodsOf(rows, granularity) {
+  const out = [];
+  for (const [key, steps] of groupBy(rows, (step) => periodStart(step.at, granularity).key)) {
+    const period = periodStart(steps[0].at, granularity);
+    out.push({
+      key,
+      label: period.label,
+      at: period.start,
+      steps: steps.length,
+      sessions: new Set(steps.map((step) => step.sessionID)).size,
+      usage: usageOf(steps),
+      cache: cacheStatsOfSteps(steps)
+    });
+  }
+  return out.sort((left, right) => left.at - right.at);
+}
+
+// src/panel-build.ts
+var SORT_KEYS = {
+  models: ["steps", "cached", "hit", "out", "cost"],
+  providers: ["steps", "cached", "hit", "cost", "share", "tps"],
+  latency: ["n", "tps", "wall"],
+  sessions: ["last", "steps", "cached", "cost"],
+  turns: ["time", "cost", "tokens"]
+};
+function sortKeys(view) {
+  return SORT_KEYS[view] ?? [];
+}
+function defaultSort(view) {
+  return sortKeys(view)[0] ?? "";
+}
+function nextSort(view, current, step) {
+  const keys = sortKeys(view);
+  if (keys.length === 0)
+    return current;
+  const index = keys.indexOf(current);
+  if (index === -1)
+    return keys[0];
+  return keys[(index + step + keys.length) % keys.length];
+}
+function detailLabel(row) {
+  switch (row.kind) {
+    case "model":
+      return `model ${row.variant !== undefined ? `${row.value} ${row.variant}` : row.value}`;
+    case "session":
+    case "turn":
+      return `session ${row.value}`;
+    case "period":
+      return `period ${row.value}`;
+    case "provider":
+      return `provider ${row.value}`;
+    case "prune":
+      return `prune older than ${row.value} days`;
+  }
+}
+function buildPanel(request) {
+  try {
+    return build(request);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return [{ text: `stats query failed: ${message}`, tone: "warning" }];
+  }
+}
+function build(request) {
+  const { db, view, now, sessionStart, width } = request;
+  const scoped = request.range === "session" && request.sessionID !== "";
+  const range = scoped ? undefined : request.range === "session" ? sessionStart === undefined ? undefined : { from: sessionStart } : rangeForRequest(request.range, now);
+  const filters = scoped ? { ...request.filters, sessionID: request.sessionID } : request.filters;
+  if (request.detail !== undefined)
+    return buildDetail(request, range, filters);
+  switch (view) {
+    case "overview": {
+      const usage = overview(db, range, filters);
+      const sessionUsage = request.sessionID === "" ? undefined : overview(db, undefined, { ...request.filters, sessionID: request.sessionID });
+      const childIDs = request.sessionID === "" ? [] : childSessionIDs(db, request.sessionID);
+      const children = childIDs.length === 0 ? [] : sessionUsageOf(db, childIDs);
+      return overviewLines({
+        usage,
+        session: sessionUsage,
+        ...children.length > 0 ? { subagents: children } : {},
+        range: request.range,
+        activity: activityOf(db, range, now),
+        coverage: coverageOf(db, { range, filters })
+      }, width);
+    }
+    case "models": {
+      const rows = sortModels(models(db, range, filters), request.sort, request.sortDesc);
+      const pairs = cachePairs(db, { range, filters });
+      const switches = switchesOf(pairs);
+      return modelsLines(rows, width, {
+        cache: cacheByModel(pairs),
+        switches: switchesByModel(switches.rows)
+      }, 40);
+    }
+    case "providers":
+      return providerSummaryLines(sortProviders(providerSummaryOf(stepRows(db, { range, filters })), request.sort, request.sortDesc), width, 40);
+    case "cache": {
+      const pairs = cachePairs(db, { range, filters });
+      return cacheLines({
+        drops: cacheDropsOf(db, pairs),
+        evidence: ttlEvidenceOf(pairs),
+        gap: gapReportOf(pairs),
+        models: topCacheModels(pairs)
+      }, width);
+    }
+    case "periods":
+      return periodLines(periodsOf(stepRows(db, { range, filters }), request.granularity), width, request.granularity, 40);
+    case "latency": {
+      const timings = timingRows(db, { range, filters });
+      const by = filters.modelID !== undefined ? "provider" : "model";
+      return latencyLines(latencyOf(timings), width, sortLatency(latencyGroupsOf(timings, by), request.sort, request.sortDesc), 14);
+    }
+    case "sessions": {
+      const rows = sortSessions(sessions(db, { range, filters, limit: 200 }), request.sort, request.sortDesc);
+      const child = rows.filter((row) => row.parentID !== undefined && rows.some((parent) => parent.sessionID === row.parentID));
+      return sessionsLines(rows, width, {
+        limit: 20,
+        rollup: { subagentSteps: child.reduce((sum, row) => sum + row.steps, 0), subagentCost: child.reduce((sum, row) => sum + row.cost, 0) }
+      });
+    }
+    case "db":
+      return request.database === undefined ? [{ text: "the database location is unavailable to this panel", tone: "warning" }] : dbLines({ info: request.database, busy: request.busy, now }, width);
+    case "turns": {
+      const sessionID = request.turnsScope === "session" ? request.sessionID : undefined;
+      const rows = sortTurns(turns(db, { sessionID, range, filters, limit: 300 }), request.sort, request.sortDesc);
+      const titles = request.turnsScope === "all" ? new Map(sessions(db, { range, filters, limit: 200 }).map((row) => [row.sessionID, row.title ?? row.sessionID])) : undefined;
+      return turnsLines(rows.slice(0, 60), width, { ...request.format, sessionTitles: titles });
+    }
+  }
+}
+function rangeForRequest(key, now) {
+  switch (key) {
+    case "today": {
+      const start = new Date(now);
+      start.setHours(0, 0, 0, 0);
+      return { from: start.getTime() };
+    }
+    case "7d":
+      return { from: now - 7 * 24 * 60 * 60 * 1000 };
+    case "30d":
+      return { from: now - 30 * 24 * 60 * 60 * 1000 };
+    default:
+      return;
+  }
+}
+function buildDetail(request, range, filters) {
+  const row = request.detail;
+  const db = request.db;
+  const width = request.width;
+  const head = { text: detailLabel(row), tone: "accent" };
+  const back = { text: "backspace returns \xB7 the header shows where you came from", tone: "muted" };
+  if (row.kind === "model") {
+    const scoped = { ...filters, modelKey: modelKey(row.value, row.variant) };
+    const stats = cacheStatsOf(db, { range, filters: scoped });
+    const steps = stepRows(db, { range, filters: scoped });
+    return [
+      head,
+      {
+        text: `steps ${stats.steps} \xB7 in ${formatTokens(stats.prompt - stats.cached)} \xB7 prompt ${formatTokens(stats.prompt)} \xB7 cached ${formatTokens(stats.cached)} \xB7 write ${formatTokens(stats.cacheWrite)} \xB7 hit ${percent(stats.hit)} \xB7 p50 ${percent(stats.hitP50)}`,
+        tone: "muted"
+      },
+      { text: "", tone: "muted" },
+      ...providerLines(providerBreakdownOf(steps), width, 40),
+      { text: "", tone: "muted" },
+      ...latencyLines(latencyOf(steps), width, latencyGroupsOf(steps, "provider"), 14),
+      { text: "", tone: "muted" },
+      back
+    ];
+  }
+  if (row.kind === "session" || row.kind === "turn") {
+    const rows = turns(db, { sessionID: row.value, limit: 80 });
+    return [head, { text: "", tone: "muted" }, ...turnsLines(rows, width, request.format), { text: "", tone: "muted" }, back];
+  }
+  if (row.kind === "provider") {
+    const scoped = { ...filters, provider: row.value };
+    const steps = stepRows(db, { range, filters: scoped });
+    const stats = cacheStatsOf(db, { range, filters: scoped });
+    return [
+      head,
+      {
+        text: `steps ${stats.steps} \xB7 in ${formatTokens(stats.prompt - stats.cached)} \xB7 prompt ${formatTokens(stats.prompt)} \xB7 cached ${formatTokens(stats.cached)} \xB7 hit ${percent(stats.hit)} \xB7 p50 ${percent(stats.hitP50)}`,
+        tone: "muted"
+      },
+      { text: "", tone: "muted" },
+      ...providerLines(providerBreakdownOf(steps), width, 40),
+      { text: "", tone: "muted" },
+      ...latencyLines(latencyOf(steps), width, latencyGroupsOf(steps, "model"), 14),
+      { text: "", tone: "muted" },
+      back
+    ];
+  }
+  if (row.kind === "period") {
+    const periods = periodsOf(stepRows(db, { range, filters }), request.granularity);
+    const period = periods.find((entry) => entry.key === row.value);
+    return [
+      head,
+      { text: `${formatCount(period?.steps ?? 0)} steps`, tone: "muted" },
+      { text: "", tone: "muted" },
+      ...providerSummaryLines(providerSummaryOf(stepRows(db, { range, filters })), width, 40),
+      { text: "", tone: "muted" },
+      back
+    ];
+  }
+  return [head, back];
+}
+function percent(value) {
+  return value === undefined ? "\u2013" : `${(value * 100).toFixed(1)}%`;
+}
+function sortModels(rows, sort, desc) {
+  const sign = desc ? -1 : 1;
+  const pick = (model) => {
+    if (sort === "cached")
+      return model.totals.cached;
+    if (sort === "out")
+      return model.totals.output;
+    if (sort === "cost")
+      return model.totals.cost;
+    return model.totals.steps;
+  };
+  return [...rows].sort((left, right) => sign * (pick(right) - pick(left)));
+}
+function sortProviders(rows, sort, desc) {
+  const sign = desc ? -1 : 1;
+  const pick = (row) => {
+    if (sort === "cached")
+      return row.cache.cached;
+    if (sort === "hit")
+      return row.cache.hit ?? -1;
+    if (sort === "cost")
+      return row.usage.cost;
+    if (sort === "share")
+      return row.share;
+    if (sort === "tps")
+      return row.tps ?? -1;
+    return row.usage.steps;
+  };
+  return [...rows].sort((left, right) => sign * (pick(right) - pick(left)));
+}
+function sortLatency(rows, sort, desc) {
+  const sign = desc ? -1 : 1;
+  const pick = (row) => {
+    if (sort === "tps")
+      return row.tps.p50 ?? -1;
+    if (sort === "wall")
+      return row.wall.p50 ?? -1;
+    return row.count;
+  };
+  return [...rows].sort((left, right) => sign * (pick(right) - pick(left)));
+}
+function sortSessions(rows, sort, desc) {
+  const sign = desc ? -1 : 1;
+  const pick = (row) => {
+    if (sort === "steps")
+      return row.steps;
+    if (sort === "cached")
+      return row.cached;
+    if (sort === "cost")
+      return row.cost;
+    return row.lastAt ?? 0;
+  };
+  return [...rows].sort((left, right) => sign * (pick(right) - pick(left)));
+}
+function sortTurns(rows, sort, desc) {
+  const sign = desc ? -1 : 1;
+  const pick = (row) => {
+    if (sort === "cost")
+      return row.totals.cost;
+    if (sort === "tokens")
+      return row.totals.cached + row.totals.input + row.totals.output;
+    return row.endAt ?? 0;
+  };
+  return [...rows].sort((left, right) => sign * (pick(right) - pick(left)));
+}
+function cacheByModel(pairs) {
+  const map = new Map;
+  for (const row of cacheStatsByModel(pairs)) {
+    map.set(modelKey(row.modelID, row.variant), row.cache);
+  }
+  return map;
+}
+function switchesByModel(rows) {
+  return new Map(rows.map((row) => [modelKey(row.modelID, row.variant), row]));
+}
+function topCacheModels(pairs) {
+  return cacheStatsByModel(pairs).slice(0, 10).map((row) => ({ usage: { modelID: row.modelID, variant: row.variant }, cache: row.cache }));
+}
+function activityOf(db, range, now) {
+  const earliest = db.query(`SELECT MIN(${STEP_TIME}) AS at FROM steps`).get();
+  const from = range?.from ?? earliest?.at ?? 0;
+  const to = range?.to ?? now;
+  const span = Math.max(1, to - from);
+  const ladder = [3600000, 3 * 3600000, 6 * 3600000, 12 * 3600000, 86400000, 3 * 86400000, 7 * 86400000, 30 * 86400000];
+  const bucket = ladder.find((size) => span / size <= 48) ?? ladder[ladder.length - 1];
+  const rows = db.query(`SELECT CAST(COALESCE(created_at, recorded_at) / ? AS INTEGER) AS bucket, COUNT(*) AS steps
+         FROM steps
+        WHERE COALESCE(created_at, recorded_at) >= ?
+        GROUP BY bucket ORDER BY bucket`).all(bucket, from);
+  if (rows.length === 0)
+    return [];
+  const first = Math.floor(from / bucket);
+  const last = rows[rows.length - 1].bucket;
+  const series = [];
+  for (let index = first;index <= last; index += 1) {
+    series.push(rows.find((row) => row.bucket === index)?.steps ?? 0);
+  }
+  return series;
+}
+
+// src/stats/maintenance.ts
+import { statSync as statSync2 } from "fs";
+
+// src/stats/db.ts
+import { Database } from "bun:sqlite";
+import { chmodSync, mkdirSync } from "fs";
+import { dirname } from "path";
+
+// src/stats/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+import { statSync } from "fs";
+function defaultDbPath(env = process.env, platform = process.platform) {
+  const name = join("opencode", "opencode-usage-insights", "usage.db");
+  if (platform === "win32") {
+    return join(env.LOCALAPPDATA ?? join(homedir(), "AppData", "Local"), name);
+  }
+  if (platform === "darwin") {
+    return join(homedir(), "Library", "Application Support", name);
+  }
+  return join(env.XDG_STATE_HOME ?? join(homedir(), ".local", "state"), name);
+}
+function expandHome(path, home = homedir()) {
+  if (path === "~")
+    return home;
+  if (path.startsWith("~/") || path.startsWith("~\\"))
+    return join(home, path.slice(2));
+  return path;
+}
+function resolveDbPath(configured, env = process.env, platform = process.platform) {
+  const home = env.HOME ?? env.USERPROFILE ?? homedir();
+  if (configured)
+    return expandHome(configured, home);
+  if (env.OPENCODE_USAGE_INSIGHTS_DB)
+    return expandHome(env.OPENCODE_USAGE_INSIGHTS_DB, home);
+  return defaultDbPath(env, platform);
+}
+function ensureRegularFile(path) {
+  let stats;
+  try {
+    stats = statSync(path);
+  } catch {
+    return;
+  }
+  if (!stats.isFile())
+    throw new Error(`not a regular file: ${path}`);
+}
+
+// src/stats/db.ts
+var SCHEMA_VERSION = 9;
+var LABEL_LIMIT = 4 * TEXT_LIMIT;
+var SCHEMA = `
+CREATE TABLE IF NOT EXISTS meta (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS sessions (
+  session_id TEXT PRIMARY KEY,
+  parent_id TEXT,
+  directory TEXT,
+  title TEXT,
+  started_at INTEGER,
+  updated_at INTEGER
+);
+
+CREATE TABLE IF NOT EXISTS prompts (
+  session_id TEXT NOT NULL,
+  message_id TEXT NOT NULL,
+  created_at INTEGER,
+  PRIMARY KEY (session_id, message_id)
+);
+CREATE INDEX IF NOT EXISTS prompts_created ON prompts(created_at);
+
+CREATE TABLE IF NOT EXISTS steps (
+  message_id TEXT PRIMARY KEY,
+  session_id TEXT NOT NULL,
+  parent_id TEXT,
+  provider_id TEXT,
+  model_id TEXT,
+  variant TEXT,
+  input_tokens INTEGER NOT NULL DEFAULT 0,
+  output_tokens INTEGER NOT NULL DEFAULT 0,
+  reasoning_tokens INTEGER NOT NULL DEFAULT 0,
+  cache_read INTEGER NOT NULL DEFAULT 0,
+  cache_write INTEGER NOT NULL DEFAULT 0,
+  cost REAL NOT NULL DEFAULT 0,
+  created_at INTEGER,
+  streamed_at INTEGER,
+  completed_at INTEGER,
+  finish TEXT,
+  recorded_at INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS steps_session ON steps(session_id, created_at);
+CREATE INDEX IF NOT EXISTS steps_model ON steps(provider_id, model_id, variant);
+CREATE INDEX IF NOT EXISTS steps_completed ON steps(completed_at);
+-- Every range filter and every ordering compares the step's own clock, which
+-- falls back to the recording time for a step that was already in flight when
+-- the plugin loaded. The index has to cover that expression, or every ranged
+-- view is a full table scan.
+CREATE INDEX IF NOT EXISTS steps_at ON steps(COALESCE(created_at, recorded_at));
+CREATE INDEX IF NOT EXISTS steps_session_at ON steps(session_id, COALESCE(created_at, recorded_at));
+
+CREATE TABLE IF NOT EXISTS events (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  message_id TEXT,
+  at INTEGER,
+  data TEXT
+);
+CREATE INDEX IF NOT EXISTS events_session ON events(session_id, at);
+CREATE INDEX IF NOT EXISTS events_kind ON events(kind, at);
+`;
+var TABLES = ["sessions", "prompts", "events", "steps"];
+function jsonText(value) {
+  if (value === undefined || value === null)
+    return null;
+  if (typeof value === "string")
+    return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return null;
+  }
+}
+var REMOVED_COLUMNS = ["provider_state", "upstream", "upstream_source", "upstream_model", "tps", "router"];
+var REMOVED_EVENT_KINDS = ["execution", "step-failed", "model-selected", "usage-recorded"];
+function dropUnused(db) {
+  const objects = db.query("SELECT name, type FROM sqlite_master WHERE type IN ('table', 'index')").all();
+  const tables = new Set(objects.filter((row) => row.type === "table").map((row) => row.name));
+  const indexes = new Set(objects.filter((row) => row.type === "index").map((row) => row.name));
+  if (tables.has("http_responses"))
+    db.exec("DROP TABLE http_responses");
+  if (indexes.has("steps_upstream"))
+    db.exec("DROP INDEX steps_upstream");
+  if (indexes.has("steps_router"))
+    db.exec("DROP INDEX steps_router");
+  const columns = new Set(db.query("PRAGMA table_info(steps)").all().map((column) => column.name));
+  for (const name of REMOVED_COLUMNS) {
+    if (columns.has(name))
+      db.exec(`ALTER TABLE steps DROP COLUMN ${name}`);
+  }
+  if (tables.has("events")) {
+    const kinds = REMOVED_EVENT_KINDS.map((kind) => `'${kind}'`).join(", ");
+    db.exec(`DELETE FROM events WHERE kind IN (${kinds})`);
+  }
+}
+function migrate(db) {
+  dropUnused(db);
+}
+var POSIX = process.platform !== "win32";
+function hardenDirectory(path) {
+  if (!POSIX)
+    return;
+  try {
+    chmodSync(path, 448);
+  } catch {}
+}
+function hardenFiles(path) {
+  if (!POSIX || path === ":memory:")
+    return;
+  for (const file of [path, `${path}-wal`, `${path}-shm`]) {
+    try {
+      chmodSync(file, 384);
+    } catch {}
+  }
+}
+function prepareDirectory(path) {
+  if (path === ":memory:")
+    return;
+  mkdirSync(dirname(path), { recursive: true, mode: 448 });
+  hardenDirectory(dirname(path));
+}
+function openStatsDb(path) {
+  if (path !== ":memory:")
+    ensureRegularFile(path);
+  prepareDirectory(path);
+  const db = new Database(path, { create: true });
+  db.exec("PRAGMA journal_mode = WAL");
+  db.exec("PRAGMA busy_timeout = 5000");
+  db.exec("PRAGMA synchronous = NORMAL");
+  db.exec(SCHEMA);
+  migrate(db);
+  db.query("INSERT INTO meta (key, value) VALUES ('schema_version', ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(String(SCHEMA_VERSION));
+  hardenFiles(path);
+  return db;
+}
+function openStatsDbReadOnly(path) {
+  ensureRegularFile(path);
+  const db = new Database(path, { readonly: true });
+  try {
+    db.query("SELECT 1 FROM steps LIMIT 1").get();
+  } catch (error) {
+    db.close();
+    throw error;
+  }
+  return db;
+}
+function openStatsDbWrite(path) {
+  if (path !== ":memory:")
+    ensureRegularFile(path);
+  prepareDirectory(path);
+  const db = new Database(path, { create: true });
+  db.exec("PRAGMA busy_timeout = 250");
+  db.exec("PRAGMA synchronous = NORMAL");
+  hardenFiles(path);
+  return db;
+}
+function recordStep(db, record) {
+  db.query(`INSERT INTO steps (
+       message_id, session_id, parent_id, provider_id, model_id, variant,
+       input_tokens, output_tokens, reasoning_tokens, cache_read, cache_write, cost,
+       created_at, streamed_at, completed_at, finish, recorded_at
+     ) VALUES (
+       $messageID, $sessionID, $parentID, $providerID, $modelID, $variant,
+       $input, $output, $reasoning, $cacheRead, $cacheWrite, $cost,
+       $createdAt, $streamedAt, $completedAt, $finish, $recordedAt
+     )
+     ON CONFLICT(message_id) DO UPDATE SET
+       session_id = excluded.session_id,
+       parent_id = COALESCE(excluded.parent_id, steps.parent_id),
+       provider_id = COALESCE(excluded.provider_id, steps.provider_id),
+       model_id = COALESCE(excluded.model_id, steps.model_id),
+       variant = COALESCE(excluded.variant, steps.variant),
+       input_tokens = excluded.input_tokens,
+       output_tokens = excluded.output_tokens,
+       reasoning_tokens = excluded.reasoning_tokens,
+       cache_read = excluded.cache_read,
+       cache_write = excluded.cache_write,
+       cost = excluded.cost,
+       created_at = COALESCE(excluded.created_at, steps.created_at),
+       streamed_at = COALESCE(excluded.streamed_at, steps.streamed_at),
+       completed_at = COALESCE(excluded.completed_at, steps.completed_at),
+       finish = COALESCE(excluded.finish, steps.finish),
+       recorded_at = excluded.recorded_at`).run({
+    $messageID: record.messageID,
+    $sessionID: record.sessionID,
+    $parentID: record.parentID ?? null,
+    $providerID: record.providerID !== undefined && isToken(record.providerID) ? record.providerID : null,
+    $modelID: record.modelID ?? null,
+    $variant: record.variant ?? null,
+    $input: record.input ?? 0,
+    $output: record.output ?? 0,
+    $reasoning: record.reasoning ?? 0,
+    $cacheRead: record.cacheRead ?? 0,
+    $cacheWrite: record.cacheWrite ?? 0,
+    $cost: record.cost ?? 0,
+    $createdAt: record.createdAt ?? null,
+    $streamedAt: record.streamedAt ?? null,
+    $completedAt: record.completedAt ?? null,
+    $finish: record.finish === undefined ? null : sanitizeLabel(record.finish, 64),
+    $recordedAt: record.recordedAt ?? Date.now()
+  });
+}
+function recordPrompt(db, record) {
+  db.query(`INSERT INTO prompts (session_id, message_id, created_at)
+     VALUES ($sessionID, $messageID, $createdAt)
+     ON CONFLICT(session_id, message_id) DO UPDATE SET created_at = COALESCE(excluded.created_at, prompts.created_at)`).run({
+    $sessionID: record.sessionID,
+    $messageID: record.messageID,
+    $createdAt: record.createdAt ?? null
+  });
+}
+function recordEvent(db, record) {
+  db.query(`INSERT INTO events (session_id, kind, message_id, at, data)
+     VALUES ($sessionID, $kind, $messageID, $at, $data)`).run({
+    $sessionID: record.sessionID,
+    $kind: sanitizeLabel(record.kind, 64),
+    $messageID: record.messageID ?? null,
+    $at: record.at ?? Date.now(),
+    $data: jsonText(record.data)
+  });
+}
+function upsertSession(db, record) {
+  db.query(`INSERT INTO sessions (session_id, parent_id, directory, title, started_at, updated_at)
+     VALUES ($sessionID, $parentID, $directory, $title, $startedAt, $updatedAt)
+     ON CONFLICT(session_id) DO UPDATE SET
+       parent_id = COALESCE(excluded.parent_id, sessions.parent_id),
+       directory = COALESCE(excluded.directory, sessions.directory),
+       title = COALESCE(excluded.title, sessions.title),
+       started_at = COALESCE(sessions.started_at, excluded.started_at),
+       updated_at = COALESCE(excluded.updated_at, sessions.updated_at)`).run({
+    $sessionID: record.sessionID,
+    $parentID: record.parentID ?? null,
+    $directory: record.directory === undefined ? null : sanitizeLabel(record.directory, LABEL_LIMIT),
+    $title: record.title === undefined ? null : sanitizeLabel(record.title, LABEL_LIMIT),
+    $startedAt: record.startedAt ?? null,
+    $updatedAt: record.updatedAt ?? null
+  });
+}
+
+// src/stats/maintenance.ts
+var STEP_TIME2 = "COALESCE(created_at, recorded_at)";
+var DAY = 24 * 60 * 60 * 1000;
+function size(path) {
+  try {
+    return statSync2(path).size;
+  } catch {
+    return 0;
+  }
+}
+function dbInfo(db, path, now = Date.now()) {
+  const tables = TABLES.map((table) => ({
+    name: table,
+    rows: db.query(`SELECT COUNT(*) AS n FROM ${table}`).get().n
+  }));
+  const window = db.query(`SELECT MIN(${STEP_TIME2}) AS first, MAX(${STEP_TIME2}) AS last FROM steps`).get();
+  const version = db.query("SELECT value FROM meta WHERE key = 'schema_version'").get();
+  return {
+    path,
+    bytes: size(path),
+    walBytes: path === ":memory:" ? undefined : size(`${path}-wal`) || undefined,
+    schemaVersion: version === null ? 0 : Number.parseInt(version.value, 10),
+    tables,
+    firstAt: window.first ?? undefined,
+    lastAt: window.last ?? undefined,
+    removable: [30, 90, 365].map((days) => ({
+      days,
+      steps: db.query(`SELECT COUNT(*) AS n FROM steps WHERE ${STEP_TIME2} < ?`).get(now - days * DAY).n
+    }))
+  };
+}
+var PRUNE_BATCH = 5000;
+function deleteBatched(db, table, where, cutoff) {
+  const statement = db.query(`DELETE FROM ${table} WHERE rowid IN (SELECT rowid FROM ${table} WHERE ${where} LIMIT ${PRUNE_BATCH})`);
+  let removed = 0;
+  for (;; ) {
+    const changes = statement.run(cutoff).changes;
+    removed += changes;
+    if (changes < PRUNE_BATCH)
+      break;
+  }
+  return removed;
+}
+function pruneOlderThan(db, cutoff) {
+  return {
+    steps: deleteBatched(db, "steps", `${STEP_TIME2} < ?`, cutoff),
+    prompts: deleteBatched(db, "prompts", "created_at IS NOT NULL AND created_at < ?", cutoff),
+    events: deleteBatched(db, "events", "at IS NOT NULL AND at < ?", cutoff)
+  };
+}
+function footprint(path) {
+  return size(path) + size(`${path}-wal`);
+}
+function vacuum(db, path) {
+  const before = footprint(path);
+  db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+  db.exec("VACUUM");
+  const after = footprint(path);
+  return { before, after, freed: Math.max(0, before - after) };
+}
+
+// src/panel.tsx
+function Panel(props) {
+  const [anchor, setAnchor] = createSignal(undefined);
+  const [detail, setDetail] = createSignal(undefined);
+  const [help, setHelp] = createSignal(false);
+  const [tick, setTick] = createSignal(0);
+  const [busy, setBusy] = createSignal(false);
+  let scroller;
+  const width = () => Math.max(60, props.input.width - 4);
+  const view = () => sanitizeSettings(props.settings).view;
+  const settings = () => sanitizeSettings(props.settings);
+  const filters = () => {
+    const current = settings();
+    return {
+      ...current.modelID !== "" ? {
+        modelID: current.modelID
+      } : {},
+      ...current.providerID !== "" ? {
+        provider: current.providerID
+      } : {}
+    };
+  };
+  const rowKey = (row) => `${row.kind}:${row.value}${row.variant !== undefined ? `#${row.variant}` : ""}`;
+  const database = createMemo(() => {
+    tick();
+    const handle = props.deps.db();
+    if (handle === undefined)
+      return;
+    try {
+      return dbInfo(handle, props.deps.dbPath(), props.deps.now());
+    } catch {
+      return;
+    }
+  });
+  const content = createMemo(() => {
+    tick();
+    props.deps.refresh?.();
+    const current = settings();
+    if (help())
+      return helpLines(width());
+    const db = props.deps.db();
+    if (db === undefined) {
+      return [{
+        text: `stats database is not readable at ${props.deps.dbPath()}; enable the usage-insights server plugin in opencode.json`,
+        tone: "warning"
+      }];
+    }
+    const info = current.view === "db" ? database() : undefined;
+    const request = {
+      db,
+      view: current.view,
+      range: current.range,
+      filters: filters(),
+      granularity: current.granularity,
+      turnsScope: current.turnsScope,
+      sort: current.sort,
+      sortDesc: current.sortDesc,
+      sessionID: props.input.sessionID,
+      sessionStart: props.deps.sessionStart(props.input.sessionID),
+      now: props.deps.now(),
+      format: props.format,
+      ...detail() !== undefined ? {
+        detail: detail()
+      } : {},
+      ...info !== undefined ? {
+        database: info
+      } : {},
+      busy: busy(),
+      width: width()
+    };
+    return buildPanel(request);
+  });
+  const header = createMemo(() => {
+    const current = settings();
+    const filters = filterSummary(current);
+    const where = detail() !== undefined ? " \xB7 backspace returns" : filters === undefined ? "" : ` \xB7 ${filters}`;
+    return [{
+      text: `usage insights \xB7 ${rangeLabel(current.range)}${where}`,
+      tone: "accent"
+    }, viewBar(current.view, width()), {
+      text: "",
+      tone: "muted"
+    }];
+  });
+  const selectable = createMemo(() => {
+    const list = [];
+    const lines = content();
+    for (let index = 0;index < lines.length; index += 1) {
+      const row = lines[index].row;
+      if (row !== undefined)
+        list.push({
+          key: rowKey(row),
+          index,
+          row
+        });
+    }
+    return list;
+  });
+  const cursor = createMemo(() => {
+    const list = selectable();
+    if (list.length === 0)
+      return -1;
+    const key = anchor();
+    const found = key === undefined ? -1 : list.findIndex((entry) => entry.key === key);
+    return found === -1 ? 0 : found;
+  });
+  createRenderEffect(() => {
+    const list = selectable();
+    const index = cursor();
+    if (index < 0)
+      return;
+    const entry = list[index];
+    if (entry === undefined)
+      return;
+    scroller?.scrollChildIntoView?.(`line-${entry.index}`);
+  });
+  function move(delta) {
+    const list = selectable();
+    if (list.length === 0)
+      return;
+    const next = Math.min(list.length - 1, Math.max(0, cursor() + delta));
+    setAnchor(list[next].key);
+  }
+  function moveEdge(toEnd) {
+    const list = selectable();
+    if (list.length === 0)
+      return;
+    setAnchor(list[toEnd ? list.length - 1 : 0].key);
+  }
+  function drill() {
+    const entry = selectable()[cursor()];
+    if (entry === undefined)
+      return;
+    if (entry.row.kind === "prune") {
+      prune(Number.parseInt(entry.row.value, 10));
+      return;
+    }
+    setDetail(entry.row);
+    setAnchor(undefined);
+  }
+  function sessionRunning() {
+    try {
+      return props.ctx.data.session.status(props.input.sessionID) === "running";
+    } catch {
+      return false;
+    }
+  }
+  async function prune(days) {
+    if (!Number.isFinite(days))
+      return;
+    if (sessionRunning()) {
+      props.ctx.ui.toast.show({
+        message: "the session is running: prune again when it is idle",
+        variant: "warning"
+      });
+      return;
+    }
+    const info = database();
+    const steps = info?.removable.find((option) => option.days === days)?.steps;
+    const confirmed = await props.ctx.ui.dialog.confirm({
+      title: `Prune older than ${days} days`,
+      message: `${steps === undefined ? "The recorded usage" : `${steps} of ${formatCount(info?.tables.find((table) => table.name === "steps")?.rows ?? 0)} steps`} would be deleted. This cannot be undone.`,
+      label: {
+        confirm: "Prune",
+        cancel: "Keep"
+      }
+    });
+    if (confirmed !== true)
+      return;
+    const cutoff = props.deps.now() - days * 24 * 60 * 60 * 1000;
+    const result = props.deps.withWrite?.((handle) => pruneOlderThan(handle, cutoff));
+    if (result === undefined) {
+      props.ctx.ui.toast.show({
+        message: "the recorder is writing: try again in a moment",
+        variant: "warning"
+      });
+    } else {
+      props.ctx.ui.toast.show({
+        message: `pruned ${result.steps} steps \xB7 ${result.prompts} prompts \xB7 ${result.events} compactions`,
+        variant: "success"
+      });
+    }
+    setAnchor(undefined);
+    setTick((value) => value + 1);
+  }
+  async function compact() {
+    if (sessionRunning()) {
+      props.ctx.ui.toast.show({
+        message: "the session is running: compact again when it is idle",
+        variant: "warning"
+      });
+      return;
+    }
+    const confirmed = await props.ctx.ui.dialog.confirm({
+      title: "Compact the database",
+      message: "SQLite rewrites the file to reclaim the space of deleted rows. It needs the recorder to be idle, and it can take a moment.",
+      label: {
+        confirm: "Compact",
+        cancel: "Cancel"
+      }
+    });
+    if (confirmed !== true)
+      return;
+    const path = props.deps.dbPath();
+    let result;
+    try {
+      result = props.deps.withWrite?.((handle) => vacuum(handle, path));
+    } catch {
+      result = undefined;
+    }
+    if (result === undefined) {
+      setBusy(true);
+      props.ctx.ui.toast.show({
+        message: "the recorder is writing: try again in a moment",
+        variant: "warning"
+      });
+    } else {
+      setBusy(false);
+      props.ctx.ui.toast.show({
+        message: `compacted: ${(result.freed / 1048576).toFixed(1)} MB back`,
+        variant: "success"
+      });
+    }
+    setTick((value) => value + 1);
+  }
+  function back() {
+    if (detail() === undefined)
+      return;
+    setDetail(undefined);
+    setAnchor(undefined);
+  }
+  async function pickFilter(kind) {
+    const db = props.deps.db();
+    if (db === undefined)
+      return;
+    const all = filterOptions(db);
+    const list = kind === "model" ? all.models : all.providers;
+    const current = settings();
+    const selected = kind === "model" ? current.modelID : current.providerID;
+    const value = await props.ctx.ui.dialog.select({
+      title: kind === "model" ? "Filter by model" : "Filter by provider",
+      current: selected,
+      options: [{
+        title: `any \xB7 ${list.length} observed`,
+        value: ""
+      }, ...list.map((entry) => ({
+        title: entry.value,
+        value: entry.value,
+        description: `${entry.steps} steps`,
+        category: kind
+      }))]
+    });
+    if (value === undefined)
+      return;
+    props.update((draft) => {
+      if (kind === "model")
+        draft.modelID = value;
+      else
+        draft.providerID = value;
+    });
+    setAnchor(undefined);
+    setDetail(undefined);
+  }
+  const command = (id, title, bind, run) => ({
+    id,
+    title,
+    bind,
+    run
+  });
+  props.ctx.keymap.layer(() => {
+    return {
+      commands: [command("usage-insights.cursor.up", "Move up", "up", () => move(-1)), command("usage-insights.cursor.down", "Move down", "down", () => move(1)), command("usage-insights.cursor.up.alt", "Move up", "k", () => move(-1)), command("usage-insights.cursor.down.alt", "Move down", "j", () => move(1)), command("usage-insights.page.up", "Page up", "pageup", () => move(-10)), command("usage-insights.page.down", "Page down", "pagedown", () => move(10)), command("usage-insights.first", "First row", "home", () => moveEdge(false)), command("usage-insights.last", "Last row", "end", () => moveEdge(true)), command("usage-insights.drill", "Open the selected row", "return", () => drill()), command("usage-insights.back", "Go back", "backspace", () => back()), command("usage-insights.view.next", "Next view", "]", () => {
+        setHelp(false);
+        props.update((draft) => {
+          draft.view = nextIn(PANEL_VIEWS, sanitizeSettings(draft).view, 1);
+        });
+      }), command("usage-insights.view.previous", "Previous view", "[", () => {
+        setHelp(false);
+        props.update((draft) => {
+          draft.view = nextIn(PANEL_VIEWS, sanitizeSettings(draft).view, -1);
+        });
+      }), command("usage-insights.range.next", "Next range", "t", () => props.update((draft) => {
+        draft.range = nextIn(RANGE_KEYS, sanitizeSettings(draft).range, 1);
+      })), command("usage-insights.range.previous", "Previous range", "shift+t", () => props.update((draft) => {
+        draft.range = nextIn(RANGE_KEYS, sanitizeSettings(draft).range, -1);
+      })), command("usage-insights.sort.cycle", "Cycle sort column", "s", () => props.update((draft) => {
+        const state = sanitizeSettings(draft);
+        draft.sort = nextSort(state.view, state.sort === "" ? defaultSort(state.view) : state.sort, 1);
+      })), command("usage-insights.sort.reverse", "Reverse sort", "shift+s", () => props.update((draft) => {
+        draft.sortDesc = !sanitizeSettings(draft).sortDesc;
+      })), command("usage-insights.bucket", "Next period bucket", "b", () => props.update((draft) => {
+        draft.granularity = nextIn(GRANULARITIES, sanitizeSettings(draft).granularity, 1);
+        draft.view = "periods";
+      })), command("usage-insights.scope", "Toggle the turns scope", "a", () => props.update((draft) => {
+        draft.turnsScope = sanitizeSettings(draft).turnsScope === "session" ? "all" : "session";
+        draft.view = "turns";
+      })), command("usage-insights.filter.model", "Filter by model", "m", () => void pickFilter("model")), command("usage-insights.filter.provider", "Filter by provider", "p", () => void pickFilter("provider")), command("usage-insights.filter.clear", "Clear filters", "x", () => {
+        props.update((draft) => {
+          draft.modelID = "";
+          draft.providerID = "";
+        });
+        setAnchor(undefined);
+      }), command("usage-insights.refresh", "Refresh", "r", () => setTick((value) => value + 1)), command("usage-insights.vacuum", "Compact the database", "v", () => void compact()), command("usage-insights.help", "Help", "?", () => setHelp((open) => !open)), command("usage-insights.fullscreen", "Toggle full screen", "f", () => props.input.toggleFullscreen()), command("usage-insights.close", "Close usage panel", "escape", () => props.input.close()), ...PANEL_VIEWS.map((name, index) => command(`usage-insights.view.${name}`, `View ${name}`, String((index + 1) % 10), () => {
+        setHelp(false);
+        props.update((draft) => {
+          draft.view = name;
+        });
+      }))]
+    };
+  });
+  const color = (tone) => {
+    switch (tone) {
+      case "muted":
+        return props.ctx.theme.text.muted;
+      case "warning":
+        return props.ctx.theme.text.feedback.warning.base;
+      case "accent":
+        return props.ctx.theme.text.feedback.info.base;
+      default:
+        return props.ctx.theme.text.base;
+    }
+  };
+  const selectedBackground = () => props.ctx.theme.background.raised.high;
+  const cursorIndex = () => cursor();
+  return (() => {
+    var _el$ = _$createElement("box"), _el$2 = _$createElement("scrollbox"), _el$3 = _$createElement("text"), _el$4 = _$createElement("text");
+    _$insertNode(_el$, _el$2);
+    _$setProp(_el$, "flexDirection", "column");
+    _$setProp(_el$, "paddingLeft", 1);
+    _$setProp(_el$, "paddingRight", 1);
+    _$insertNode(_el$2, _el$3);
+    _$insertNode(_el$2, _el$4);
+    _$use((target) => {
+      scroller = target;
+      const focusable = target;
+      if (focusable !== null && typeof focusable === "object")
+        focusable.focusable = false;
+    }, _el$2);
+    _$setProp(_el$2, "flexGrow", 1);
+    _$setProp(_el$2, "scrollY", true);
+    _$setProp(_el$2, "verticalScrollbarOptions", {
+      visible: true
+    });
+    _$insert(_el$2, _$createComponent(For, {
+      get each() {
+        return header();
+      },
+      children: (line) => (() => {
+        var _el$5 = _$createElement("text");
+        _$insert(_el$5, () => line.text);
+        _$effect((_$p) => _$setProp(_el$5, "fg", color(line.tone), _$p));
+        return _el$5;
+      })()
+    }), _el$3);
+    _$insert(_el$2, _$createComponent(For, {
+      get each() {
+        return content();
+      },
+      children: (line, index) => {
+        const selected = () => index() === selectedLineIndex(content(), cursorIndex());
+        return (() => {
+          var _el$6 = _$createElement("text");
+          _$insert(_el$6, () => line.text);
+          _$effect((_p$) => {
+            var _v$3 = `line-${index()}`, _v$4 = color(line.tone), _v$5 = selected() ? selectedBackground() : undefined, _v$6 = selected() ? TextAttributes.BOLD : undefined;
+            _v$3 !== _p$.e && (_p$.e = _$setProp(_el$6, "id", _v$3, _p$.e));
+            _v$4 !== _p$.t && (_p$.t = _$setProp(_el$6, "fg", _v$4, _p$.t));
+            _v$5 !== _p$.a && (_p$.a = _$setProp(_el$6, "bg", _v$5, _p$.a));
+            _v$6 !== _p$.o && (_p$.o = _$setProp(_el$6, "attributes", _v$6, _p$.o));
+            return _p$;
+          }, {
+            e: undefined,
+            t: undefined,
+            a: undefined,
+            o: undefined
+          });
+          return _el$6;
+        })();
+      }
+    }), _el$3);
+    _$insert(_el$4, () => keysFor(view()));
+    _$effect((_p$) => {
+      var _v$ = props.ctx.theme.text.muted, _v$2 = props.ctx.theme.text.muted;
+      _v$ !== _p$.e && (_p$.e = _$setProp(_el$3, "fg", _v$, _p$.e));
+      _v$2 !== _p$.t && (_p$.t = _$setProp(_el$4, "fg", _v$2, _p$.t));
+      return _p$;
+    }, {
+      e: undefined,
+      t: undefined
+    });
+    return _el$;
+  })();
+}
+function selectedLineIndex(lines, cursor) {
+  let seen = -1;
+  for (let index = 0;index < lines.length; index += 1) {
+    if (lines[index].row === undefined)
+      continue;
+    seen += 1;
+    if (seen === cursor)
+      return index;
+  }
+  return -1;
+}
+
+// src/sidebar.tsx
+import { effect as _$effect2 } from "@opentui/solid";
+import { insert as _$insert2 } from "@opentui/solid";
+import { createComponent as _$createComponent2 } from "@opentui/solid";
+import { setProp as _$setProp2 } from "@opentui/solid";
+import { createElement as _$createElement2 } from "@opentui/solid";
+import { For as For2, createMemo as createMemo2 } from "solid-js";
+function TurnsSidebar(props) {
+  const color = (tone) => {
+    switch (tone) {
+      case "muted":
+        return props.ctx.theme.text.muted;
+      case "warning":
+        return props.ctx.theme.text.feedback.warning.base;
+      case "accent":
+        return props.ctx.theme.text.feedback.info.base;
+      default:
+        return props.ctx.theme.text.base;
+    }
+  };
+  const lines = createMemo2(() => {
+    props.deps.refresh();
+    const db = props.deps.db();
+    if (db === undefined)
+      return [];
+    const budget = props.deps.budget ?? 34;
+    try {
+      const summary = sessionSummaryLines(overview(db, undefined, {
+        sessionID: props.sessionID
+      }), budget);
+      const history = sidebarLines(turns(db, {
+        sessionID: props.sessionID,
+        limit: props.deps.limit
+      }), {
+        ...props.options,
+        budget
+      });
+      return [...summary, {
+        text: "turns",
+        tone: "accent"
+      }, ...history];
+    } catch {
+      return [];
+    }
+  });
+  return (() => {
+    var _el$ = _$createElement2("box");
+    _$setProp2(_el$, "flexDirection", "column");
+    _$setProp2(_el$, "paddingLeft", 1);
+    _$setProp2(_el$, "paddingRight", 1);
+    _$insert2(_el$, _$createComponent2(For2, {
+      get each() {
+        return lines();
+      },
+      children: (line) => (() => {
+        var _el$2 = _$createElement2("text");
+        _$insert2(_el$2, () => line.text);
+        _$effect2((_$p) => _$setProp2(_el$2, "fg", color(line.tone), _$p));
+        return _el$2;
+      })()
+    }));
+    return _el$;
+  })();
+}
+
+// src/tui.tsx
+var REFRESH_THROTTLE_MS = 300;
+var __test = {
+  line: undefined,
+  lineText: undefined,
+  open: undefined,
+  state: undefined
+};
+var tui_default = Plugin.define({
+  id: "usage-insights",
+  setup(ctx) {
+    const options = ctx.options ?? {};
+    if (options.enabled === false)
+      return;
+    const panelEnabled = options.panel !== false;
+    const [settings, updateSettings] = ctx.storage.store("panel", {
+      initial: DEFAULT_SETTINGS
+    });
+    const patchSettings = (mutation) => {
+      updateSettings(mutation);
+    };
+    const [refresh, setRefresh] = createSignal2(0);
+    let database;
+    let databaseFailed = false;
+    let refreshTimer;
+    let lastRefresh = 0;
+    function bumpRefresh() {
+      const now = Date.now();
+      const wait = lastRefresh + REFRESH_THROTTLE_MS - now;
+      if (wait <= 0) {
+        lastRefresh = now;
+        setRefresh((value) => value + 1);
+        return;
+      }
+      if (refreshTimer !== undefined)
+        return;
+      refreshTimer = setTimeout(() => {
+        refreshTimer = undefined;
+        lastRefresh = Date.now();
+        setRefresh((value) => value + 1);
+      }, wait);
+      refreshTimer.unref?.();
+    }
+    function db() {
+      if (database !== undefined)
+        return database;
+      if (databaseFailed)
+        return;
+      try {
+        database = openStatsDbReadOnly(resolveDbPath(options.db));
+        return database;
+      } catch {
+        databaseFailed = true;
+        return;
+      }
+    }
+    function withWrite(run) {
+      let handle;
+      try {
+        handle = openStatsDbWrite(resolveDbPath(options.db));
+        return run(handle);
+      } catch {
+        return;
+      } finally {
+        handle?.close();
+      }
+    }
+    function sessionStart(sessionID) {
+      return ctx.data.session.get(sessionID)?.time.created;
+    }
+    function sessionIdle(sessionID) {
+      try {
+        return ctx.data.session.status(sessionID) === "idle";
+      } catch {
+        return true;
+      }
+    }
+    function lineFor(sessionID) {
+      if (!sessionIdle(sessionID))
+        return;
+      const messages = ctx.data.session.message.list(sessionID);
+      const info = ctx.data.session.get(sessionID);
+      return computeTurn(toTranscriptTail(messages, 2), sessionTotals(info));
+    }
+    function toneColor(tone) {
+      if (tone === "warning")
+        return ctx.theme.text.feedback.warning.base;
+      if (tone === "muted")
+        return ctx.theme.text.muted;
+      return ctx.theme.text.base;
+    }
+    function Line(props) {
+      const parts = createMemo3(() => lineParts(lineFor(props.sessionID), {
+        labels: options.labels,
+        fields: options.fields,
+        turnTotals: options.turnTotals
+      }));
+      return _$createComponent3(Show, {
+        get when() {
+          return parts().length > 0;
+        },
+        children: () => {
+          let node;
+          const element = (() => {
+            var _el$ = _$createElement3("text");
+            _$use2((target) => {
+              node = target;
+            }, _el$);
+            return _el$;
+          })();
+          createRenderEffect2(() => {
+            const rendered = node;
+            if (rendered === undefined)
+              return;
+            const current = parts();
+            rendered.content = current.length === 0 ? "" : new StyledText(current.map((part) => fg(toneColor(part.tone))(part.text)));
+          });
+          return element;
+        }
+      });
+    }
+    const disposeLine = ctx.ui.slot({
+      append: "session.composer.top",
+      render: (input) => _$createComponent3(Line, {
+        get sessionID() {
+          return input.sessionID;
+        }
+      })
+    });
+    const disposePanel = panelEnabled ? ctx.ui.slot({
+      append: "session.panel",
+      render: (input) => input.name === PANEL_NAME ? _$createComponent3(Panel, {
+        input,
+        ctx,
+        deps: {
+          db,
+          dbPath: () => resolveDbPath(options.db),
+          withWrite,
+          now: () => Date.now(),
+          sessionStart,
+          refresh
+        },
+        settings,
+        update: patchSettings,
+        get format() {
+          return {
+            labels: options.labels,
+            fields: options.fields,
+            turnTotals: options.turnTotals
+          };
+        }
+      }) : null
+    }) : () => {};
+    const disposeSidebar = ctx.ui.slot({
+      append: "sidebar.content",
+      render: (input) => options.sidebar === false ? null : _$createComponent3(TurnsSidebar, {
+        get sessionID() {
+          return input.sessionID;
+        },
+        ctx,
+        get deps() {
+          return {
+            db,
+            refresh,
+            limit: Math.max(1, Math.round(options.sidebarTurns ?? 5))
+          };
+        },
+        get options() {
+          return {
+            labels: options.labels,
+            fields: options.fields,
+            turnTotals: options.turnTotals
+          };
+        }
+      })
+    });
+    function open(input) {
+      const parsed = parseArgs(input);
+      if (parsed.view !== undefined || parsed.range !== undefined) {
+        patchSettings((draft) => {
+          if (parsed.view !== undefined)
+            draft.view = parsed.view;
+          if (parsed.range !== undefined)
+            draft.range = parsed.range;
+        });
+      }
+      const tokens = (input ?? "").split(/\s+/).map((token) => token.trim()).filter((token) => token !== "" && !token.startsWith("/"));
+      if (tokens.length === 0 && ctx.ui.panel.current()?.name === PANEL_NAME) {
+        ctx.ui.panel.close();
+        return true;
+      }
+      return ctx.ui.panel.open(PANEL_NAME);
+    }
+    if (panelEnabled) {
+      ctx.keymap.layer(() => {
+        return {
+          mode: "global",
+          commands: [{
+            id: "usage-insights.stats",
+            title: "Usage insights",
+            description: "Open the usage statistics panel",
+            group: "Usage insights",
+            bind: false,
+            palette: true,
+            slash: {
+              name: "usage",
+              aliases: ["insights"],
+              arguments: true
+            },
+            run: (input) => {
+              if (!open(input)) {
+                ctx.ui.toast.show({
+                  message: "Open a session first, then run /usage",
+                  variant: "warning"
+                });
+              }
+            }
+          }]
+        };
+      });
+    }
+    const disposeEvents = [
+      ctx.data.on("session.step.ended", () => bumpRefresh()),
+      ctx.data.on("session.execution.succeeded", () => bumpRefresh()),
+      ctx.data.on("session.execution.failed", () => bumpRefresh()),
+      ctx.data.on("session.execution.interrupted", () => bumpRefresh()),
+      ctx.data.on("session.compaction.ended", () => bumpRefresh())
+    ];
+    __test.line = lineFor;
+    __test.lineText = (sessionID) => lineText(lineParts(lineFor(sessionID), {
+      labels: options.labels,
+      fields: options.fields
+    }));
+    __test.open = open;
+    __test.state = () => {
+      const current = sanitizeSettings(settings);
+      return {
+        view: current.view,
+        range: current.range
+      };
+    };
+    return () => {
+      if (refreshTimer !== undefined)
+        clearTimeout(refreshTimer);
+      for (const dispose of disposeEvents)
+        dispose();
+      disposeLine();
+      disposePanel();
+      disposeSidebar();
+      database?.close();
+    };
+  }
+});
+export {
+  __test,
+  tui_default as default
+};
+
+//# debugId=6DDD20AEAE1B401D64756E2164756E21