opencode-usage-insights 0.0.0-stage → 0.1.1

package/dist/index.js

@@ -0,0 +1,1227 @@
+// @bun
+// src/index.ts
+import { Plugin } from "@opencode/plugin";
+
+// 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/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/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/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/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/recorder.ts
+function createRecorder(db, options) {
+  const MAX_TRACKED_SESSIONS = 512;
+  const MAX_PENDING = 256;
+  const pending = new Map;
+  const lastModel = new Map;
+  const now = options?.now ?? (() => Date.now());
+  const MAX_DEFERRED = 256;
+  const deferred = [];
+  function isBusy(error) {
+    const code = error?.code;
+    return code === "SQLITE_BUSY" || code === "SQLITE_LOCKED";
+  }
+  function enqueue(run) {
+    if (deferred.length >= MAX_DEFERRED)
+      deferred.shift();
+    deferred.push(run);
+  }
+  function flushDeferred() {
+    while (deferred.length > 0) {
+      const next = deferred[0];
+      try {
+        next();
+      } catch {
+        return;
+      }
+      deferred.shift();
+    }
+  }
+  function write(run) {
+    if (deferred.length > 0) {
+      flushDeferred();
+      if (deferred.length > 0) {
+        enqueue(run);
+        return;
+      }
+    }
+    try {
+      run();
+    } catch (error) {
+      if (isBusy(error))
+        enqueue(run);
+    }
+  }
+  function remember(map, key, value, limit) {
+    map.delete(key);
+    map.set(key, value);
+    while (map.size > limit) {
+      const oldest = map.keys().next();
+      if (oldest.done === true)
+        break;
+      map.delete(oldest.value);
+    }
+  }
+  function forget(sessionID) {
+    lastModel.delete(sessionID);
+    for (const [messageID, step] of pending) {
+      if (step.sessionID === sessionID)
+        pending.delete(messageID);
+    }
+  }
+  function recordPendingStep(messageID, data, finish, at) {
+    const sessionID = data.sessionID;
+    if (typeof sessionID !== "string")
+      return;
+    const info = pending.get(messageID);
+    pending.delete(messageID);
+    const model = info?.model ?? lastModel.get(sessionID);
+    write(() => recordStep(db, {
+      messageID,
+      sessionID,
+      providerID: model?.providerID,
+      modelID: model?.id,
+      variant: model?.variant,
+      input: data.tokens?.input,
+      output: data.tokens?.output,
+      reasoning: data.tokens?.reasoning,
+      cacheRead: data.tokens?.cache?.read,
+      cacheWrite: data.tokens?.cache?.write,
+      cost: data.cost,
+      createdAt: info?.started,
+      streamedAt: info?.streamed,
+      completedAt: at,
+      finish,
+      recordedAt: now()
+    }));
+  }
+  function handleEvent(event) {
+    if (deferred.length > 0)
+      flushDeferred();
+    const data = event.data ?? {};
+    const at = typeof event.created === "number" ? event.created : now();
+    const sessionID = typeof data.sessionID === "string" ? data.sessionID : undefined;
+    switch (event.type) {
+      case "session.created": {
+        if (sessionID === undefined)
+          return;
+        write(() => upsertSession(db, {
+          sessionID,
+          parentID: data.parentID,
+          directory: data.location?.directory,
+          title: data.title,
+          startedAt: at,
+          updatedAt: at
+        }));
+        if (data.model !== undefined)
+          remember(lastModel, sessionID, data.model, MAX_TRACKED_SESSIONS);
+        return;
+      }
+      case "session.deleted": {
+        if (sessionID !== undefined)
+          forget(sessionID);
+        return;
+      }
+      case "session.renamed": {
+        if (sessionID === undefined)
+          return;
+        write(() => upsertSession(db, { sessionID, title: data.title, updatedAt: at }));
+        return;
+      }
+      case "session.moved": {
+        if (sessionID === undefined)
+          return;
+        write(() => upsertSession(db, { sessionID, directory: data.location?.directory, updatedAt: at }));
+        return;
+      }
+      case "session.inbox.enqueued": {
+        if (sessionID === undefined)
+          return;
+        if (data.item?.type !== "user" && data.item?.type !== "synthetic")
+          return;
+        const inboxID = data.inboxID;
+        if (typeof inboxID !== "string")
+          return;
+        write(() => recordPrompt(db, { sessionID, messageID: inboxID, createdAt: at }));
+        return;
+      }
+      case "session.model.selected": {
+        if (sessionID !== undefined && data.model !== undefined)
+          remember(lastModel, sessionID, data.model, MAX_TRACKED_SESSIONS);
+        return;
+      }
+      case "session.step.started": {
+        if (sessionID === undefined || typeof data.assistantMessageID !== "string")
+          return;
+        remember(pending, data.assistantMessageID, {
+          messageID: data.assistantMessageID,
+          sessionID,
+          started: typeof data.started === "number" ? data.started : undefined,
+          streamed: undefined,
+          model: data.model
+        }, MAX_PENDING);
+        return;
+      }
+      case "session.step.streamed": {
+        if (typeof data.assistantMessageID !== "string")
+          return;
+        const info = pending.get(data.assistantMessageID);
+        if (info !== undefined)
+          info.streamed = at;
+        return;
+      }
+      case "session.step.ended": {
+        if (typeof data.assistantMessageID !== "string")
+          return;
+        recordPendingStep(data.assistantMessageID, data, data.finish ?? "unknown", at);
+        return;
+      }
+      case "session.step.failed": {
+        if (typeof data.assistantMessageID !== "string")
+          return;
+        recordPendingStep(data.assistantMessageID, data, data.finish ?? "error", at);
+        return;
+      }
+      case "session.compaction.ended": {
+        if (sessionID === undefined)
+          return;
+        write(() => recordEvent(db, {
+          sessionID,
+          kind: COMPACTION_KIND,
+          at,
+          data: { reason: data.reason, model: data.model, tokens: data.tokens, cost: data.cost }
+        }));
+        return;
+      }
+      default:
+        return;
+    }
+  }
+  function pendingFor(sessionID) {
+    let found;
+    for (const item of pending.values()) {
+      if (item.sessionID !== sessionID)
+        continue;
+      if (found === undefined || (item.started ?? 0) >= (found.started ?? 0))
+        found = item;
+    }
+    return found;
+  }
+  return { handleEvent, pendingFor };
+}
+
+// src/index.ts
+function tryOpen(path) {
+  try {
+    return openStatsDb(path);
+  } catch {
+    return;
+  }
+}
+var src_default = Plugin.define({
+  id: "usage-insights",
+  async setup(ctx) {
+    const options = ctx.options ?? {};
+    if (options.enabled === false)
+      return;
+    const db = tryOpen(resolveDbPath(options.db));
+    if (db === undefined)
+      return;
+    try {
+      db.exec("PRAGMA busy_timeout = 1000");
+    } catch {}
+    const recorder = createRecorder(db);
+    const abort = new AbortController;
+    const stream = (async () => {
+      try {
+        for await (const event of ctx.event.subscribe({ signal: abort.signal })) {
+          try {
+            recorder.handleEvent(event);
+          } catch {}
+        }
+      } catch {}
+    })();
+    return async () => {
+      abort.abort();
+      await stream;
+      db.close();
+    };
+  }
+});
+export {
+  src_default as default
+};
+
+//# debugId=CB2A8AAFDC0E182864756E2164756E21