tokentrace 0.19.2 → 0.20.0

package/dist/runtime/chatgpt-app.mjs

@@ -0,0 +1,3901 @@
+import { createRequire as __tokentraceCreateRequire } from 'node:module'; const require = __tokentraceCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/lib/chatgpt-app/server.ts
+import { createServer } from "node:http";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+
+// src/lib/chatgpt-app/prototype.ts
+import { registerAppResource, registerAppTool, RESOURCE_MIME_TYPE } from "@modelcontextprotocol/ext-apps/server";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+
+// src/lib/format.ts
+function formatTokens(value) {
+  const number4 = value ?? 0;
+  if (number4 >= 999995e3) return `${(number4 / 1e9).toFixed(2)}B`;
+  if (number4 >= 999950) return `${(number4 / 1e6).toFixed(2)}M`;
+  if (number4 >= 1e3) return `${(number4 / 1e3).toFixed(1)}K`;
+  return number4.toLocaleString();
+}
+function formatCurrency(value, currency = "USD") {
+  if (value == null) return "Unknown";
+  return new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency,
+    maximumFractionDigits: value < 1 ? 4 : 2
+  }).format(value);
+}
+
+// src/db/client.ts
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+
+// src/db/migrate-core.ts
+var ddl = `
+PRAGMA journal_mode = WAL;
+PRAGMA foreign_keys = ON;
+
+CREATE TABLE IF NOT EXISTS providers (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  type TEXT NOT NULL,
+  created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+);
+
+CREATE TABLE IF NOT EXISTS tools (
+  id TEXT PRIMARY KEY,
+  provider_id TEXT NOT NULL REFERENCES providers(id) ON DELETE CASCADE,
+  name TEXT NOT NULL,
+  created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+);
+CREATE UNIQUE INDEX IF NOT EXISTS tools_provider_name_idx ON tools(provider_id, name);
+
+CREATE TABLE IF NOT EXISTS models (
+  id TEXT PRIMARY KEY,
+  provider_id TEXT NOT NULL REFERENCES providers(id) ON DELETE CASCADE,
+  name TEXT NOT NULL,
+  input_token_price REAL,
+  output_token_price REAL,
+  cached_input_token_price REAL,
+  cache_write_token_price REAL,
+  currency TEXT NOT NULL DEFAULT 'USD',
+  effective_from INTEGER,
+  raw_metadata TEXT
+);
+CREATE UNIQUE INDEX IF NOT EXISTS models_provider_name_idx ON models(provider_id, name);
+
+CREATE TABLE IF NOT EXISTS projects (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  path TEXT NOT NULL,
+  created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+);
+CREATE UNIQUE INDEX IF NOT EXISTS projects_path_idx ON projects(path);
+
+CREATE TABLE IF NOT EXISTS sessions (
+  id TEXT PRIMARY KEY,
+  source_id TEXT NOT NULL,
+  tool_id TEXT NOT NULL REFERENCES tools(id) ON DELETE CASCADE,
+  project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+  started_at INTEGER,
+  ended_at INTEGER,
+  title TEXT,
+  source_file TEXT NOT NULL,
+  raw_metadata TEXT
+);
+CREATE UNIQUE INDEX IF NOT EXISTS sessions_source_id_idx ON sessions(source_id);
+CREATE INDEX IF NOT EXISTS sessions_tool_idx ON sessions(tool_id);
+CREATE INDEX IF NOT EXISTS sessions_project_idx ON sessions(project_id);
+CREATE INDEX IF NOT EXISTS sessions_started_idx ON sessions(started_at);
+
+CREATE TABLE IF NOT EXISTS interactions (
+  id TEXT PRIMARY KEY,
+  source_id TEXT NOT NULL,
+  session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+  timestamp INTEGER,
+  role TEXT NOT NULL,
+  model_id TEXT REFERENCES models(id) ON DELETE SET NULL,
+  input_tokens INTEGER NOT NULL DEFAULT 0,
+  output_tokens INTEGER NOT NULL DEFAULT 0,
+  cache_read_tokens INTEGER NOT NULL DEFAULT 0,
+  cache_write_tokens INTEGER NOT NULL DEFAULT 0,
+  reasoning_tokens INTEGER NOT NULL DEFAULT 0,
+  total_tokens INTEGER NOT NULL DEFAULT 0,
+  estimated_tokens INTEGER NOT NULL DEFAULT 0,
+  token_confidence TEXT NOT NULL DEFAULT 'unknown',
+  cost REAL,
+  cost_estimated INTEGER NOT NULL DEFAULT 0,
+  latency_ms INTEGER,
+  raw_text_preview TEXT,
+  raw_text TEXT,
+  raw_metadata TEXT
+);
+CREATE UNIQUE INDEX IF NOT EXISTS interactions_source_id_idx ON interactions(source_id);
+CREATE INDEX IF NOT EXISTS interactions_session_idx ON interactions(session_id);
+CREATE INDEX IF NOT EXISTS interactions_model_idx ON interactions(model_id);
+CREATE INDEX IF NOT EXISTS interactions_timestamp_idx ON interactions(timestamp);
+CREATE INDEX IF NOT EXISTS interactions_analytics_cover_idx
+  ON interactions(timestamp, session_id, model_id, total_tokens, input_tokens, output_tokens,
+    cache_read_tokens, cache_write_tokens, reasoning_tokens, cost, cost_estimated,
+    estimated_tokens, token_confidence);
+CREATE INDEX IF NOT EXISTS interactions_session_analytics_idx
+  ON interactions(session_id, timestamp, model_id, total_tokens, input_tokens, output_tokens,
+    cache_read_tokens, cache_write_tokens, reasoning_tokens, cost, cost_estimated,
+    estimated_tokens, token_confidence);
+CREATE INDEX IF NOT EXISTS interactions_cost_repair_idx
+  ON interactions(cost, timestamp, session_id, model_id, total_tokens, input_tokens, output_tokens,
+    cache_read_tokens, cache_write_tokens, reasoning_tokens, token_confidence);
+
+PRAGMA user_version;
+
+CREATE TABLE IF NOT EXISTS tool_calls (
+  id TEXT PRIMARY KEY,
+  interaction_id TEXT NOT NULL REFERENCES interactions(id) ON DELETE CASCADE,
+  name TEXT NOT NULL,
+  status TEXT,
+  duration_ms INTEGER,
+  raw_metadata TEXT
+);
+CREATE INDEX IF NOT EXISTS tool_calls_interaction_idx ON tool_calls(interaction_id);
+
+CREATE TABLE IF NOT EXISTS scan_runs (
+  id TEXT PRIMARY KEY,
+  started_at INTEGER NOT NULL,
+  completed_at INTEGER,
+  files_scanned INTEGER NOT NULL DEFAULT 0,
+  records_imported INTEGER NOT NULL DEFAULT 0,
+  warnings TEXT NOT NULL DEFAULT '[]',
+  errors TEXT NOT NULL DEFAULT '[]'
+);
+
+CREATE TABLE IF NOT EXISTS scan_files (
+  id TEXT PRIMARY KEY,
+  scan_run_id TEXT NOT NULL REFERENCES scan_runs(id) ON DELETE CASCADE,
+  path TEXT NOT NULL,
+  modified_time INTEGER,
+  size_bytes INTEGER NOT NULL DEFAULT 0,
+  file_hash TEXT,
+  parser TEXT,
+  status TEXT NOT NULL,
+  records_imported INTEGER NOT NULL DEFAULT 0,
+  warnings TEXT NOT NULL DEFAULT '[]',
+  errors TEXT NOT NULL DEFAULT '[]',
+  raw_metadata TEXT
+);
+CREATE INDEX IF NOT EXISTS scan_files_path_hash_idx ON scan_files(path, file_hash);
+CREATE INDEX IF NOT EXISTS scan_files_run_idx ON scan_files(scan_run_id);
+CREATE INDEX IF NOT EXISTS scan_files_path_latest_idx ON scan_files(path, scan_run_id, status, parser);
+
+CREATE TABLE IF NOT EXISTS settings (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL,
+  updated_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+);
+
+CREATE TABLE IF NOT EXISTS unknown_cost_reviews (
+  key TEXT PRIMARY KEY,
+  source_file TEXT NOT NULL DEFAULT '',
+  model TEXT NOT NULL DEFAULT '',
+  cause TEXT NOT NULL DEFAULT '',
+  status TEXT NOT NULL DEFAULT 'unresolved',
+  notes TEXT NOT NULL DEFAULT '',
+  created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  updated_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+);
+
+CREATE TABLE IF NOT EXISTS saved_views (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  filters TEXT NOT NULL DEFAULT '{}',
+  created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  updated_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+);
+CREATE INDEX IF NOT EXISTS saved_views_updated_idx ON saved_views(updated_at);
+
+CREATE TABLE IF NOT EXISTS file_parser_overrides (
+  path TEXT PRIMARY KEY,
+  parser_id TEXT,
+  excluded INTEGER NOT NULL DEFAULT 0,
+  note TEXT,
+  created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  updated_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  CHECK (excluded IN (0, 1)),
+  CHECK ((excluded = 1 AND parser_id IS NULL) OR (excluded = 0 AND parser_id IS NOT NULL))
+);
+CREATE INDEX IF NOT EXISTS file_parser_overrides_updated_idx ON file_parser_overrides(updated_at);
+
+CREATE TABLE IF NOT EXISTS saved_reports (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  name_lower TEXT NOT NULL UNIQUE,
+  view_type TEXT NOT NULL,
+  params TEXT NOT NULL DEFAULT '{}',
+  format TEXT NOT NULL DEFAULT 'markdown',
+  created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  last_run_at INTEGER
+);
+CREATE INDEX IF NOT EXISTS saved_reports_updated_idx ON saved_reports(created_at);
+
+CREATE TABLE IF NOT EXISTS agent_actions (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  ts INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  surface TEXT NOT NULL,
+  command TEXT NOT NULL,
+  outcome TEXT NOT NULL,
+  summary TEXT NOT NULL DEFAULT '',
+  payload TEXT NOT NULL DEFAULT '{}'
+);
+CREATE INDEX IF NOT EXISTS agent_actions_ts_idx ON agent_actions(ts);
+
+CREATE TABLE IF NOT EXISTS model_aliases (
+  id TEXT PRIMARY KEY,
+  provider_id TEXT NOT NULL,
+  observed_model TEXT NOT NULL,
+  priced_model_id TEXT NOT NULL REFERENCES models(id) ON DELETE CASCADE,
+  confidence REAL NOT NULL,
+  rule TEXT NOT NULL,
+  notes TEXT,
+  created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  updated_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+);
+CREATE UNIQUE INDEX IF NOT EXISTS model_aliases_provider_observed_idx
+  ON model_aliases(provider_id, observed_model);
+CREATE INDEX IF NOT EXISTS model_aliases_priced_model_idx
+  ON model_aliases(priced_model_id);
+`;
+function applyMigrations(sqlite2) {
+  sqlite2.exec(ddl);
+  const interactionColumns = sqlite2.prepare("PRAGMA table_info(interactions)").all();
+  if (!interactionColumns.some((column) => column.name === "token_confidence")) {
+    try {
+      sqlite2.exec("ALTER TABLE interactions ADD COLUMN token_confidence TEXT NOT NULL DEFAULT 'unknown'");
+    } catch (error) {
+      if (!(error instanceof Error) || !error.message.toLowerCase().includes("duplicate column")) {
+        throw error;
+      }
+    }
+  }
+  const modelColumns = sqlite2.prepare("PRAGMA table_info(models)").all();
+  if (!modelColumns.some((column) => column.name === "cache_write_token_price")) {
+    try {
+      sqlite2.exec("ALTER TABLE models ADD COLUMN cache_write_token_price REAL");
+    } catch (error) {
+      if (!(error instanceof Error) || !error.message.toLowerCase().includes("duplicate column")) {
+        throw error;
+      }
+    }
+  }
+  const reviewColumns = sqlite2.prepare("PRAGMA table_info(unknown_cost_reviews)").all();
+  const reviewColumnNames = new Set(reviewColumns.map((column) => column.name));
+  const addReviewColumn = (name, definition) => {
+    if (reviewColumnNames.has(name)) return;
+    try {
+      sqlite2.exec(`ALTER TABLE unknown_cost_reviews ADD COLUMN ${definition}`);
+      reviewColumnNames.add(name);
+    } catch (error) {
+      if (!(error instanceof Error) || !error.message.toLowerCase().includes("duplicate column")) {
+        throw error;
+      }
+    }
+  };
+  addReviewColumn("source_file", "source_file TEXT NOT NULL DEFAULT ''");
+  addReviewColumn("model", "model TEXT NOT NULL DEFAULT ''");
+  addReviewColumn("cause", "cause TEXT NOT NULL DEFAULT ''");
+  addReviewColumn("status", "status TEXT NOT NULL DEFAULT 'unresolved'");
+  addReviewColumn("notes", "notes TEXT NOT NULL DEFAULT ''");
+  addReviewColumn("created_at", "created_at INTEGER NOT NULL DEFAULT 0");
+  addReviewColumn("updated_at", "updated_at INTEGER NOT NULL DEFAULT 0");
+  const upgradedReviewColumns = sqlite2.prepare("PRAGMA table_info(unknown_cost_reviews)").all();
+  const upgradedReviewColumnNames = new Set(upgradedReviewColumns.map((column) => column.name));
+  if (upgradedReviewColumnNames.has("state")) {
+    sqlite2.exec("UPDATE unknown_cost_reviews SET status = state WHERE status = 'unresolved' AND state <> ''");
+  }
+  if (upgradedReviewColumnNames.has("note")) {
+    sqlite2.exec("UPDATE unknown_cost_reviews SET notes = note WHERE notes = '' AND note <> ''");
+  }
+  sqlite2.exec(`
+    UPDATE unknown_cost_reviews
+    SET cause = substr(key, 1, instr(key, ':') - 1)
+    WHERE cause = '' AND instr(key, ':') > 0;
+
+    UPDATE unknown_cost_reviews
+    SET created_at = updated_at
+    WHERE created_at = 0 AND updated_at > 0;
+
+    UPDATE unknown_cost_reviews
+    SET created_at = unixepoch() * 1000
+    WHERE created_at = 0;
+
+    UPDATE unknown_cost_reviews
+    SET updated_at = created_at
+    WHERE updated_at = 0;
+  `);
+  const repairRows = sqlite2.prepare("SELECT key, model FROM unknown_cost_reviews WHERE model = ''").all();
+  const updateModel = sqlite2.prepare("UPDATE unknown_cost_reviews SET model = ? WHERE key = ?");
+  for (const row of repairRows) {
+    const model = row.key.split(":").at(-1) ?? "";
+    updateModel.run(model, row.key);
+  }
+}
+
+// src/db/sqlite-functions.ts
+var localDateKeyFunctionName = "local_date_key";
+var invalidDateKey = "1970-01-01";
+function timestampNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim()) {
+    const numeric = Number(value);
+    if (Number.isFinite(numeric)) return numeric;
+  }
+  return null;
+}
+function formatLocalDateKey(value) {
+  const timestamp = timestampNumber(value);
+  if (timestamp == null) return invalidDateKey;
+  const date = new Date(timestamp);
+  if (Number.isNaN(date.getTime())) return invalidDateKey;
+  return [
+    date.getFullYear(),
+    String(date.getMonth() + 1).padStart(2, "0"),
+    String(date.getDate()).padStart(2, "0")
+  ].join("-");
+}
+function registerSqliteFunctions(sqlite2) {
+  sqlite2.function(localDateKeyFunctionName, { deterministic: true }, formatLocalDateKey);
+}
+
+// src/db/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  interactionRelations: () => interactionRelations,
+  interactions: () => interactions,
+  modelRelations: () => modelRelations,
+  models: () => models,
+  projectRelations: () => projectRelations,
+  projects: () => projects,
+  providerRelations: () => providerRelations,
+  providers: () => providers,
+  savedViews: () => savedViews,
+  scanFiles: () => scanFiles,
+  scanRuns: () => scanRuns,
+  sessionRelations: () => sessionRelations,
+  sessions: () => sessions,
+  settings: () => settings,
+  toolCalls: () => toolCalls,
+  toolRelations: () => toolRelations,
+  tools: () => tools,
+  unknownCostReviews: () => unknownCostReviews
+});
+import { relations, sql } from "drizzle-orm";
+import {
+  index,
+  integer,
+  real,
+  sqliteTable,
+  text,
+  uniqueIndex
+} from "drizzle-orm/sqlite-core";
+var providers = sqliteTable("providers", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  type: text("type").notNull(),
+  createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
+});
+var tools = sqliteTable(
+  "tools",
+  {
+    id: text("id").primaryKey(),
+    providerId: text("provider_id").notNull().references(() => providers.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
+  },
+  (table) => ({
+    providerNameIdx: uniqueIndex("tools_provider_name_idx").on(
+      table.providerId,
+      table.name
+    )
+  })
+);
+var models = sqliteTable(
+  "models",
+  {
+    id: text("id").primaryKey(),
+    providerId: text("provider_id").notNull().references(() => providers.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    inputTokenPrice: real("input_token_price"),
+    outputTokenPrice: real("output_token_price"),
+    cachedInputTokenPrice: real("cached_input_token_price"),
+    cacheWriteTokenPrice: real("cache_write_token_price"),
+    currency: text("currency").notNull().default("USD"),
+    effectiveFrom: integer("effective_from", { mode: "timestamp_ms" }),
+    rawMetadata: text("raw_metadata", { mode: "json" }).$type()
+  },
+  (table) => ({
+    providerModelIdx: uniqueIndex("models_provider_name_idx").on(
+      table.providerId,
+      table.name
+    )
+  })
+);
+var projects = sqliteTable(
+  "projects",
+  {
+    id: text("id").primaryKey(),
+    name: text("name").notNull(),
+    path: text("path").notNull(),
+    createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
+  },
+  (table) => ({
+    pathIdx: uniqueIndex("projects_path_idx").on(table.path)
+  })
+);
+var sessions = sqliteTable(
+  "sessions",
+  {
+    id: text("id").primaryKey(),
+    sourceId: text("source_id").notNull(),
+    toolId: text("tool_id").notNull().references(() => tools.id, { onDelete: "cascade" }),
+    projectId: text("project_id").references(() => projects.id, {
+      onDelete: "set null"
+    }),
+    startedAt: integer("started_at", { mode: "timestamp_ms" }),
+    endedAt: integer("ended_at", { mode: "timestamp_ms" }),
+    title: text("title"),
+    sourceFile: text("source_file").notNull(),
+    rawMetadata: text("raw_metadata", { mode: "json" }).$type()
+  },
+  (table) => ({
+    sourceIdx: uniqueIndex("sessions_source_id_idx").on(table.sourceId),
+    toolIdx: index("sessions_tool_idx").on(table.toolId),
+    projectIdx: index("sessions_project_idx").on(table.projectId),
+    startedIdx: index("sessions_started_idx").on(table.startedAt)
+  })
+);
+var interactions = sqliteTable(
+  "interactions",
+  {
+    id: text("id").primaryKey(),
+    sourceId: text("source_id").notNull(),
+    sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+    timestamp: integer("timestamp", { mode: "timestamp_ms" }),
+    role: text("role").notNull(),
+    modelId: text("model_id").references(() => models.id, {
+      onDelete: "set null"
+    }),
+    inputTokens: integer("input_tokens").notNull().default(0),
+    outputTokens: integer("output_tokens").notNull().default(0),
+    cacheReadTokens: integer("cache_read_tokens").notNull().default(0),
+    cacheWriteTokens: integer("cache_write_tokens").notNull().default(0),
+    reasoningTokens: integer("reasoning_tokens").notNull().default(0),
+    totalTokens: integer("total_tokens").notNull().default(0),
+    estimatedTokens: integer("estimated_tokens", { mode: "boolean" }).notNull().default(false),
+    tokenConfidence: text("token_confidence").notNull().default("unknown"),
+    cost: real("cost"),
+    costEstimated: integer("cost_estimated", { mode: "boolean" }).notNull().default(false),
+    latencyMs: integer("latency_ms"),
+    rawTextPreview: text("raw_text_preview"),
+    rawText: text("raw_text"),
+    rawMetadata: text("raw_metadata", { mode: "json" }).$type()
+  },
+  (table) => ({
+    sourceIdx: uniqueIndex("interactions_source_id_idx").on(table.sourceId),
+    sessionIdx: index("interactions_session_idx").on(table.sessionId),
+    modelIdx: index("interactions_model_idx").on(table.modelId),
+    timestampIdx: index("interactions_timestamp_idx").on(table.timestamp),
+    analyticsCoverIdx: index("interactions_analytics_cover_idx").on(
+      table.timestamp,
+      table.sessionId,
+      table.modelId,
+      table.totalTokens,
+      table.inputTokens,
+      table.outputTokens,
+      table.cacheReadTokens,
+      table.cacheWriteTokens,
+      table.reasoningTokens,
+      table.cost,
+      table.costEstimated,
+      table.estimatedTokens,
+      table.tokenConfidence
+    ),
+    sessionAnalyticsIdx: index("interactions_session_analytics_idx").on(
+      table.sessionId,
+      table.timestamp,
+      table.modelId,
+      table.totalTokens,
+      table.inputTokens,
+      table.outputTokens,
+      table.cacheReadTokens,
+      table.cacheWriteTokens,
+      table.reasoningTokens,
+      table.cost,
+      table.costEstimated,
+      table.estimatedTokens,
+      table.tokenConfidence
+    ),
+    costRepairIdx: index("interactions_cost_repair_idx").on(
+      table.cost,
+      table.timestamp,
+      table.sessionId,
+      table.modelId,
+      table.totalTokens,
+      table.inputTokens,
+      table.outputTokens,
+      table.cacheReadTokens,
+      table.cacheWriteTokens,
+      table.reasoningTokens,
+      table.tokenConfidence
+    )
+  })
+);
+var toolCalls = sqliteTable(
+  "tool_calls",
+  {
+    id: text("id").primaryKey(),
+    interactionId: text("interaction_id").notNull().references(() => interactions.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    status: text("status"),
+    durationMs: integer("duration_ms"),
+    rawMetadata: text("raw_metadata", { mode: "json" }).$type()
+  },
+  (table) => ({
+    interactionIdx: index("tool_calls_interaction_idx").on(table.interactionId)
+  })
+);
+var scanRuns = sqliteTable("scan_runs", {
+  id: text("id").primaryKey(),
+  startedAt: integer("started_at", { mode: "timestamp_ms" }).notNull(),
+  completedAt: integer("completed_at", { mode: "timestamp_ms" }),
+  filesScanned: integer("files_scanned").notNull().default(0),
+  recordsImported: integer("records_imported").notNull().default(0),
+  warnings: text("warnings", { mode: "json" }).$type().notNull().default(sql`'[]'`),
+  errors: text("errors", { mode: "json" }).$type().notNull().default(sql`'[]'`)
+});
+var scanFiles = sqliteTable(
+  "scan_files",
+  {
+    id: text("id").primaryKey(),
+    scanRunId: text("scan_run_id").notNull().references(() => scanRuns.id, { onDelete: "cascade" }),
+    path: text("path").notNull(),
+    modifiedTime: integer("modified_time", { mode: "timestamp_ms" }),
+    sizeBytes: integer("size_bytes").notNull().default(0),
+    fileHash: text("file_hash"),
+    parser: text("parser"),
+    status: text("status").notNull(),
+    recordsImported: integer("records_imported").notNull().default(0),
+    warnings: text("warnings", { mode: "json" }).$type().notNull().default(sql`'[]'`),
+    errors: text("errors", { mode: "json" }).$type().notNull().default(sql`'[]'`),
+    rawMetadata: text("raw_metadata", { mode: "json" }).$type()
+  },
+  (table) => ({
+    pathHashIdx: index("scan_files_path_hash_idx").on(table.path, table.fileHash),
+    scanRunIdx: index("scan_files_run_idx").on(table.scanRunId),
+    pathLatestIdx: index("scan_files_path_latest_idx").on(
+      table.path,
+      table.scanRunId,
+      table.status,
+      table.parser
+    )
+  })
+);
+var settings = sqliteTable("settings", {
+  key: text("key").primaryKey(),
+  value: text("value", { mode: "json" }).$type().notNull(),
+  updatedAt: integer("updated_at", { mode: "timestamp_ms" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
+});
+var unknownCostReviews = sqliteTable("unknown_cost_reviews", {
+  key: text("key").primaryKey(),
+  sourceFile: text("source_file").notNull().default(""),
+  model: text("model").notNull().default(""),
+  cause: text("cause").notNull().default(""),
+  status: text("status").notNull().default("unresolved"),
+  notes: text("notes").notNull().default(""),
+  createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
+  updatedAt: integer("updated_at", { mode: "timestamp_ms" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
+});
+var savedViews = sqliteTable(
+  "saved_views",
+  {
+    id: text("id").primaryKey(),
+    name: text("name").notNull(),
+    filters: text("filters", { mode: "json" }).$type().notNull().default(sql`'{}'`),
+    createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
+    updatedAt: integer("updated_at", { mode: "timestamp_ms" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
+  },
+  (table) => ({
+    updatedIdx: index("saved_views_updated_idx").on(table.updatedAt)
+  })
+);
+var providerRelations = relations(providers, ({ many }) => ({
+  tools: many(tools),
+  models: many(models)
+}));
+var toolRelations = relations(tools, ({ one, many }) => ({
+  provider: one(providers, {
+    fields: [tools.providerId],
+    references: [providers.id]
+  }),
+  sessions: many(sessions)
+}));
+var modelRelations = relations(models, ({ one, many }) => ({
+  provider: one(providers, {
+    fields: [models.providerId],
+    references: [providers.id]
+  }),
+  interactions: many(interactions)
+}));
+var projectRelations = relations(projects, ({ many }) => ({
+  sessions: many(sessions)
+}));
+var sessionRelations = relations(sessions, ({ one, many }) => ({
+  tool: one(tools, {
+    fields: [sessions.toolId],
+    references: [tools.id]
+  }),
+  project: one(projects, {
+    fields: [sessions.projectId],
+    references: [projects.id]
+  }),
+  interactions: many(interactions)
+}));
+var interactionRelations = relations(interactions, ({ one, many }) => ({
+  session: one(sessions, {
+    fields: [interactions.sessionId],
+    references: [sessions.id]
+  }),
+  model: one(models, {
+    fields: [interactions.modelId],
+    references: [models.id]
+  }),
+  toolCalls: many(toolCalls)
+}));
+
+// src/db/client.ts
+var defaultDbPath = path.join(process.cwd(), ".tokentrace", "tokentrace.db");
+function databaseUrlPath(value) {
+  if (!value?.startsWith("file:")) return null;
+  try {
+    return fileURLToPath(value);
+  } catch {
+    return value.slice("file:".length);
+  }
+}
+var dbPath = process.env.TOKENTRACE_DB ?? databaseUrlPath(process.env.DATABASE_URL) ?? defaultDbPath;
+fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+var sqlite = new Database(dbPath);
+sqlite.pragma("journal_mode = WAL");
+sqlite.pragma("synchronous = NORMAL");
+sqlite.pragma("temp_store = MEMORY");
+sqlite.pragma("cache_size = -65536");
+sqlite.pragma("mmap_size = 268435456");
+sqlite.pragma("busy_timeout = 10000");
+sqlite.pragma("foreign_keys = ON");
+registerSqliteFunctions(sqlite);
+applyMigrations(sqlite);
+var db = drizzle(sqlite, { schema: schema_exports });
+
+// src/db/prepared.ts
+var cache = /* @__PURE__ */ new Map();
+function prepareCached(sql2) {
+  let stmt = cache.get(sql2);
+  if (!stmt) {
+    stmt = sqlite.prepare(sql2);
+    cache.set(sql2, stmt);
+  }
+  return stmt;
+}
+
+// src/lib/analytics-query-helpers.ts
+function number(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function dateStringFromTimestamp(timestamp) {
+  const date = new Date(timestamp);
+  return [
+    date.getFullYear(),
+    String(date.getMonth() + 1).padStart(2, "0"),
+    String(date.getDate()).padStart(2, "0")
+  ].join("-");
+}
+function addCalendarDays(value, days) {
+  const [year = NaN, month = NaN, day = NaN] = value.split("-").map(Number);
+  const date = new Date(year, month - 1, day);
+  date.setDate(date.getDate() + days);
+  return dateStringFromTimestamp(date.getTime());
+}
+function emptyTrendPoint(date) {
+  return {
+    date,
+    totalTokens: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    cachedTokens: 0,
+    reasoningTokens: 0,
+    cost: 0
+  };
+}
+function trendBounds(points, filters) {
+  const firstDataDate = points[0]?.date;
+  const lastDataDate = points.at(-1)?.date;
+  const fromDate = filters.from != null ? dateStringFromTimestamp(filters.from) : firstDataDate;
+  const toExclusiveDate = filters.to != null ? addCalendarDays(dateStringFromTimestamp(filters.to - 1), 1) : lastDataDate ? addCalendarDays(lastDataDate, 1) : null;
+  if (!fromDate || !toExclusiveDate || fromDate >= toExclusiveDate) return null;
+  return { fromDate, toExclusiveDate };
+}
+function fillMissingTrendDays(points, filters) {
+  const bounds = trendBounds(points, filters);
+  if (!bounds) return [];
+  const byDate = new Map(points.map((point) => [point.date, point]));
+  const filled = [];
+  for (let date = bounds.fromDate; date < bounds.toExclusiveDate; date = addCalendarDays(date, 1)) {
+    filled.push(byDate.get(date) ?? emptyTrendPoint(date));
+  }
+  return filled;
+}
+function parseJson(value, fallback) {
+  if (Array.isArray(value) || value && typeof value === "object") return value;
+  if (typeof value !== "string") return fallback;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
+function rows(sql2, ...params) {
+  return prepareCached(sql2).all(...params);
+}
+function withQuery(path2, params) {
+  const query = new URLSearchParams();
+  Object.entries(params).forEach(([key, value]) => {
+    if (value) query.set(key, value);
+  });
+  const serialized = query.toString();
+  return serialized ? `${path2}?${serialized}` : path2;
+}
+function stringMetadata(value, key) {
+  if (!value || typeof value !== "object") return null;
+  const candidate = value[key];
+  return typeof candidate === "string" && candidate.trim() ? candidate : null;
+}
+function numberMetadata(value, key) {
+  if (!value || typeof value !== "object") return null;
+  const candidate = value[key];
+  return typeof candidate === "number" && Number.isFinite(candidate) ? candidate : null;
+}
+function timestampWhere(filters = {}, alias = "i", prefix = "WHERE") {
+  const clauses = [];
+  const params = [];
+  if (filters.from != null) {
+    clauses.push(`${alias}.timestamp >= ?`);
+    params.push(filters.from);
+  }
+  if (filters.to != null) {
+    clauses.push(`${alias}.timestamp < ?`);
+    params.push(filters.to);
+  }
+  return {
+    sql: clauses.length ? `${prefix} ${clauses.join(" AND ")}` : "",
+    params
+  };
+}
+function timestampJoinCondition(filters = {}, alias = "i") {
+  const clauses = [];
+  const params = [];
+  if (filters.from != null) {
+    clauses.push(`${alias}.timestamp >= ?`);
+    params.push(filters.from);
+  }
+  if (filters.to != null) {
+    clauses.push(`${alias}.timestamp < ?`);
+    params.push(filters.to);
+  }
+  return {
+    sql: clauses.length ? ` AND ${clauses.join(" AND ")}` : "",
+    params
+  };
+}
+
+// src/lib/analytics/summary.ts
+function getSummary(filters = {}) {
+  const interactionFilter = timestampWhere(filters, "interactions");
+  const aggregate = sqlite.prepare(
+    `SELECT
+        COALESCE(SUM(total_tokens), 0) AS totalTokens,
+        COALESCE(SUM(input_tokens + output_tokens + reasoning_tokens), 0) AS nonCachedTokens,
+        COALESCE(SUM(input_tokens), 0) AS inputTokens,
+        COALESCE(SUM(output_tokens), 0) AS outputTokens,
+        COALESCE(SUM(cache_read_tokens), 0) AS cacheReadTokens,
+        COALESCE(SUM(cache_write_tokens), 0) AS cacheWriteTokens,
+        COALESCE(SUM(cache_read_tokens + cache_write_tokens), 0) AS cachedTokens,
+        COALESCE(SUM(reasoning_tokens), 0) AS reasoningTokens,
+        COALESCE(SUM(cost), 0) AS totalCost,
+        COALESCE(SUM(CASE WHEN cost_estimated = 0 AND cost IS NOT NULL THEN cost ELSE 0 END), 0) AS exactCost,
+        COALESCE(SUM(CASE WHEN cost_estimated = 1 AND cost IS NOT NULL THEN cost ELSE 0 END), 0) AS estimatedCost,
+        COALESCE(SUM(CASE WHEN cost IS NULL THEN 1 ELSE 0 END), 0) AS unknownCostInteractions,
+        COUNT(*) AS interactions,
+        COUNT(DISTINCT session_id) AS sessions
+       FROM interactions INDEXED BY interactions_analytics_cover_idx
+       ${interactionFilter.sql}`
+  ).get(...interactionFilter.params);
+  const toolFilter = timestampWhere(filters, "i");
+  const tool = sqlite.prepare(
+    `SELECT t.name
+       FROM interactions i INDEXED BY interactions_analytics_cover_idx
+       JOIN sessions s ON s.id = i.session_id
+       JOIN tools t ON t.id = s.tool_id
+       ${toolFilter.sql}
+       GROUP BY t.id
+       ORDER BY SUM(i.total_tokens) DESC
+       LIMIT 1`
+  ).get(...toolFilter.params);
+  const modelFilter = timestampWhere(filters, "i");
+  const model = sqlite.prepare(
+    `SELECT m.name
+       FROM interactions i INDEXED BY interactions_analytics_cover_idx
+       LEFT JOIN models m ON m.id = i.model_id
+       ${modelFilter.sql}
+       GROUP BY m.id
+       ORDER BY SUM(i.total_tokens) DESC
+       LIMIT 1`
+  ).get(...modelFilter.params);
+  return {
+    totalTokens: number(aggregate.totalTokens),
+    nonCachedTokens: number(aggregate.nonCachedTokens),
+    inputTokens: number(aggregate.inputTokens),
+    outputTokens: number(aggregate.outputTokens),
+    cacheReadTokens: number(aggregate.cacheReadTokens),
+    cacheWriteTokens: number(aggregate.cacheWriteTokens),
+    cachedTokens: number(aggregate.cachedTokens),
+    reasoningTokens: number(aggregate.reasoningTokens),
+    totalCost: number(aggregate.totalCost),
+    exactCost: number(aggregate.exactCost),
+    estimatedCost: number(aggregate.estimatedCost),
+    unknownCostInteractions: number(aggregate.unknownCostInteractions),
+    sessions: number(aggregate.sessions),
+    interactions: number(aggregate.interactions),
+    mostUsedTool: tool?.name ?? "No data",
+    mostUsedModel: model?.name ?? "No data"
+  };
+}
+var sevenDaysMs = 7 * 24 * 60 * 60 * 1e3;
+var maxUsefulPercentDelta = 999;
+function comparisonSnapshot(summary) {
+  return {
+    totalTokens: summary.totalTokens,
+    totalCost: summary.totalCost,
+    sessions: summary.sessions,
+    interactions: summary.interactions,
+    unknownCostInteractions: summary.unknownCostInteractions
+  };
+}
+function percentDelta(current, previous) {
+  if (previous === 0) return current === 0 ? 0 : null;
+  const rounded = Math.round((current - previous) / previous * 100);
+  return Math.abs(rounded) > maxUsefulPercentDelta ? null : rounded;
+}
+function deltaLabel(percentValue, absolute, previous, noun) {
+  if (percentValue == null) {
+    if (previous === 0) return absolute > 0 ? `New ${noun} activity` : `No ${noun} activity yet`;
+    if (absolute === 0) return `${noun} unchanged`;
+    return `${absolute > 0 ? "Higher" : "Lower"} ${noun} activity`;
+  }
+  if (percentValue === 0) return `${noun} unchanged`;
+  return `${Math.abs(percentValue)}% ${percentValue > 0 ? "more" : "less"} ${noun}`;
+}
+function getComparisonWindow(filters = {}) {
+  if (filters.from != null && filters.to != null && filters.to > filters.from) {
+    const duration = filters.to - filters.from;
+    return {
+      mode: "selected-period",
+      label: "Previous matching period",
+      current: { from: filters.from, to: filters.to },
+      previous: { from: filters.from - duration, to: filters.from }
+    };
+  }
+  const latest = sqlite.prepare("SELECT MAX(timestamp) AS latest FROM interactions WHERE timestamp IS NOT NULL").get();
+  const latestTimestamp = latest?.latest;
+  if (latestTimestamp == null) {
+    return {
+      mode: "empty",
+      label: "Previous period",
+      current: {},
+      previous: {}
+    };
+  }
+  const currentTo = latestTimestamp + 1;
+  const currentFrom = currentTo - sevenDaysMs;
+  return {
+    mode: "latest-seven-days",
+    label: "Previous 7 days",
+    current: { from: currentFrom, to: currentTo },
+    previous: { from: currentFrom - sevenDaysMs, to: currentFrom }
+  };
+}
+function getUsageComparison(filters = {}) {
+  const window = getComparisonWindow(filters);
+  const current = comparisonSnapshot(getSummary(window.current));
+  const previous = comparisonSnapshot(getSummary(window.previous));
+  const delta = {
+    totalTokens: current.totalTokens - previous.totalTokens,
+    totalCost: current.totalCost - previous.totalCost,
+    sessions: current.sessions - previous.sessions,
+    interactions: current.interactions - previous.interactions,
+    unknownCostInteractions: current.unknownCostInteractions - previous.unknownCostInteractions,
+    totalTokensPercent: percentDelta(current.totalTokens, previous.totalTokens),
+    totalCostPercent: percentDelta(current.totalCost, previous.totalCost),
+    sessionsPercent: percentDelta(current.sessions, previous.sessions),
+    interactionsPercent: percentDelta(current.interactions, previous.interactions),
+    unknownCostInteractionsPercent: percentDelta(
+      current.unknownCostInteractions,
+      previous.unknownCostInteractions
+    )
+  };
+  const headline = window.mode === "empty" ? "No previous usage to compare yet" : deltaLabel(delta.totalTokensPercent, delta.totalTokens, previous.totalTokens, "tokens");
+  const detail = window.mode === "selected-period" ? "Compared with the immediately previous matching period." : window.mode === "latest-seven-days" ? "Compared with the seven days before the latest imported interaction." : "Run a scan after CLI sessions to build a local comparison baseline.";
+  return {
+    mode: window.mode,
+    label: window.label,
+    current,
+    previous,
+    delta,
+    headline,
+    detail
+  };
+}
+
+// src/lib/analytics/trends.ts
+function getTrends(filters = {}) {
+  const filter = timestampWhere(filters, "i", "AND");
+  const points = rows(
+    `SELECT
+      local_date_key(i.timestamp) AS date,
+      COALESCE(SUM(i.total_tokens), 0) AS totalTokens,
+      COALESCE(SUM(i.input_tokens), 0) AS inputTokens,
+      COALESCE(SUM(i.output_tokens), 0) AS outputTokens,
+      COALESCE(SUM(i.cache_read_tokens + i.cache_write_tokens), 0) AS cachedTokens,
+      COALESCE(SUM(i.reasoning_tokens), 0) AS reasoningTokens,
+      COALESCE(SUM(i.cost), 0) AS cost
+     FROM interactions i INDEXED BY interactions_analytics_cover_idx
+     WHERE i.timestamp IS NOT NULL
+     ${filter.sql}
+     GROUP BY date
+     ORDER BY date ASC`,
+    ...filter.params
+  ).map((row) => ({
+    ...row,
+    totalTokens: number(row.totalTokens),
+    inputTokens: number(row.inputTokens),
+    outputTokens: number(row.outputTokens),
+    cachedTokens: number(row.cachedTokens),
+    reasoningTokens: number(row.reasoningTokens),
+    cost: number(row.cost)
+  }));
+  return fillMissingTrendDays(points, filters);
+}
+
+// src/lib/data-confidence.ts
+function ratio(value, total) {
+  if (total <= 0) return 0;
+  return Math.max(0, Math.min(1, value / total));
+}
+function grade(score, totalInteractions) {
+  if (totalInteractions <= 0) return "empty";
+  if (score >= 85) return "high";
+  if (score >= 60) return "medium";
+  return "low";
+}
+function buildDataConfidenceScore(input) {
+  const total = input.totalInteractions;
+  const exactRatio = ratio(input.exactTokenInteractions, total);
+  const tokenizerRatio = ratio(input.tokenizerEstimateInteractions, total);
+  const simpleRatio = ratio(input.simpleEstimateInteractions, total);
+  const unknownTokenRatio = ratio(input.unknownTokenInteractions, total);
+  const pricedRatio = ratio(input.pricedCostInteractions, total);
+  const unknownCostRatio = ratio(input.unknownCostInteractions, total);
+  const parser = input.parserConfidence == null ? 0.7 : Math.max(0, Math.min(1, input.parserConfidence));
+  const freshness = input.scanFreshness === "fresh" ? 1 : input.scanFreshness === "stale" ? 0.65 : input.scanFreshness === "no-successful-scan" ? 0.3 : 0;
+  const tokenScore = exactRatio * 100 + tokenizerRatio * 82 + simpleRatio * 55 - unknownTokenRatio * 35;
+  const costScore = pricedRatio * 100 - unknownCostRatio * 45;
+  const score = Math.max(
+    0,
+    Math.min(100, Math.round(tokenScore * 0.36 + costScore * 0.34 + parser * 100 * 0.18 + freshness * 100 * 0.12))
+  );
+  const drivers = [
+    `Token coverage: ${Math.round((exactRatio + tokenizerRatio) * 100)}% exact or tokenizer-estimated.`,
+    `Cost coverage: ${Math.round(pricedRatio * 100)}% priced.`
+  ];
+  if (input.unknownCostInteractions > 0) {
+    drivers.push(`Repair unknown costs for ${input.unknownCostInteractions.toLocaleString()} interactions.`);
+  }
+  if (input.simpleEstimateInteractions > 0 || input.unknownTokenInteractions > 0) {
+    drivers.push("Improve parser coverage to reduce simple or unknown token estimates.");
+  }
+  if (input.scanFreshness === "stale") {
+    drivers.push("Run a fresh scan.");
+  }
+  if (input.parserConfidence != null && input.parserConfidence < 0.75) {
+    drivers.push("Review parser confidence for this evidence path.");
+  }
+  return {
+    score,
+    grade: grade(score, total),
+    drivers,
+    repairHref: input.unknownCostInteractions > 0 ? "/repair" : null
+  };
+}
+
+// src/lib/analytics/entities.ts
+function getToolComparison(filters = {}) {
+  const filter = timestampWhere(filters, "i");
+  const subFilter = timestampWhere(filters, "i2", "AND");
+  return rows(
+    `SELECT
+      t.name AS tool,
+      p.name AS provider,
+      COALESCE(SUM(i.total_tokens), 0) AS totalTokens,
+      COALESCE(SUM(i.input_tokens), 0) AS inputTokens,
+      COALESCE(SUM(i.output_tokens), 0) AS outputTokens,
+      COALESCE(SUM(i.cache_read_tokens + i.cache_write_tokens), 0) AS cachedTokens,
+      COALESCE(SUM(i.cost), 0) AS cost,
+      COUNT(DISTINCT s.id) AS sessions,
+      COUNT(*) AS interactions,
+      COALESCE((
+        SELECT m2.name
+        FROM interactions i2 INDEXED BY interactions_session_analytics_idx
+        JOIN sessions s2 ON s2.id = i2.session_id
+        LEFT JOIN models m2 ON m2.id = i2.model_id
+        WHERE s2.tool_id = t.id
+        ${subFilter.sql}
+        GROUP BY m2.id
+        ORDER BY SUM(COALESCE(i2.cost, 0)) DESC
+        LIMIT 1
+      ), 'Unknown') AS mostExpensiveModel
+     FROM interactions i INDEXED BY interactions_session_analytics_idx
+     JOIN sessions s ON s.id = i.session_id
+     JOIN tools t ON t.id = s.tool_id
+     JOIN providers p ON p.id = t.provider_id
+     ${filter.sql}
+     GROUP BY t.id, p.id
+     ORDER BY totalTokens DESC`,
+    ...subFilter.params,
+    ...filter.params
+  ).map((row) => ({
+    tool: row.tool,
+    provider: row.provider,
+    totalTokens: number(row.totalTokens),
+    cost: number(row.cost),
+    sessions: number(row.sessions),
+    interactions: number(row.interactions),
+    averageTokensPerSession: row.sessions ? number(row.totalTokens) / number(row.sessions) : 0,
+    averageTokensPerInteraction: row.interactions ? number(row.totalTokens) / number(row.interactions) : 0,
+    outputInputRatio: row.inputTokens ? number(row.outputTokens) / number(row.inputTokens) : 0,
+    cacheEfficiency: row.inputTokens + row.cachedTokens ? number(row.cachedTokens) / (number(row.inputTokens) + number(row.cachedTokens)) : 0,
+    mostExpensiveModel: row.mostExpensiveModel
+  }));
+}
+function getModelRows(filters = {}) {
+  const filter = timestampWhere(filters, "i");
+  const baseRows = rows(
+    `SELECT
+      COALESCE(m.name, 'unknown') AS model,
+      p.name AS provider,
+      p.id AS providerId,
+      m.input_token_price AS inputPrice,
+      m.output_token_price AS outputPrice,
+      COALESCE(SUM(i.total_tokens), 0) AS totalTokens,
+      COALESCE(SUM(i.input_tokens), 0) AS inputTokens,
+      COALESCE(SUM(i.output_tokens), 0) AS outputTokens,
+      COALESCE(SUM(i.cost), 0) AS cost,
+      COUNT(*) AS interactions,
+      COALESCE(AVG(i.output_tokens), 0) AS averageOutputTokens
+     FROM interactions i INDEXED BY interactions_analytics_cover_idx
+     LEFT JOIN models m ON m.id = i.model_id
+     LEFT JOIN providers p ON p.id = m.provider_id
+     ${filter.sql}
+     GROUP BY m.id
+     ORDER BY totalTokens DESC`,
+    ...filter.params
+  );
+  const configuredPrices = rows(
+    `SELECT provider_id AS providerId, name,
+      COALESCE(input_token_price, 999999) + COALESCE(output_token_price, 999999) AS combinedPrice
+     FROM models
+     WHERE input_token_price IS NOT NULL AND output_token_price IS NOT NULL`
+  );
+  return baseRows.map((row) => {
+    const currentPrice = number(row.inputPrice) + number(row.outputPrice);
+    const cheaper = configuredPrices.filter((candidate) => candidate.providerId === row.providerId).filter((candidate) => candidate.name !== row.model).filter((candidate) => !currentPrice || candidate.combinedPrice < currentPrice).sort((a, b) => a.combinedPrice - b.combinedPrice)[0];
+    const tokenEfficiency = row.inputTokens ? number(row.outputTokens) / number(row.inputTokens) : number(row.outputTokens);
+    return {
+      model: row.model,
+      provider: row.provider ?? "Unknown",
+      totalTokens: number(row.totalTokens),
+      inputTokens: number(row.inputTokens),
+      outputTokens: number(row.outputTokens),
+      cost: number(row.cost),
+      interactions: number(row.interactions),
+      averageOutputTokens: number(row.averageOutputTokens),
+      tokenEfficiency,
+      suggestedAlternative: cheaper?.name ?? null,
+      overuseFlag: number(row.cost) > 0 && cheaper && number(row.totalTokens) > 25e3 ? "Cheaper configured alternative exists" : null
+    };
+  });
+}
+function getProjectRows(filters = {}) {
+  const filter = timestampJoinCondition(filters, "i");
+  return rows(
+    `SELECT
+      pr.id,
+      pr.name AS project,
+      pr.path,
+      COALESCE(SUM(i.total_tokens), 0) AS totalTokens,
+      COALESCE(SUM(i.input_tokens), 0) AS inputTokens,
+      COALESCE(SUM(i.output_tokens), 0) AS outputTokens,
+      COALESCE(SUM(i.cost), 0) AS cost,
+      COUNT(DISTINCT s.id) AS sessions,
+      COUNT(*) AS interactions,
+      COALESCE(SUM(CASE WHEN i.token_confidence = 'exact' THEN 1 ELSE 0 END), 0) AS exactTokenInteractions,
+      COALESCE(SUM(CASE WHEN i.token_confidence = 'tokenizer estimate' THEN 1 ELSE 0 END), 0) AS tokenizerEstimateInteractions,
+      COALESCE(SUM(CASE WHEN i.token_confidence IN ('simple estimate', 'high-confidence estimate', 'low-confidence estimate') THEN 1 ELSE 0 END), 0) AS simpleEstimateInteractions,
+      COALESCE(SUM(CASE WHEN i.token_confidence = 'unknown' THEN 1 ELSE 0 END), 0) AS unknownTokenInteractions,
+      COALESCE(SUM(CASE WHEN i.cost IS NOT NULL THEN 1 ELSE 0 END), 0) AS pricedCostInteractions,
+      COALESCE(SUM(CASE WHEN i.cost IS NULL THEN 1 ELSE 0 END), 0) AS unknownCostInteractions,
+      MAX(i.timestamp) AS lastUsedAt
+     FROM projects pr
+     JOIN sessions s ON s.project_id = pr.id
+     JOIN interactions i INDEXED BY interactions_session_analytics_idx ON i.session_id = s.id ${filter.sql}
+     GROUP BY pr.id
+     ORDER BY totalTokens DESC`,
+    ...filter.params
+  ).map((row) => {
+    const confidence = buildDataConfidenceScore({
+      totalInteractions: number(row.interactions),
+      exactTokenInteractions: number(row.exactTokenInteractions),
+      tokenizerEstimateInteractions: number(row.tokenizerEstimateInteractions),
+      simpleEstimateInteractions: number(row.simpleEstimateInteractions),
+      unknownTokenInteractions: number(row.unknownTokenInteractions),
+      pricedCostInteractions: number(row.pricedCostInteractions),
+      unknownCostInteractions: number(row.unknownCostInteractions),
+      parserConfidence: null,
+      scanFreshness: "fresh"
+    });
+    return {
+      id: row.id,
+      project: row.project,
+      path: row.path,
+      totalTokens: number(row.totalTokens),
+      cost: number(row.cost),
+      sessions: number(row.sessions),
+      interactions: number(row.interactions),
+      outputInputRatio: row.inputTokens ? number(row.outputTokens) / number(row.inputTokens) : 0,
+      lastUsedAt: row.lastUsedAt,
+      confidenceScore: confidence.score,
+      confidenceGrade: confidence.grade
+    };
+  });
+}
+function getSessions(filters = {}, detail = "full") {
+  const filter = timestampJoinCondition(filters, "i");
+  const pricingModelSql = detail === "full" ? `(
+        SELECT m2.name
+        FROM interactions i2 INDEXED BY interactions_session_analytics_idx
+        LEFT JOIN models m2 ON m2.id = i2.model_id
+        WHERE i2.session_id = s.id
+        GROUP BY m2.id
+        ORDER BY SUM(i2.total_tokens) DESC
+        LIMIT 1
+      )` : "NULL";
+  const parserColumns = detail === "full" ? `sf.parser AS parser,
+      sf.status AS parserStatus,
+      sf.raw_metadata AS parserRawMetadata,` : `NULL AS parser,
+      NULL AS parserStatus,
+      NULL AS parserRawMetadata,`;
+  const parserJoin = detail === "full" ? `LEFT JOIN scan_files sf ON sf.id = (
+       SELECT sf2.id
+       FROM scan_files sf2
+       JOIN scan_runs sr2 ON sr2.id = sf2.scan_run_id
+       WHERE sf2.path = s.source_file
+       ORDER BY sr2.started_at DESC
+       LIMIT 1
+     )` : "";
+  return rows(
+    `SELECT
+      s.id,
+      s.started_at AS startedAt,
+      s.ended_at AS endedAt,
+      s.title,
+      s.source_file AS sourceFile,
+      t.name AS tool,
+      provider.name AS provider,
+      pr.name AS project,
+      pr.path AS projectPath,
+      COALESCE(group_concat(DISTINCT m.name), 'unknown') AS models,
+      ${pricingModelSql} AS pricingModel,
+      COALESCE(SUM(i.total_tokens), 0) AS totalTokens,
+      COALESCE(SUM(i.input_tokens), 0) AS inputTokens,
+      COALESCE(SUM(i.output_tokens), 0) AS outputTokens,
+      COALESCE(SUM(i.cache_read_tokens + i.cache_write_tokens), 0) AS cachedTokens,
+      COALESCE(SUM(i.reasoning_tokens), 0) AS reasoningTokens,
+      SUM(i.cost) AS cost,
+      MAX(i.cost_estimated) AS costEstimated,
+      MAX(i.estimated_tokens) AS estimatedTokens,
+      CASE
+        WHEN SUM(CASE WHEN i.token_confidence = 'unknown' THEN 1 ELSE 0 END) > 0 THEN 'unknown'
+        WHEN SUM(CASE WHEN i.token_confidence = 'simple estimate' THEN 1 ELSE 0 END) > 0 THEN 'simple estimate'
+        WHEN SUM(CASE WHEN i.token_confidence = 'low-confidence estimate' THEN 1 ELSE 0 END) > 0 THEN 'low-confidence estimate'
+        WHEN SUM(CASE WHEN i.token_confidence = 'tokenizer estimate' THEN 1 ELSE 0 END) > 0 THEN 'tokenizer estimate'
+        WHEN SUM(CASE WHEN i.token_confidence = 'high-confidence estimate' THEN 1 ELSE 0 END) > 0 THEN 'high-confidence estimate'
+        ELSE 'exact'
+      END AS tokenConfidence,
+      COALESCE(SUM(CASE WHEN i.token_confidence = 'exact' THEN 1 ELSE 0 END), 0) AS exactTokenInteractions,
+      COALESCE(SUM(CASE WHEN i.token_confidence = 'tokenizer estimate' THEN 1 ELSE 0 END), 0) AS tokenizerEstimateInteractions,
+      COALESCE(SUM(CASE WHEN i.token_confidence IN ('simple estimate', 'high-confidence estimate', 'low-confidence estimate') THEN 1 ELSE 0 END), 0) AS simpleEstimateInteractions,
+      COALESCE(SUM(CASE WHEN i.token_confidence = 'unknown' THEN 1 ELSE 0 END), 0) AS unknownTokenInteractions,
+      COALESCE(SUM(CASE WHEN i.cost IS NOT NULL THEN 1 ELSE 0 END), 0) AS pricedCostInteractions,
+      COALESCE(SUM(CASE WHEN i.cost IS NULL THEN 1 ELSE 0 END), 0) AS unknownCostInteractions,
+      ${parserColumns}
+      COUNT(*) AS interactionCount,
+      CASE WHEN s.started_at IS NOT NULL AND s.ended_at IS NOT NULL THEN s.ended_at - s.started_at ELSE NULL END AS durationMs
+     FROM sessions s
+     JOIN tools t ON t.id = s.tool_id
+     JOIN providers provider ON provider.id = t.provider_id
+     LEFT JOIN projects pr ON pr.id = s.project_id
+     JOIN interactions i INDEXED BY interactions_session_analytics_idx ON i.session_id = s.id ${filter.sql}
+     LEFT JOIN models m ON m.id = i.model_id
+     ${parserJoin}
+     GROUP BY s.id
+     ORDER BY COALESCE(s.started_at, 0) DESC
+     LIMIT 1000`,
+    ...filter.params
+  ).map((row) => {
+    const parserMetadata = parseJson(row.parserRawMetadata, {});
+    const pricingModel = row.pricingModel && row.pricingModel !== "unknown" ? row.pricingModel : null;
+    const parserConfidence = numberMetadata(parserMetadata, "confidence");
+    const confidence = buildDataConfidenceScore({
+      totalInteractions: number(row.interactionCount),
+      exactTokenInteractions: number(row.exactTokenInteractions),
+      tokenizerEstimateInteractions: number(row.tokenizerEstimateInteractions),
+      simpleEstimateInteractions: number(row.simpleEstimateInteractions),
+      unknownTokenInteractions: number(row.unknownTokenInteractions),
+      pricedCostInteractions: number(row.pricedCostInteractions),
+      unknownCostInteractions: number(row.unknownCostInteractions),
+      parserConfidence,
+      scanFreshness: "fresh"
+    });
+    return {
+      ...row,
+      totalTokens: number(row.totalTokens),
+      inputTokens: number(row.inputTokens),
+      outputTokens: number(row.outputTokens),
+      cachedTokens: number(row.cachedTokens),
+      reasoningTokens: number(row.reasoningTokens),
+      cost: row.cost == null ? null : number(row.cost),
+      costEstimated: Boolean(row.costEstimated),
+      estimatedTokens: Boolean(row.estimatedTokens),
+      parserConfidence,
+      parserReason: stringMetadata(parserMetadata, "reason"),
+      sourceHref: withQuery("/sessions", { source: row.sourceFile }),
+      parserHref: withQuery("/parser-debug", { source: row.sourceFile }),
+      pricingHref: pricingModel ? withQuery("/pricing", { model: pricingModel }) : null,
+      interactionCount: number(row.interactionCount),
+      confidenceScore: confidence.score,
+      confidenceGrade: confidence.grade
+    };
+  });
+}
+
+// src/lib/model-aliases.ts
+function unique(values) {
+  return Array.from(new Set(values.filter(Boolean)));
+}
+function addClaudeCandidates(name, candidates) {
+  const lower = name.toLowerCase();
+  const datedFamilyFirst = lower.match(/^(claude)-(opus|sonnet|haiku)-(\d+)-(\d+)-\d{8}$/);
+  if (datedFamilyFirst) {
+    const [, prefix, family, major, minor] = datedFamilyFirst;
+    candidates.push(`${prefix}-${family}-${major}-${minor}`);
+    candidates.push(`${prefix}-${family}-${major}.${minor}`);
+  }
+  const datedVersionFirst = lower.match(/^(claude)-(\d+)-(\d+)-(opus|sonnet|haiku)-\d{8}$/);
+  if (datedVersionFirst) {
+    const [, prefix, major, minor, family] = datedVersionFirst;
+    candidates.push(`${prefix}-${family}-${major}-${minor}`);
+    candidates.push(`${prefix}-${family}-${major}.${minor}`);
+  }
+  const legacyDated = lower.match(/^(claude)-(\d+)-(opus|sonnet|haiku)-\d{8}$/);
+  if (legacyDated) {
+    const [, prefix, major, family] = legacyDated;
+    candidates.push(`${prefix}-${family}-${major}`);
+  }
+  const strippedDate = lower.replace(/-\d{8}$/, "");
+  if (strippedDate !== lower) candidates.push(strippedDate);
+  const familyHyphenVersion = strippedDate.match(/^(claude)-(opus|sonnet|haiku)-(\d+)-(\d+)$/);
+  if (familyHyphenVersion) {
+    const [, prefix, family, major, minor] = familyHyphenVersion;
+    candidates.push(`${prefix}-${family}-${major}.${minor}`);
+  }
+}
+function addProviderPrefixCandidates(name, candidates) {
+  const withoutProvider = name.replace(/^[a-z0-9_.-]+\//i, "");
+  if (withoutProvider !== name) candidates.push(withoutProvider);
+}
+function addSnapshotDateCandidates(name, candidates) {
+  const withoutProvider = name.replace(/^[a-z0-9_.-]+\//i, "");
+  const lower = withoutProvider.toLowerCase();
+  const stripped = lower.replace(/[-_.]\d{4}[-_.]?\d{2}[-_.]?\d{2}$/, "");
+  if (stripped !== lower) candidates.push(stripped);
+}
+function modelNameCandidates(modelName) {
+  const trimmed = modelName?.trim();
+  if (!trimmed) return ["unknown"];
+  const candidates = [trimmed];
+  addProviderPrefixCandidates(trimmed, candidates);
+  addClaudeCandidates(trimmed, candidates);
+  addSnapshotDateCandidates(trimmed, candidates);
+  return unique(candidates);
+}
+
+// src/lib/analytics/repair.ts
+function getUnknownCostQueue(filters = {}) {
+  const filter = timestampJoinCondition(filters, "i");
+  return rows(
+    `SELECT
+      CASE
+        WHEN lower(COALESCE(m.name, 'unknown')) = 'unknown' THEN 'missing model'
+        WHEN COALESCE(i.total_tokens, 0) <= 0 THEN 'missing token count'
+        WHEN lower(COALESCE(m.name, 'unknown')) <> 'unknown'
+          AND COALESCE(i.total_tokens, 0) > 0
+          AND (m.input_token_price IS NULL OR m.output_token_price IS NULL)
+          THEN 'missing pricing'
+        ELSE 'other'
+      END AS cause,
+      COALESCE(m.name, 'unknown') AS model,
+      COALESCE(p.name, 'Unknown') AS provider,
+      t.name AS tool,
+      s.source_file AS sourceFile,
+      COUNT(*) AS interactions,
+      COUNT(DISTINCT s.id) AS sessions,
+      COALESCE(SUM(i.total_tokens), 0) AS totalTokens,
+      '' AS repairHref,
+      '' AS sourceHref,
+      '' AS parserHref,
+      '' AS pricingHref
+     FROM interactions i INDEXED BY interactions_session_analytics_idx
+     JOIN sessions s ON s.id = i.session_id ${filter.sql}
+     JOIN tools t ON t.id = s.tool_id
+     LEFT JOIN models m ON m.id = i.model_id
+     LEFT JOIN providers p ON p.id = m.provider_id
+     WHERE i.cost IS NULL
+     GROUP BY cause, m.id, t.id, s.source_file
+     ORDER BY
+      CASE cause
+        WHEN 'missing pricing' THEN 0
+        WHEN 'missing model' THEN 1
+        WHEN 'missing token count' THEN 2
+        ELSE 3
+      END,
+      interactions DESC,
+      totalTokens DESC
+     LIMIT 20`,
+    ...filter.params
+  ).map((row) => {
+    const parserHref = withQuery("/parser-debug", { source: row.sourceFile });
+    const sourceHref = withQuery("/sessions", { source: row.sourceFile });
+    const pricingHref = row.cause === "missing pricing" && row.model !== "unknown" ? withQuery("/pricing", { model: row.model }) : null;
+    return {
+      ...row,
+      repairHref: pricingHref ?? parserHref,
+      sourceHref,
+      parserHref,
+      pricingHref,
+      interactions: number(row.interactions),
+      sessions: number(row.sessions),
+      totalTokens: number(row.totalTokens)
+    };
+  });
+}
+function getModelAliasSuggestions(filters = {}) {
+  const filter = timestampJoinCondition(filters, "i");
+  const pricedRows = rows(
+    `SELECT provider_id AS providerId, name AS model
+     FROM models
+     WHERE input_token_price IS NOT NULL AND output_token_price IS NOT NULL`
+  );
+  const pricedByProvider = /* @__PURE__ */ new Map();
+  pricedRows.forEach((row) => {
+    const bucket = pricedByProvider.get(row.providerId) ?? /* @__PURE__ */ new Set();
+    bucket.add(row.model.toLowerCase());
+    pricedByProvider.set(row.providerId, bucket);
+  });
+  const pricedName = /* @__PURE__ */ new Map();
+  pricedRows.forEach((row) => {
+    pricedName.set(`${row.providerId}:${row.model.toLowerCase()}`, row.model);
+  });
+  const suggestions = rows(
+    `SELECT
+      COALESCE(m.name, 'unknown') AS model,
+      COALESCE(p.id, tool_provider.id) AS providerId,
+      COALESCE(p.name, tool_provider.name) AS provider,
+      t.name AS tool,
+      MIN(s.source_file) AS sourceFile,
+      COUNT(*) AS interactions,
+      COALESCE(SUM(i.total_tokens), 0) AS totalTokens
+     FROM interactions i INDEXED BY interactions_session_analytics_idx
+     JOIN sessions s ON s.id = i.session_id ${filter.sql}
+     JOIN tools t ON t.id = s.tool_id
+     JOIN providers tool_provider ON tool_provider.id = t.provider_id
+     LEFT JOIN models m ON m.id = i.model_id
+     LEFT JOIN providers p ON p.id = m.provider_id
+     WHERE i.cost IS NULL
+     GROUP BY model, providerId, t.id
+     ORDER BY interactions DESC, totalTokens DESC
+     LIMIT 40`,
+    ...filter.params
+  ).map((row) => {
+    const baseRow = {
+      model: row.model,
+      provider: row.provider,
+      tool: row.tool,
+      sourceFile: row.sourceFile
+    };
+    const normalizedModel = row.model.trim().toLowerCase();
+    const parserHref = withQuery("/parser-debug", { source: row.sourceFile });
+    const repairHref = withQuery("/pricing", { model: row.model });
+    const candidates = modelNameCandidates(row.model).slice(1);
+    const pricedSet = pricedByProvider.get(row.providerId) ?? /* @__PURE__ */ new Set();
+    const suggestedModel = candidates.map((candidate) => candidate.toLowerCase()).find((candidate) => pricedSet.has(candidate)) ?? null;
+    const suggestedDisplay = suggestedModel ? pricedName.get(`${row.providerId}:${suggestedModel}`) ?? suggestedModel : null;
+    if (normalizedModel === "unknown") {
+      return {
+        ...baseRow,
+        interactions: number(row.interactions),
+        totalTokens: number(row.totalTokens),
+        suggestedModel: null,
+        confidence: "low",
+        reason: "The parser did not extract a model name. Inspect the source metadata before adding pricing.",
+        repairHref: parserHref,
+        parserHref
+      };
+    }
+    if (normalizedModel === "<synthetic>" || normalizedModel === "synthetic") {
+      return {
+        ...baseRow,
+        interactions: number(row.interactions),
+        totalTokens: number(row.totalTokens),
+        suggestedModel: null,
+        confidence: "medium",
+        reason: "Synthetic rows should inherit the real transcript model only after parser review.",
+        repairHref: parserHref,
+        parserHref
+      };
+    }
+    if (suggestedDisplay) {
+      return {
+        ...baseRow,
+        interactions: number(row.interactions),
+        totalTokens: number(row.totalTokens),
+        suggestedModel: suggestedDisplay,
+        confidence: "high",
+        reason: "This observed model name matches a priced base model after removing a dated provider suffix.",
+        repairHref,
+        parserHref
+      };
+    }
+    return {
+      ...baseRow,
+      interactions: number(row.interactions),
+      totalTokens: number(row.totalTokens),
+      suggestedModel: null,
+      confidence: "low",
+      reason: "No priced alias candidate exists yet. Add an explicit price row or verify the model name from parser evidence.",
+      repairHref,
+      parserHref
+    };
+  });
+  const confidenceRank = { high: 0, medium: 1, low: 2 };
+  return suggestions.sort((a, b) => confidenceRank[a.confidence] - confidenceRank[b.confidence] || b.totalTokens - a.totalTokens).slice(0, 8);
+}
+
+// src/lib/scan-health-rules.ts
+function incrementCount(target, key, amount = 1) {
+  target[key] = (target[key] ?? 0) + amount;
+}
+function uniqueMessages(messages) {
+  return Array.from(new Set(messages.map((message) => message.trim()).filter(Boolean))).slice(0, 6);
+}
+function groupScanNotes(scanRun, files) {
+  const groups = /* @__PURE__ */ new Map();
+  function add(severity, message, example) {
+    const trimmed = message.trim();
+    if (!trimmed) return;
+    const key = `${severity}:${trimmed}`;
+    const existing = groups.get(key);
+    if (existing) {
+      existing.count += 1;
+      if (example && !existing.examples.includes(example) && existing.examples.length < 3) {
+        existing.examples.push(example);
+      }
+      return;
+    }
+    groups.set(key, {
+      severity,
+      message: trimmed,
+      count: 1,
+      examples: example ? [example] : []
+    });
+  }
+  for (const error of scanRun?.errors ?? []) add("error", error);
+  for (const warning of scanRun?.warnings ?? []) add("warning", warning);
+  for (const file of files) {
+    const fileErrorSeverity = file.status === "skipped_unknown" ? "warning" : "error";
+    for (const error of file.errors) add(fileErrorSeverity, error, file.path);
+    for (const warning of file.warnings) add("warning", warning, file.path);
+  }
+  return Array.from(groups.values()).sort((a, b) => {
+    if (a.severity !== b.severity) return a.severity === "error" ? -1 : 1;
+    return b.count - a.count;
+  }).slice(0, 6);
+}
+var scanHealthStaleAfterMs = 7 * 24 * 60 * 60 * 1e3;
+function isSuccessfulScanRun(scanRun) {
+  return scanRun.completedAt != null && scanRun.recordsImported > 0 && scanRun.errors.length === 0;
+}
+function buildScanFreshness({
+  latestRun,
+  lastSuccessfulRun,
+  now
+}) {
+  if (!latestRun) {
+    return {
+      state: "no-scan",
+      lastSuccessfulCompletedAt: null,
+      staleAfterMs: scanHealthStaleAfterMs,
+      description: "No local scan has run yet."
+    };
+  }
+  if (!lastSuccessfulRun?.completedAt) {
+    return {
+      state: "no-successful-scan",
+      lastSuccessfulCompletedAt: null,
+      staleAfterMs: scanHealthStaleAfterMs,
+      description: "No completed scan has imported usage records yet."
+    };
+  }
+  if (now - lastSuccessfulRun.completedAt > scanHealthStaleAfterMs) {
+    return {
+      state: "stale",
+      lastSuccessfulCompletedAt: lastSuccessfulRun.completedAt,
+      staleAfterMs: scanHealthStaleAfterMs,
+      description: "The last successful import is more than seven days old."
+    };
+  }
+  return {
+    state: "fresh",
+    lastSuccessfulCompletedAt: lastSuccessfulRun.completedAt,
+    staleAfterMs: scanHealthStaleAfterMs,
+    description: "Recent scan history includes a successful import."
+  };
+}
+function action(label, href, reason, tone = "default") {
+  return { label, href, reason, tone };
+}
+function plural(count, singular, pluralValue = `${singular}s`) {
+  return `${count} ${count === 1 ? singular : pluralValue}`;
+}
+function joinHealthParts(parts) {
+  if (parts.length <= 1) return parts[0] ?? "";
+  return `${parts.slice(0, -1).join(", ")} and ${parts[parts.length - 1]}`;
+}
+function buildScanHealthStatus({
+  latestRun,
+  stats,
+  confidence
+}) {
+  if (!latestRun) {
+    return {
+      headline: "No scans yet",
+      description: "Run a local scan to discover Claude Code, Codex CLI, and generic AI CLI artifacts.",
+      tone: "secondary"
+    };
+  }
+  if (stats.failed > 0 || stats.importedWithErrors > 0 || stats.hardErrorCount > 0) {
+    return {
+      headline: "Scan needs attention",
+      description: `${joinHealthParts([
+        `${plural(stats.failed + stats.importedWithErrors, "file")} failed or imported with errors`,
+        stats.unsupported > 0 ? `${plural(stats.unsupported, "file")} need parser review` : ""
+      ].filter(Boolean))} in the latest scan.`,
+      tone: "destructive"
+    };
+  }
+  if (stats.unsupported > 0 || stats.warningCount > 0 || confidence.unknownCostInteractions > 0 || confidence.unknownTokenInteractions > 0) {
+    return {
+      headline: "Review recommended",
+      description: "The latest scan completed, but some files, prices, or token confidence need review.",
+      tone: "warning"
+    };
+  }
+  return {
+    headline: "Scan health looks good",
+    description: stats.duplicates > 0 ? "The latest scan completed and previously imported duplicate files were safely skipped." : "The latest scan completed without parser errors, unsupported files, or unknown model rates.",
+    tone: "success"
+  };
+}
+function buildScanHealthActions({
+  latestRun,
+  stats,
+  confidence,
+  freshness,
+  supplyChain
+}) {
+  const actions = [];
+  const supplyChainStatus = supplyChain ?? {
+    status: "not-run",
+    checkedAt: null,
+    findings: 0,
+    summary: "Supply-chain IOC check has not run in this dashboard process."
+  };
+  if (supplyChainStatus.status === "failed") {
+    actions.push(action("Review supply-chain check", "/diagnostics#supply-chain", supplyChainStatus.summary, "destructive"));
+  }
+  if (!latestRun) {
+    actions.push(action("Run first scan", "/settings#scan-controls", "Discover local AI CLI usage files."));
+  }
+  if (stats.failed > 0 || stats.importedWithErrors > 0 || stats.hardErrorCount > 0) {
+    actions.push(action("Review parser failures", "/parser-debug", "Parser errors can hide usage data.", "destructive"));
+  }
+  if (stats.unsupported > 0) {
+    actions.push(action("Inspect unsupported files", "/discovery", "Unsupported files show where adapters need improvement.", "warning"));
+  }
+  if (confidence.unknownCostInteractions > 0) {
+    actions.push(action("Set model rate", "/pricing", "Unknown costs make cost totals incomplete.", "warning"));
+  }
+  if (confidence.unknownTokenInteractions > 0 || confidence.estimatedTokenInteractions > 0) {
+    actions.push(action("Review token confidence", "/parser-debug", "Estimated or unknown token counts should stay visible.", "warning"));
+  }
+  if (freshness.state === "stale") {
+    actions.push(action("Run a fresh scan", "/settings#scan-controls", freshness.description, "warning"));
+  }
+  if (latestRun && stats.imported === 0 && stats.duplicates === 0 && stats.unsupported === 0 && stats.failed === 0) {
+    actions.push(action("Add custom folders", "/settings#custom-folders", "No files were imported by the latest scan.", "warning"));
+  }
+  if (latestRun) {
+    actions.push(action("Export pack", "/api/export?type=scan-files", "Share parser metadata without raw prompts."));
+  }
+  return {
+    supplyChainStatus,
+    actions
+  };
+}
+
+// src/lib/scan-health.ts
+function buildScanHealth({
+  scanRuns: scanRuns2,
+  scanFiles: scanFiles2,
+  confidence,
+  supplyChain,
+  now = Date.now()
+}) {
+  const latestRun = scanRuns2[0] ?? null;
+  const lastSuccessfulRun = scanRuns2.find(isSuccessfulScanRun) ?? null;
+  const freshness = buildScanFreshness({ latestRun, lastSuccessfulRun, now });
+  const latestFiles = latestRun ? scanFiles2.filter((file) => file.scanRunId === latestRun.id) : [];
+  const latestStatusCounts = {};
+  const parserCounts = {};
+  for (const file of latestFiles) {
+    incrementCount(latestStatusCounts, file.status);
+    incrementCount(parserCounts, file.parser ?? "No parser");
+  }
+  const latestWarnings = uniqueMessages([
+    ...latestRun?.warnings ?? [],
+    ...latestFiles.flatMap((file) => file.warnings.map((warning) => `${file.path}: ${warning}`))
+  ]);
+  const latestErrors = uniqueMessages([
+    ...latestRun?.errors ?? [],
+    ...latestFiles.flatMap((file) => file.errors.map((error) => `${file.path}: ${error}`))
+  ]);
+  const latestNoteGroups = groupScanNotes(latestRun, latestFiles);
+  const stats = {
+    unsupported: latestStatusCounts.skipped_unknown ?? 0,
+    failed: latestStatusCounts.failed ?? 0,
+    importedWithErrors: latestStatusCounts.imported_with_errors ?? 0,
+    duplicates: latestStatusCounts.skipped_duplicate ?? 0,
+    imported: latestStatusCounts.imported ?? 0,
+    warningCount: latestWarnings.length,
+    hardErrorCount: (latestRun?.errors.length ?? 0) + latestFiles.filter((file) => file.status === "failed" || file.status === "imported_with_errors").reduce((total, file) => total + file.errors.length, 0)
+  };
+  const tokenCoverage = {
+    exact: confidence.exactTokenInteractions ?? 0,
+    tokenizerEstimate: confidence.tokenizerEstimateInteractions ?? 0,
+    simpleEstimate: confidence.simpleEstimateInteractions ?? 0,
+    highConfidenceEstimate: confidence.highConfidenceTokenInteractions ?? 0,
+    lowConfidenceEstimate: confidence.lowConfidenceTokenInteractions ?? 0,
+    unknown: confidence.unknownTokenInteractions ?? 0,
+    estimated: confidence.estimatedTokenInteractions ?? 0,
+    total: confidence.interactions ?? 0
+  };
+  const costCoverage = {
+    priced: confidence.exactCostInteractions + confidence.estimatedCostInteractions,
+    exact: confidence.exactCostInteractions,
+    estimated: confidence.estimatedCostInteractions,
+    unknown: confidence.unknownCostInteractions,
+    unknownCauses: confidence.unknownCostCauses,
+    total: confidence.interactions
+  };
+  const { headline, description, tone } = buildScanHealthStatus({ latestRun, stats, confidence });
+  const { supplyChainStatus, actions } = buildScanHealthActions({
+    latestRun,
+    stats,
+    confidence,
+    freshness,
+    supplyChain
+  });
+  return {
+    latestRun,
+    lastSuccessfulRun,
+    latestFiles,
+    headline,
+    description,
+    tone,
+    latestStatusCounts,
+    parserCounts,
+    latestWarnings,
+    latestErrors,
+    latestNoteGroups,
+    freshness,
+    tokenCoverage,
+    costCoverage,
+    supplyChain: supplyChainStatus,
+    actions
+  };
+}
+
+// src/lib/analytics-timing.ts
+var DEFAULT_ANALYTICS_QUERY_WARN_MS = 500;
+var MAX_SAMPLES = 50;
+var samples = [];
+function configuredThresholdMs() {
+  const value = Number(process.env.TOKENTRACE_ANALYTICS_QUERY_WARN_MS);
+  if (Number.isFinite(value) && value > 0) return value;
+  return DEFAULT_ANALYTICS_QUERY_WARN_MS;
+}
+function timingEnabled() {
+  return process.env.TOKENTRACE_ANALYTICS_TIMING === "1" || process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test";
+}
+function nowMs() {
+  return globalThis.performance?.now() ?? Date.now();
+}
+function recordAnalyticsQueryTiming(label, durationMs, thresholdMs = configuredThresholdMs()) {
+  if (!timingEnabled()) return;
+  if (durationMs < thresholdMs) return;
+  samples.push({
+    label,
+    durationMs: Math.round(durationMs),
+    thresholdMs,
+    recordedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  if (samples.length > MAX_SAMPLES) {
+    samples.splice(0, samples.length - MAX_SAMPLES);
+  }
+}
+function timeAnalyticsQuery(label, callback) {
+  if (!timingEnabled()) return callback();
+  const startedAt = nowMs();
+  try {
+    return callback();
+  } finally {
+    recordAnalyticsQueryTiming(label, nowMs() - startedAt);
+  }
+}
+
+// src/lib/analytics/scan-trust.ts
+function getScanRunRows(limit) {
+  return rows(
+    `SELECT id, started_at AS startedAt, completed_at AS completedAt,
+      files_scanned AS filesScanned, records_imported AS recordsImported, warnings, errors
+     FROM scan_runs
+     ORDER BY started_at DESC, completed_at DESC, id DESC
+     LIMIT ?`,
+    limit
+  ).map((row) => ({
+    ...row,
+    warnings: parseJson(row.warnings, []),
+    errors: parseJson(row.errors, [])
+  }));
+}
+function getScanFileRows(limit) {
+  const limitSql = limit == null ? "" : "LIMIT ?";
+  const params = limit == null ? [] : [limit];
+  return rows(
+    `SELECT sf.id, sf.scan_run_id AS scanRunId, sf.path, sf.modified_time AS modifiedTime,
+      sf.size_bytes AS sizeBytes, sf.file_hash AS fileHash, sf.parser, sf.status,
+      sf.records_imported AS recordsImported, sf.warnings, sf.errors, sf.raw_metadata AS rawMetadata,
+      sr.started_at AS scanStartedAt
+     FROM scan_files sf
+     JOIN scan_runs sr ON sr.id = sf.scan_run_id
+     ORDER BY sr.started_at DESC, sr.completed_at DESC, sr.id DESC, sf.path ASC
+     ${limitSql}`,
+    ...params
+  ).map((row) => ({
+    ...row,
+    warnings: parseJson(row.warnings, []),
+    errors: parseJson(row.errors, []),
+    rawMetadata: parseJson(row.rawMetadata, {})
+  }));
+}
+function getScanFileRowsForRunIds(scanRunIds) {
+  if (!scanRunIds.length) return [];
+  const placeholders = scanRunIds.map(() => "?").join(", ");
+  return rows(
+    `SELECT sf.id, sf.scan_run_id AS scanRunId, sf.path, sf.modified_time AS modifiedTime,
+      sf.size_bytes AS sizeBytes, sf.file_hash AS fileHash, sf.parser, sf.status,
+      sf.records_imported AS recordsImported, sf.warnings, sf.errors, sf.raw_metadata AS rawMetadata,
+      sr.started_at AS scanStartedAt
+     FROM scan_files sf
+     JOIN scan_runs sr ON sr.id = sf.scan_run_id
+     WHERE sf.scan_run_id IN (${placeholders})
+     ORDER BY sr.started_at DESC, sr.completed_at DESC, sr.id DESC, sf.path ASC`,
+    ...scanRunIds
+  ).map((row) => ({
+    ...row,
+    warnings: parseJson(row.warnings, []),
+    errors: parseJson(row.errors, []),
+    rawMetadata: parseJson(row.rawMetadata, {})
+  }));
+}
+function getScanConfidenceSummary(filters = {}) {
+  const filter = timestampWhere(filters, "i");
+  const unknownFilter = timestampJoinCondition(filters, "i");
+  const row = sqlite.prepare(
+    `SELECT
+        COUNT(*) AS interactions,
+        COALESCE(SUM(CASE WHEN token_confidence = 'exact' THEN 1 ELSE 0 END), 0) AS exactTokenInteractions,
+        COALESCE(SUM(CASE WHEN token_confidence = 'tokenizer estimate' THEN 1 ELSE 0 END), 0) AS tokenizerEstimateInteractions,
+        COALESCE(SUM(CASE WHEN token_confidence = 'simple estimate' THEN 1 ELSE 0 END), 0) AS simpleEstimateInteractions,
+        COALESCE(SUM(CASE WHEN token_confidence = 'high-confidence estimate' THEN 1 ELSE 0 END), 0) AS highConfidenceTokenInteractions,
+        COALESCE(SUM(CASE WHEN token_confidence = 'low-confidence estimate' THEN 1 ELSE 0 END), 0) AS lowConfidenceTokenInteractions,
+        COALESCE(SUM(CASE WHEN token_confidence = 'unknown' THEN 1 ELSE 0 END), 0) AS unknownTokenInteractions,
+        COALESCE(SUM(CASE WHEN estimated_tokens = 1 THEN 1 ELSE 0 END), 0) AS estimatedTokenInteractions,
+        COALESCE(SUM(CASE WHEN cost IS NOT NULL AND cost_estimated = 0 THEN 1 ELSE 0 END), 0) AS exactCostInteractions,
+        COALESCE(SUM(CASE WHEN cost IS NOT NULL AND cost_estimated = 1 THEN 1 ELSE 0 END), 0) AS estimatedCostInteractions,
+        COALESCE(SUM(CASE WHEN cost IS NULL THEN 1 ELSE 0 END), 0) AS unknownCostInteractions
+       FROM interactions i INDEXED BY interactions_analytics_cover_idx
+       ${filter.sql}`
+  ).get(...filter.params);
+  const unknownCostCauses = sqlite.prepare(
+    `WITH unknown_costs AS (
+        SELECT
+          CASE
+            WHEN lower(COALESCE(m.name, 'unknown')) = 'unknown' THEN 'missingModelName'
+            WHEN COALESCE(i.total_tokens, 0) <= 0 THEN 'missingTokenCount'
+            WHEN lower(COALESCE(m.name, 'unknown')) <> 'unknown'
+              AND COALESCE(i.total_tokens, 0) > 0
+              AND (m.input_token_price IS NULL OR m.output_token_price IS NULL)
+              THEN 'missingPricing'
+            ELSE 'other'
+          END AS cause
+        FROM interactions i INDEXED BY interactions_analytics_cover_idx
+        LEFT JOIN models m ON m.id = i.model_id
+        WHERE i.cost IS NULL
+        ${unknownFilter.sql}
+      )
+      SELECT
+        COALESCE(SUM(CASE WHEN cause = 'missingModelName' THEN 1 ELSE 0 END), 0) AS missingModelName,
+        COALESCE(SUM(CASE WHEN cause = 'missingTokenCount' THEN 1 ELSE 0 END), 0) AS missingTokenCount,
+        COALESCE(SUM(CASE WHEN cause = 'missingPricing' THEN 1 ELSE 0 END), 0) AS missingPricing,
+        COALESCE(SUM(CASE WHEN cause = 'other' THEN 1 ELSE 0 END), 0) AS other
+       FROM unknown_costs`
+  ).get(...unknownFilter.params);
+  return {
+    interactions: number(row.interactions),
+    exactTokenInteractions: number(row.exactTokenInteractions),
+    tokenizerEstimateInteractions: number(row.tokenizerEstimateInteractions),
+    simpleEstimateInteractions: number(row.simpleEstimateInteractions),
+    highConfidenceTokenInteractions: number(row.highConfidenceTokenInteractions),
+    lowConfidenceTokenInteractions: number(row.lowConfidenceTokenInteractions),
+    unknownTokenInteractions: number(row.unknownTokenInteractions),
+    estimatedTokenInteractions: number(row.estimatedTokenInteractions),
+    exactCostInteractions: number(row.exactCostInteractions),
+    estimatedCostInteractions: number(row.estimatedCostInteractions),
+    unknownCostInteractions: number(row.unknownCostInteractions),
+    unknownCostCauses: {
+      missingModelName: number(unknownCostCauses.missingModelName),
+      missingPricing: number(unknownCostCauses.missingPricing),
+      missingTokenCount: number(unknownCostCauses.missingTokenCount),
+      other: number(unknownCostCauses.other)
+    }
+  };
+}
+function getPricedModelCount() {
+  const row = sqlite.prepare(
+    `SELECT COUNT(*) AS count
+       FROM models
+       WHERE input_token_price IS NOT NULL
+         AND output_token_price IS NOT NULL`
+  ).get();
+  return number(row.count);
+}
+function getScanFileRowsForScope(scanRuns2, scope) {
+  if (scope === "all") return getScanFileRows(null);
+  if (scope === "none") return [];
+  const runIds = scanRuns2.slice(0, scope === "latest" ? 1 : 2).map((scanRun) => scanRun.id);
+  return getScanFileRowsForRunIds(runIds);
+}
+function getScanTrustData(filters = {}, options = {}) {
+  return timeAnalyticsQuery("analytics.scanTrust", () => {
+    const scanRuns2 = getScanRunRows(50);
+    const scanFiles2 = getScanFileRowsForScope(scanRuns2, options.scanFileScope ?? "all");
+    const confidence = getScanConfidenceSummary(filters);
+    return {
+      scanRuns: scanRuns2,
+      scanFiles: scanFiles2,
+      confidence,
+      pricedModelCount: getPricedModelCount(),
+      health: buildScanHealth({
+        scanRuns: scanRuns2,
+        scanFiles: scanFiles2,
+        confidence
+      })
+    };
+  });
+}
+
+// src/lib/analytics/insights.ts
+function getLatestScanRecommendationStats() {
+  const latest = sqlite.prepare(
+    `SELECT id, records_imported AS recordsImported
+       FROM scan_runs
+       ORDER BY started_at DESC, completed_at DESC, id DESC
+       LIMIT 1`
+  ).get();
+  if (!latest) {
+    return {
+      latestRecordsImported: 0,
+      duplicateFiles: 0,
+      parserReviewFiles: 0,
+      ignoredFiles: 0
+    };
+  }
+  const counts = rows(
+    `SELECT status, COUNT(*) AS count
+     FROM scan_files
+     WHERE scan_run_id = ?
+     GROUP BY status`,
+    latest.id
+  ).reduce((summary, row) => {
+    summary[row.status] = number(row.count);
+    return summary;
+  }, {});
+  return {
+    latestRecordsImported: number(latest.recordsImported),
+    duplicateFiles: counts.skipped_duplicate ?? 0,
+    parserReviewFiles: (counts.skipped_unknown ?? 0) + (counts.failed ?? 0) + (counts.imported_with_errors ?? 0),
+    ignoredFiles: counts.ignored_non_usage ?? 0
+  };
+}
+function buildInsights(data) {
+  const insights = [];
+  const totalCost = data.summary.totalCost;
+  const topSessions = [...data.sessions].sort((a, b) => b.totalTokens - a.totalTokens);
+  const topTenTokens = topSessions.slice(0, Math.max(1, Math.ceil(topSessions.length * 0.1))).reduce(
+    (sum, session) => sum + session.totalTokens,
+    0
+  );
+  if (data.summary.totalTokens > 0 && topTenTokens / data.summary.totalTokens > 0.5) {
+    insights.push({
+      id: "concentrated-usage",
+      severity: "high",
+      problem: "A small number of sessions account for most token usage.",
+      evidence: `Top sessions represent ${Math.round(topTenTokens / data.summary.totalTokens * 100)}% of all tokens.`,
+      savingOpportunity: totalCost ? `Reviewing these sessions targets about $${(totalCost * 0.5).toFixed(2)} of spend.` : "High token concentration even when cost is unknown.",
+      recommendation: "Split large tasks into smaller prompts and add checkpoints before long coding runs."
+    });
+  }
+  const highOutputProject = data.projects.find((project) => project.outputInputRatio > 2 && project.totalTokens > 5e3);
+  if (highOutputProject) {
+    insights.push({
+      id: "high-output-project",
+      severity: "medium",
+      problem: "One project uses unusually high output tokens.",
+      evidence: `${highOutputProject.project} has an output/input ratio of ${highOutputProject.outputInputRatio.toFixed(1)}x.`,
+      savingOpportunity: highOutputProject.cost ? `Potential review pool: $${highOutputProject.cost.toFixed(2)}.` : "Savings depend on configured pricing.",
+      recommendation: "Ask for concise diffs, summaries, or file-scoped edits when working in this project."
+    });
+  }
+  const cacheEfficiency = data.summary.inputTokens + data.summary.cachedTokens ? data.summary.cachedTokens / (data.summary.inputTokens + data.summary.cachedTokens) : 0;
+  if (data.summary.inputTokens > 1e4 && cacheEfficiency < 0.05) {
+    insights.push({
+      id: "low-cache",
+      severity: "medium",
+      problem: "Cache usage is low.",
+      evidence: `Cached tokens are ${Math.round(cacheEfficiency * 100)}% of reusable input volume.`,
+      savingOpportunity: "Better context reuse can reduce repeated input-token spend on supported models.",
+      recommendation: "Keep stable instructions and repo context consistent across related runs where the CLI supports caching."
+    });
+  }
+  const costlyAlternative = data.models.find((model) => model.overuseFlag && model.suggestedAlternative);
+  if (costlyAlternative) {
+    insights.push({
+      id: "expensive-model-overuse",
+      severity: "medium",
+      problem: "Configured cheaper models may fit some low-complexity work.",
+      evidence: `${costlyAlternative.model} has ${costlyAlternative.totalTokens.toLocaleString()} tokens and ${costlyAlternative.suggestedAlternative} is cheaper in your pricing table.`,
+      savingOpportunity: costlyAlternative.cost ? `Candidate spend: $${costlyAlternative.cost.toFixed(2)}.` : "Savings require complete pricing.",
+      recommendation: "Use cheaper models for refactoring, search-heavy, or mechanical edits, and reserve expensive models for ambiguous architecture work."
+    });
+  }
+  if (data.trends.length >= 14) {
+    const last = data.trends.slice(-7).reduce((sum, day) => sum + day.totalTokens, 0) / 7;
+    const previous = data.trends.slice(-14, -7).reduce((sum, day) => sum + day.totalTokens, 0) / 7;
+    if (previous > 0 && last / previous > 1.25) {
+      insights.push({
+        id: "session-length-growing",
+        severity: "low",
+        problem: "Average usage is increasing.",
+        evidence: `Last 7-day average is ${Math.round((last / previous - 1) * 100)}% above the prior week.`,
+        savingOpportunity: "Reducing drift can slow recurring spend growth.",
+        recommendation: "Use planning prompts before long coding runs and prune stale context between unrelated tasks."
+      });
+    }
+  }
+  if (!insights.length) {
+    insights.push({
+      id: "baseline",
+      severity: "low",
+      problem: "No strong optimization pattern detected yet.",
+      evidence: "Scan more sessions or configure prices for richer recommendations.",
+      savingOpportunity: "Unknown until more local usage is imported.",
+      recommendation: "Run a scan after several CLI sessions and revisit this page."
+    });
+  }
+  return insights;
+}
+
+// src/lib/evidence/metrics.ts
+var evidenceMetrics = [
+  "processed-tokens",
+  "non-cache-tokens",
+  "cached-tokens",
+  "estimated-cost",
+  "sessions",
+  "unknown-cost",
+  "guardrails",
+  "review-queue"
+];
+var metricTitles = {
+  "processed-tokens": {
+    title: "Processed tokens",
+    description: "All input, output, cache, and reasoning tokens from imported local CLI records."
+  },
+  "non-cache-tokens": {
+    title: "Non-cache tokens",
+    description: "Fresh input, output, and reasoning tokens, excluding cache read/write tokens."
+  },
+  "cached-tokens": {
+    title: "Cached tokens",
+    description: "Cache read and cache write tokens reported by supported tools."
+  },
+  "estimated-cost": {
+    title: "Estimated cost",
+    description: "Cost calculated from editable provider model rates, including exact, estimated, and unknown rows."
+  },
+  sessions: {
+    title: "Sessions",
+    description: "Imported local CLI sessions and their interaction evidence."
+  },
+  "unknown-cost": {
+    title: "Unknown cost",
+    description: "Interactions whose cost cannot be calculated because model, price, or token counts are missing."
+  },
+  guardrails: {
+    title: "Monthly guardrails",
+    description: "Current-month usage contributing to local guardrail progress."
+  },
+  "review-queue": {
+    title: "Review queue",
+    description: "Evidence behind deterministic local review recommendations."
+  }
+};
+function withQuery2(path2, params) {
+  const query = new URLSearchParams();
+  Object.entries(params).forEach(([key, value]) => {
+    if (value) query.set(key, value);
+  });
+  const serialized = query.toString();
+  return serialized ? `${path2}?${serialized}` : path2;
+}
+function evidenceHref(metric2, params = {}) {
+  return withQuery2("/evidence", { metric: metric2, ...params });
+}
+
+// src/lib/evidence/mapping.ts
+function number2(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function mapEvidenceTrail({
+  metric: metric2,
+  rows: rows2
+}) {
+  const config = metricTitles[metric2] ?? metricTitles["processed-tokens"];
+  const sessions2 = rows2.sessions.map((session) => {
+    const cost = session.cost == null ? null : number2(session.cost);
+    return {
+      id: session.id,
+      title: session.title,
+      tool: session.tool,
+      provider: session.provider,
+      project: session.project,
+      model: session.model,
+      sourceFile: session.sourceFile,
+      parser: session.parser,
+      parserStatus: session.parserStatus,
+      parserConfidence: typeof session.parserConfidence === "number" && Number.isFinite(session.parserConfidence) ? session.parserConfidence : null,
+      tokenConfidence: session.tokenConfidence,
+      totalTokens: number2(session.totalTokens),
+      cost: metric2 === "unknown-cost" && number2(session.unknownCostInteractions) > 0 ? null : cost,
+      unknownCostInteractions: number2(session.unknownCostInteractions),
+      interactions: number2(session.interactions),
+      sessionHref: withQuery2("/sessions", { source: session.sourceFile, evidence: metric2 }),
+      sourceHref: withQuery2("/sessions", { source: session.sourceFile, evidence: metric2 }),
+      parserHref: withQuery2("/parser-debug", { source: session.sourceFile }),
+      pricingHref: session.pricingModel ? withQuery2("/pricing", { model: session.pricingModel }) : null
+    };
+  });
+  return {
+    metric: metric2,
+    title: config.title,
+    description: config.description,
+    totals: {
+      tokens: number2(rows2.totals.tokens),
+      cost: number2(rows2.totals.cost),
+      sessions: number2(rows2.totals.sessions),
+      interactions: number2(rows2.totals.interactions),
+      unknownCostInteractions: number2(rows2.totals.unknownCostInteractions)
+    },
+    confidence: {
+      exact: number2(rows2.confidence.exact),
+      estimated: number2(rows2.confidence.estimated),
+      unknown: number2(rows2.confidence.unknown)
+    },
+    sourceFiles: rows2.sourceFiles.map((source) => ({
+      sourceFile: source.sourceFile,
+      tokens: number2(source.tokens),
+      sessions: number2(source.sessions),
+      interactions: number2(source.interactions),
+      unknownCostInteractions: number2(source.unknownCostInteractions),
+      sourceHref: withQuery2("/sessions", { source: source.sourceFile, evidence: metric2 }),
+      parserHref: withQuery2("/parser-debug", { source: source.sourceFile })
+    })),
+    sessions: sessions2
+  };
+}
+
+// src/lib/evidence/query.ts
+function currentMonthWindow(now = /* @__PURE__ */ new Date()) {
+  const from = new Date(now.getFullYear(), now.getMonth(), 1).getTime();
+  const to = new Date(now.getFullYear(), now.getMonth() + 1, 1).getTime();
+  return { from, to };
+}
+function metricTokenExpression(metric2, alias = "i") {
+  if (metric2 === "cached-tokens") return `${alias}.cache_read_tokens + ${alias}.cache_write_tokens`;
+  if (metric2 === "non-cache-tokens") return `${alias}.input_tokens + ${alias}.output_tokens + ${alias}.reasoning_tokens`;
+  return `${alias}.total_tokens`;
+}
+function metricClauses(metric2, alias = "i") {
+  if (metric2 === "cached-tokens") return [`(${alias}.cache_read_tokens + ${alias}.cache_write_tokens) > 0`];
+  if (metric2 === "unknown-cost") return [`${alias}.cost IS NULL`];
+  if (metric2 === "non-cache-tokens") {
+    return [`(${alias}.input_tokens + ${alias}.output_tokens + ${alias}.reasoning_tokens) > 0`];
+  }
+  if (metric2 === "guardrails") {
+    const window = currentMonthWindow();
+    return [`${alias}.timestamp >= ${window.from}`, `${alias}.timestamp < ${window.to}`];
+  }
+  return [];
+}
+function evidenceWhere(metric2, filters = {}, alias = "i", prefix = "WHERE") {
+  const clauses = metricClauses(metric2, alias);
+  const params = [];
+  if (typeof filters.from === "number" && Number.isFinite(filters.from)) {
+    clauses.push(`${alias}.timestamp >= ?`);
+    params.push(filters.from);
+  }
+  if (typeof filters.to === "number" && Number.isFinite(filters.to)) {
+    clauses.push(`${alias}.timestamp < ?`);
+    params.push(filters.to);
+  }
+  return {
+    sql: clauses.length ? `${prefix} ${clauses.join(" AND ")}` : "",
+    params
+  };
+}
+function fetchEvidenceTrailRows({
+  metric: metric2,
+  filters
+}) {
+  const activeFilters = filters ?? {};
+  const where = evidenceWhere(metric2, activeFilters);
+  const modelWhere = evidenceWhere(metric2, activeFilters, "i3", "AND");
+  const pricingWhere = evidenceWhere(metric2, activeFilters, "i2", "AND");
+  const tokenExpression = metricTokenExpression(metric2);
+  const pricingTokenExpression = metricTokenExpression(metric2, "i2");
+  const totals = sqlite.prepare(
+    `SELECT
+        COALESCE(SUM(${tokenExpression}), 0) AS tokens,
+        COALESCE(SUM(i.cost), 0) AS cost,
+        COUNT(DISTINCT i.session_id) AS sessions,
+        COUNT(*) AS interactions,
+        SUM(CASE WHEN i.cost IS NULL THEN 1 ELSE 0 END) AS unknownCostInteractions
+       FROM interactions i INDEXED BY interactions_analytics_cover_idx
+       ${where.sql}`
+  ).get(...where.params);
+  const confidence = sqlite.prepare(
+    `SELECT
+        COALESCE(SUM(CASE WHEN i.token_confidence = 'exact' AND i.estimated_tokens = 0 THEN 1 ELSE 0 END), 0) AS exact,
+        COALESCE(SUM(CASE WHEN i.estimated_tokens = 1 OR i.token_confidence LIKE '%estimate%' THEN 1 ELSE 0 END), 0) AS estimated,
+        COALESCE(SUM(CASE WHEN i.token_confidence = 'unknown' THEN 1 ELSE 0 END), 0) AS unknown
+       FROM interactions i INDEXED BY interactions_analytics_cover_idx
+       ${where.sql}`
+  ).get(...where.params);
+  const sourceFiles = sqlite.prepare(
+    `SELECT
+        s.source_file AS sourceFile,
+        COALESCE(SUM(${tokenExpression}), 0) AS tokens,
+        COUNT(DISTINCT s.id) AS sessions,
+        COUNT(*) AS interactions,
+        SUM(CASE WHEN i.cost IS NULL THEN 1 ELSE 0 END) AS unknownCostInteractions
+       FROM interactions i INDEXED BY interactions_analytics_cover_idx
+       JOIN sessions s ON s.id = i.session_id
+       ${where.sql}
+       GROUP BY s.source_file
+       ORDER BY tokens DESC, interactions DESC, sourceFile ASC
+       LIMIT 8`
+  ).all(...where.params);
+  const sessions2 = sqlite.prepare(
+    `WITH session_totals AS (
+        SELECT
+          i.session_id AS sessionId,
+          CASE
+            WHEN SUM(CASE WHEN i.token_confidence = 'unknown' THEN 1 ELSE 0 END) > 0 THEN 'unknown'
+            WHEN SUM(CASE WHEN i.token_confidence = 'low-confidence estimate' THEN 1 ELSE 0 END) > 0 THEN 'low-confidence estimate'
+            WHEN SUM(CASE WHEN i.token_confidence = 'high-confidence estimate' THEN 1 ELSE 0 END) > 0 THEN 'high-confidence estimate'
+            WHEN SUM(CASE WHEN i.estimated_tokens = 1 THEN 1 ELSE 0 END) > 0 THEN 'estimated'
+            ELSE 'exact'
+          END AS tokenConfidence,
+          COALESCE(SUM(${tokenExpression}), 0) AS totalTokens,
+          SUM(i.cost) AS cost,
+          SUM(CASE WHEN i.cost IS NULL THEN 1 ELSE 0 END) AS unknownCostInteractions,
+          COUNT(*) AS interactions
+        FROM interactions i INDEXED BY interactions_analytics_cover_idx
+        ${where.sql}
+        GROUP BY i.session_id
+        ORDER BY totalTokens DESC, sessionId ASC
+        LIMIT 100
+      )
+      SELECT
+        s.id,
+        COALESCE(s.title, t.name || ' session') AS title,
+        t.name AS tool,
+        p.name AS provider,
+        COALESCE(pr.name, 'Unassigned') AS project,
+        COALESCE((
+          SELECT group_concat(model_name)
+          FROM (
+            SELECT DISTINCT COALESCE(m3.name, 'unknown') AS model_name
+            FROM interactions i3 INDEXED BY interactions_session_analytics_idx
+            LEFT JOIN models m3 ON m3.id = i3.model_id
+            WHERE i3.session_id = s.id
+            ${modelWhere.sql}
+            ORDER BY model_name ASC
+          )
+        ), 'unknown') AS model,
+        (
+          SELECT m2.name
+          FROM interactions i2 INDEXED BY interactions_session_analytics_idx
+          LEFT JOIN models m2 ON m2.id = i2.model_id
+          WHERE i2.session_id = s.id
+            ${pricingWhere.sql}
+            AND m2.name IS NOT NULL
+          GROUP BY m2.id, m2.name
+          ORDER BY SUM(${pricingTokenExpression}) DESC, m2.name ASC
+          LIMIT 1
+        ) AS pricingModel,
+        s.source_file AS sourceFile,
+        sf.parser AS parser,
+        sf.status AS parserStatus,
+        json_extract(sf.raw_metadata, '$.confidence') AS parserConfidence,
+        st.tokenConfidence,
+        st.totalTokens,
+        st.cost,
+        st.unknownCostInteractions,
+        st.interactions
+       FROM session_totals st
+       JOIN sessions s ON s.id = st.sessionId
+       JOIN tools t ON t.id = s.tool_id
+       JOIN providers p ON p.id = t.provider_id
+       LEFT JOIN projects pr ON pr.id = s.project_id
+       LEFT JOIN scan_files sf ON sf.id = (
+         SELECT sf2.id
+         FROM scan_files sf2
+         JOIN scan_runs sr2 ON sr2.id = sf2.scan_run_id
+         WHERE sf2.path = s.source_file
+         ORDER BY
+           CASE
+             WHEN sf2.status IN ('imported', 'imported_with_errors')
+               AND sf2.parser IS NOT NULL
+               AND sf2.raw_metadata IS NOT NULL
+               AND sf2.raw_metadata <> '{}'
+               THEN 0
+             WHEN sf2.status IN ('imported', 'imported_with_errors')
+               AND sf2.parser IS NOT NULL
+               THEN 1
+             ELSE 2
+           END,
+           sr2.started_at DESC,
+           sf2.id ASC
+         LIMIT 1
+       )
+       ORDER BY st.totalTokens DESC, s.id ASC`
+  ).all(...where.params, ...modelWhere.params, ...pricingWhere.params);
+  return {
+    totals,
+    confidence,
+    sourceFiles,
+    sessions: sessions2
+  };
+}
+
+// src/lib/evidence-trail.ts
+function buildEvidenceTrail(input) {
+  return mapEvidenceTrail({
+    metric: input.metric,
+    rows: fetchEvidenceTrailRows({
+      metric: input.metric,
+      filters: input.filters
+    })
+  });
+}
+
+// src/lib/recommendations.ts
+function recommendation(id, severity, title, evidence, action2, href) {
+  return { id, severity, title, evidence, action: action2, href };
+}
+function guardrailRecommendation(metric2, kind, monthLabel2) {
+  if (!metric2.configured || metric2.status === "ok") return null;
+  const exceeded = metric2.status === "exceeded";
+  const formattedUsed = kind === "cost" ? formatCurrency(metric2.used) : formatTokens(metric2.used);
+  const formattedLimit = kind === "cost" ? formatCurrency(metric2.limit) : formatTokens(metric2.limit);
+  const noun = kind === "cost" ? "cost" : "token";
+  const percent = Math.round(metric2.percent * 100);
+  return recommendation(
+    `monthly-${noun}-limit-${metric2.status}`,
+    exceeded ? "high" : "medium",
+    exceeded ? `Monthly ${noun} guardrail exceeded` : `Monthly ${noun} guardrail is close`,
+    `${monthLabel2} is at ${formattedUsed} of ${formattedLimit} (${percent}%).`,
+    exceeded ? "Review current-month sessions before starting more long CLI runs." : "Watch the next few sessions or adjust the local guardrail in Settings.",
+    "/sessions"
+  );
+}
+function buildLocalRecommendations(input) {
+  const recommendations = [];
+  const missingPricing = input.unknownCosts.filter((row) => row.cause === "missing pricing").reduce((sum, row) => sum + row.interactions, 0);
+  if (missingPricing > 0) {
+    const top = input.unknownCosts.find((row) => row.cause === "missing pricing");
+    recommendations.push(recommendation(
+      "unknown-pricing",
+      "high",
+      "Add missing model rates",
+      `${missingPricing.toLocaleString()} interactions have tokens and model names but no usable price row${top ? `; top model: ${top.model}` : ""}.`,
+      "Set the missing provider model rates so cost totals become complete.",
+      top?.repairHref ?? "/pricing"
+    ));
+  } else if (input.summary.unknownCostInteractions > 0) {
+    recommendations.push(recommendation(
+      "unknown-cost",
+      "medium",
+      "Repair unknown cost rows",
+      `${input.summary.unknownCostInteractions.toLocaleString()} interactions still have unknown cost.`,
+      "Use the repair queue to decide whether model rates, model names, or token counts are missing.",
+      "/diagnostics"
+    ));
+  }
+  if (input.guardrails) {
+    const guardrailItems = [
+      guardrailRecommendation(input.guardrails.cost, "cost", input.guardrails.monthLabel),
+      guardrailRecommendation(input.guardrails.tokens, "tokens", input.guardrails.monthLabel)
+    ].filter((item) => Boolean(item));
+    recommendations.push(...guardrailItems);
+  }
+  const topProject = input.projects[0];
+  if (topProject && input.summary.totalTokens > 0 && topProject.totalTokens / input.summary.totalTokens >= 0.5) {
+    recommendations.push(recommendation(
+      "dominant-project",
+      "medium",
+      "One project dominates usage",
+      `${topProject.project} accounts for ${Math.round(topProject.totalTokens / input.summary.totalTokens * 100)}% of imported tokens.`,
+      "Review that project's sessions before optimizing smaller usage elsewhere.",
+      `/sessions?project=${encodeURIComponent(topProject.project)}`
+    ));
+  }
+  const estimatedTool = input.tools.find((tool) => tool.interactions > 0 && tool.totalTokens > 0 && tool.tool === "Generic Log");
+  if (estimatedTool) {
+    recommendations.push(recommendation(
+      "generic-log-estimates",
+      "medium",
+      "Generic logs are contributing usage",
+      `${estimatedTool.tool} has ${estimatedTool.totalTokens.toLocaleString()} tokens across ${estimatedTool.interactions.toLocaleString()} interactions.`,
+      "Review parser confidence before treating generic log estimates as exact usage.",
+      "/parser-debug"
+    ));
+  }
+  const cacheBase = input.summary.inputTokens + input.summary.cachedTokens;
+  const cacheEfficiency = cacheBase > 0 ? input.summary.cachedTokens / cacheBase : 0;
+  if (input.summary.inputTokens > 1e4 && cacheEfficiency < 0.1) {
+    recommendations.push(recommendation(
+      "low-cache",
+      "low",
+      "Cache usage is low",
+      `Cached tokens are ${Math.round(cacheEfficiency * 100)}% of reusable input volume.`,
+      "Inspect model and session mix to see whether your CLI can reuse more context.",
+      "/models"
+    ));
+  }
+  if (input.scan && input.scan.latestRecordsImported === 0 && input.scan.duplicateFiles > 0 && input.scan.parserReviewFiles === 0) {
+    recommendations.push(recommendation(
+      "duplicate-only-scan",
+      "low",
+      "Last scan found only already imported files",
+      `${input.scan.duplicateFiles.toLocaleString()} duplicate files were skipped safely.`,
+      "No action is needed unless you expected new sessions.",
+      "/diagnostics"
+    ));
+  }
+  if (input.scan && input.scan.parserReviewFiles > 0) {
+    recommendations.push(recommendation(
+      "parser-review",
+      "medium",
+      "Some files need parser review",
+      `${input.scan.parserReviewFiles.toLocaleString()} files were unsupported in the latest scan.`,
+      "Inspect Discovery to separate real usage files from support files.",
+      "/discovery"
+    ));
+  }
+  if (input.scan && input.scan.ignoredFiles > 0) {
+    recommendations.push(recommendation(
+      "ignored-support-files",
+      "low",
+      "Support files are being ignored",
+      `${input.scan.ignoredFiles.toLocaleString()} known non-usage files were ignored instead of imported.`,
+      "This is expected for Claude/Codex cache, plugin, todo, and support files.",
+      "/discovery"
+    ));
+  }
+  if (!recommendations.length) {
+    recommendations.push(recommendation(
+      "baseline",
+      "low",
+      "No urgent local recommendation",
+      "Current scans, model rates, and parser confidence do not show a high-priority repair.",
+      "Keep scanning after new CLI sessions.",
+      "/settings#scan-controls"
+    ));
+  }
+  const rank = { high: 0, medium: 1, low: 2 };
+  return recommendations.sort((a, b) => rank[a.severity] - rank[b.severity]).slice(0, 8);
+}
+
+// src/lib/review-queue.ts
+function slug(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "unknown";
+}
+function withQuery3(path2, params) {
+  const query = new URLSearchParams();
+  Object.entries(params).forEach(([key, value]) => {
+    if (value) query.set(key, value);
+  });
+  const serialized = query.toString();
+  return serialized ? `${path2}?${serialized}` : path2;
+}
+function guardrailItem(metric2, kind, monthLabel2) {
+  if (!metric2.configured || metric2.status === "ok") return null;
+  const exceeded = metric2.status === "exceeded";
+  const formattedUsed = kind === "cost" ? formatCurrency(metric2.used) : formatTokens(metric2.used);
+  const formattedLimit = kind === "cost" ? formatCurrency(metric2.limit) : formatTokens(metric2.limit);
+  const noun = kind === "cost" ? "cost" : "token";
+  return {
+    id: `guardrail-${kind}-${metric2.status}`,
+    severity: exceeded ? "high" : "medium",
+    category: "guardrail",
+    title: exceeded ? `Monthly ${noun} guardrail exceeded` : `Monthly ${noun} guardrail is close`,
+    evidence: `${monthLabel2} is at ${formattedUsed} of ${formattedLimit} (${Math.round(metric2.percent * 100)}%).`,
+    action: exceeded ? "Review current-month sessions before starting another long CLI run." : "Watch the next sessions or adjust the local guardrail in Settings.",
+    href: "/sessions",
+    impactLabel: `${monthLabel2} ${noun}`,
+    impactValue: formattedUsed
+  };
+}
+function unknownCostItem(row) {
+  const severity = row.cause === "missing pricing" ? "high" : "medium";
+  return {
+    id: `repair-unknown-cost-${slug(row.cause)}-${slug(row.model)}`,
+    severity,
+    category: "cost-repair",
+    title: row.cause === "missing pricing" ? "Price a real model name" : "Repair unknown-cost usage",
+    evidence: `${row.interactions.toLocaleString()} interactions from ${row.tool} are ${row.cause}; model: ${row.model}.`,
+    action: row.cause === "missing pricing" ? "Add or confirm the model price so cost totals become complete." : "Inspect parser evidence to recover the missing model or token count.",
+    href: row.repairHref,
+    impactLabel: "unknown cost",
+    impactValue: `${row.interactions.toLocaleString()} interactions`
+  };
+}
+function sessionItem(session, summary) {
+  const tokenShare = summary.totalTokens > 0 ? session.totalTokens / summary.totalTokens : 0;
+  const costShare = summary.totalCost > 0 && session.cost != null ? session.cost / summary.totalCost : 0;
+  const severity = tokenShare >= 0.25 || costShare >= 0.25 ? "high" : "medium";
+  const title = session.title?.trim() || `${session.tool} session`;
+  return {
+    id: `review-session-${session.id}`,
+    severity,
+    category: "session",
+    title: "Review a high-impact session",
+    evidence: `${title} used ${formatTokens(session.totalTokens)} tokens${session.cost != null ? ` and ${formatCurrency(session.cost)}` : ""}.`,
+    action: "Open the evidence trail before optimizing smaller usage elsewhere.",
+    href: session.sourceHref,
+    impactLabel: "session tokens",
+    impactValue: formatTokens(session.totalTokens)
+  };
+}
+function projectItem(project, summary) {
+  if (summary.totalTokens <= 0 || project.totalTokens / summary.totalTokens < 0.5) return null;
+  return {
+    id: `review-project-${project.id}`,
+    severity: "medium",
+    category: "project",
+    title: "One project dominates usage",
+    evidence: `${project.project} accounts for ${Math.round(project.totalTokens / summary.totalTokens * 100)}% of imported tokens.`,
+    action: "Review this project's sessions before spreading effort across smaller projects.",
+    href: withQuery3("/sessions", { project: project.project }),
+    impactLabel: "project tokens",
+    impactValue: formatTokens(project.totalTokens)
+  };
+}
+function modelItem(model) {
+  if (!model.overuseFlag || !model.suggestedAlternative) return null;
+  return {
+    id: `review-model-${slug(model.provider)}-${slug(model.model)}`,
+    severity: "medium",
+    category: "model",
+    title: "Check expensive-model usage",
+    evidence: `${model.model} has ${formatTokens(model.totalTokens)} tokens and ${model.suggestedAlternative} is cheaper in Model Rates.`,
+    action: "Review sessions for mechanical work that could use a cheaper configured model.",
+    href: withQuery3("/sessions", { model: model.model }),
+    impactLabel: "model cost",
+    impactValue: formatCurrency(model.cost)
+  };
+}
+function cacheItem(tool, summary) {
+  if (tool.totalTokens < 1e4 || tool.cacheEfficiency >= 0.05 || summary.inputTokens < 1e4) return null;
+  return {
+    id: `review-cache-${slug(tool.tool)}`,
+    severity: "low",
+    category: "cache",
+    title: "Cache reuse is low",
+    evidence: `${tool.tool} has ${formatTokens(tool.totalTokens)} tokens with ${Math.round(tool.cacheEfficiency * 100)}% cache efficiency.`,
+    action: "Inspect model and session mix to see whether context reuse is possible.",
+    href: withQuery3("/sessions", { tool: tool.tool }),
+    impactLabel: "tool tokens",
+    impactValue: formatTokens(tool.totalTokens)
+  };
+}
+function buildReviewQueue(input) {
+  const items = [];
+  const guardrailItems = [
+    guardrailItem(input.guardrails.cost, "cost", input.guardrails.monthLabel),
+    guardrailItem(input.guardrails.tokens, "tokens", input.guardrails.monthLabel)
+  ].filter((item) => Boolean(item));
+  items.push(...guardrailItems);
+  const topUnknownCost = input.unknownCosts[0];
+  if (topUnknownCost) {
+    items.push(unknownCostItem(topUnknownCost));
+  }
+  const topSession = [...input.sessions].sort((a, b) => {
+    const costDelta = (b.cost ?? 0) - (a.cost ?? 0);
+    return costDelta || b.totalTokens - a.totalTokens;
+  })[0];
+  if (topSession && topSession.totalTokens > 0) {
+    items.push(sessionItem(topSession, input.summary));
+  }
+  const topProject = input.projects[0] ? projectItem(input.projects[0], input.summary) : null;
+  if (topProject) items.push(topProject);
+  const modelReview = input.models.map(modelItem).find(Boolean);
+  if (modelReview) items.push(modelReview);
+  const cacheReview = input.tools.map((tool) => cacheItem(tool, input.summary)).find(Boolean);
+  if (cacheReview) items.push(cacheReview);
+  if (!items.length) {
+    return [
+      {
+        id: "baseline",
+        severity: "low",
+        category: "baseline",
+        title: "No urgent review item",
+        evidence: "Current local usage does not show a high-priority repair or optimization queue.",
+        action: "Keep scanning after meaningful CLI sessions.",
+        href: "/settings#scan-controls",
+        impactLabel: "review status",
+        impactValue: "clear"
+      }
+    ];
+  }
+  const severityRank = { high: 0, medium: 1, low: 2 };
+  const categoryRank = {
+    guardrail: 0,
+    "cost-repair": 1,
+    session: 2,
+    project: 3,
+    model: 4,
+    cache: 5,
+    baseline: 6
+  };
+  return items.sort((a, b) => severityRank[a.severity] - severityRank[b.severity] || categoryRank[a.category] - categoryRank[b.category]).slice(0, 8);
+}
+
+// src/lib/project-signals.ts
+function slug2(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "unknown";
+}
+function sessionsHref(project) {
+  return `/sessions?project=${encodeURIComponent(project)}`;
+}
+function sessionsByProject(sessions2) {
+  return sessions2.reduce((groups, session) => {
+    const group = groups[session.project] ??= [];
+    group.push(session);
+    return groups;
+  }, {});
+}
+function dominantProjectSignal(project, totalTokens) {
+  if (totalTokens <= 0) return null;
+  const share = project.totalTokens / totalTokens;
+  if (share < 0.5) return null;
+  return {
+    id: `project-dominance-${project.id}`,
+    severity: share >= 0.75 ? "high" : "medium",
+    project: project.project,
+    path: project.path,
+    signal: "dominant usage",
+    evidence: `${project.project} accounts for ${Math.round(share * 100)}% of imported tokens.`,
+    action: "Review this project's sessions before optimizing smaller projects.",
+    href: sessionsHref(project.project),
+    metricLabel: "project share",
+    metricValue: `${Math.round(share * 100)}%`
+  };
+}
+function unknownCostSignal(project, sessions2) {
+  const count = sessions2.filter((session) => session.cost == null).length;
+  if (count === 0) return null;
+  return {
+    id: `project-unknown-cost-${slug2(project.project)}`,
+    severity: "high",
+    project: project.project,
+    path: project.path,
+    signal: "unknown cost",
+    evidence: `${count.toLocaleString()} sessions in ${project.project} still have unknown cost.`,
+    action: "Repair model-rate or parser evidence for this project's sessions.",
+    href: `/sessions?project=${encodeURIComponent(project.project)}&cost=unknown`,
+    metricLabel: "unknown sessions",
+    metricValue: count.toLocaleString()
+  };
+}
+function estimatedTokensSignal(project, sessions2) {
+  const count = sessions2.filter((session) => session.estimatedTokens || session.tokenConfidence !== "exact").length;
+  if (count === 0) return null;
+  return {
+    id: `project-estimated-tokens-${slug2(project.project)}`,
+    severity: "medium",
+    project: project.project,
+    path: project.path,
+    signal: "estimated tokens",
+    evidence: `${count.toLocaleString()} sessions in ${project.project} use estimated or unknown token confidence.`,
+    action: "Review parser confidence before treating this project as exact.",
+    href: sessionsHref(project.project),
+    metricLabel: "estimated sessions",
+    metricValue: count.toLocaleString()
+  };
+}
+function modelConcentrationSignal(project, sessions2) {
+  if (sessions2.length < 3) return null;
+  const totals = sessions2.reduce((summary, session) => {
+    const model = session.models.split(",")[0]?.trim() || "unknown";
+    summary[model] = (summary[model] ?? 0) + session.totalTokens;
+    return summary;
+  }, {});
+  const top = Object.entries(totals).sort((a, b) => b[1] - a[1])[0];
+  if (!top || project.totalTokens <= 0 || top[1] / project.totalTokens < 0.8) return null;
+  return {
+    id: `project-model-concentration-${slug2(project.project)}-${slug2(top[0])}`,
+    severity: "low",
+    project: project.project,
+    path: project.path,
+    signal: "model concentration",
+    evidence: `${top[0]} accounts for ${Math.round(top[1] / project.totalTokens * 100)}% of ${project.project} tokens.`,
+    action: "Review whether this project needs one default model or more intentional model choices.",
+    href: sessionsHref(project.project),
+    metricLabel: "top model tokens",
+    metricValue: formatTokens(top[1])
+  };
+}
+function buildProjectSignals(input) {
+  const groupedSessions = sessionsByProject(input.sessions);
+  const signals = [];
+  input.projects.forEach((project) => {
+    const projectSessions = groupedSessions[project.project] ?? [];
+    const projectSignals = [
+      dominantProjectSignal(project, input.totalTokens),
+      unknownCostSignal(project, projectSessions),
+      estimatedTokensSignal(project, projectSessions),
+      modelConcentrationSignal(project, projectSessions)
+    ].filter((signal) => Boolean(signal));
+    signals.push(...projectSignals);
+  });
+  const severityRank = { high: 0, medium: 1, low: 2 };
+  const signalRank = {
+    "dominant usage": 0,
+    "unknown cost": 1,
+    "estimated tokens": 2,
+    "model concentration": 3
+  };
+  return signals.sort((a, b) => signalRank[a.signal] - signalRank[b.signal] || severityRank[a.severity] - severityRank[b.severity]).slice(0, 12);
+}
+
+// src/lib/session-comparison.ts
+function median(values) {
+  if (!values.length) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const middle = Math.floor(sorted.length / 2);
+  const upper = sorted[middle];
+  if (upper === void 0) return 0;
+  const lower = sorted[middle - 1];
+  return sorted.length % 2 === 0 && lower !== void 0 ? (lower + upper) / 2 : upper;
+}
+function groupKey(session) {
+  const primaryModel = session.models.split(",")[0]?.trim() || "unknown";
+  return [session.project, session.tool, primaryModel].join("\0");
+}
+function titleFor(session) {
+  return session.title?.trim() || `${session.tool} session`;
+}
+function buildSessionComparisons(sessions2) {
+  const groups = /* @__PURE__ */ new Map();
+  sessions2.forEach((session) => {
+    const key = groupKey(session);
+    const group = groups.get(key) ?? [];
+    group.push(session);
+    groups.set(key, group);
+  });
+  const rows2 = [];
+  groups.forEach((group) => {
+    if (group.length < 3) return;
+    const medianTokens = median(group.map((session) => session.totalTokens).filter((value) => value > 0));
+    const medianCost = median(group.map((session) => session.cost ?? 0).filter((value) => value > 0));
+    if (medianTokens <= 0) return;
+    group.forEach((session) => {
+      const tokenMultiple = session.totalTokens / medianTokens;
+      const costMultiple = medianCost > 0 && session.cost != null ? session.cost / medianCost : null;
+      const isTokenOutlier = session.totalTokens >= 5e3 && tokenMultiple >= 3;
+      const isCostOutlier = session.cost != null && session.cost >= 1 && costMultiple != null && costMultiple >= 3;
+      if (!isTokenOutlier && !isCostOutlier) return;
+      const flag = isTokenOutlier ? "token outlier" : "cost outlier";
+      const multiple = isTokenOutlier ? tokenMultiple : costMultiple ?? tokenMultiple;
+      rows2.push({
+        sessionId: session.id,
+        title: titleFor(session),
+        project: session.project,
+        tool: session.tool,
+        models: session.models,
+        totalTokens: session.totalTokens,
+        cost: session.cost,
+        peerSessions: group.length,
+        peerMedianTokens: medianTokens,
+        peerMedianCost: medianCost > 0 ? medianCost : null,
+        tokenMultiple,
+        costMultiple,
+        severity: multiple >= 5 ? "high" : "medium",
+        flag,
+        evidence: flag === "token outlier" ? `${titleFor(session)} used ${formatTokens(session.totalTokens)}, ${tokenMultiple.toFixed(1)}x its peer median.` : `${titleFor(session)} cost ${formatCurrency(session.cost)}, ${(costMultiple ?? 0).toFixed(1)}x its peer median.`,
+        action: "Compare this session against similar project, tool, and model sessions.",
+        href: session.sourceHref
+      });
+    });
+  });
+  const severityRank = { high: 0, medium: 1, low: 2 };
+  return rows2.sort((a, b) => severityRank[a.severity] - severityRank[b.severity] || b.tokenMultiple - a.tokenMultiple).slice(0, 12);
+}
+
+// src/db/settings.ts
+import { eq } from "drizzle-orm";
+
+// src/lib/import-profiles.ts
+var builtInImportProfiles = [
+  {
+    id: "structured-usage-log",
+    label: "Structured usage logs",
+    kind: "jsonl",
+    description: "Local wrapper or team JSONL records with session, model, usage, and optional cost fields.",
+    matchers: [".jsonl", ".ndjson"],
+    enabled: true,
+    builtIn: true
+  },
+  {
+    id: "cursor-chat-export",
+    label: "Cursor chat exports",
+    kind: "cursor-chat",
+    description: "Cursor-style JSON chat or composer exports with conversations and messages.",
+    matchers: ["cursor", "composer", ".json"],
+    enabled: true,
+    builtIn: true
+  },
+  {
+    id: "generic-jsonl",
+    label: "Generic JSONL usage",
+    kind: "jsonl",
+    description: "Line-delimited JSON records with usage, model, role, or token fields.",
+    matchers: [".jsonl"],
+    enabled: true,
+    builtIn: true
+  },
+  {
+    id: "generic-text-log",
+    label: "Generic text usage log",
+    kind: "text-log",
+    description: "Plain text logs with token, model, session, or cost-like usage lines.",
+    matchers: [".log", ".txt", ".md"],
+    enabled: true,
+    builtIn: true
+  },
+  {
+    id: "sqlite-history",
+    label: "SQLite usage history",
+    kind: "sqlite-history",
+    description: "Local SQLite databases with usage-shaped history tables.",
+    matchers: [".db", ".sqlite", ".sqlite3"],
+    enabled: true,
+    builtIn: true
+  }
+];
+function slug3(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 64);
+}
+function normalizeKind(value) {
+  if (value === "sqlite-history" || value === "text-log" || value === "jsonl" || value === "cursor-chat") return value;
+  return "text-log";
+}
+function normalizeMatchers(value) {
+  if (!Array.isArray(value)) return [];
+  return Array.from(
+    new Set(
+      value.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean).slice(0, 12)
+    )
+  );
+}
+function normalizeImportProfiles(value) {
+  const custom = Array.isArray(value) ? value : [];
+  const builtIns = builtInImportProfiles.map((profile) => {
+    const override = custom.find((item) => {
+      return item && typeof item === "object" && item.id === profile.id;
+    });
+    return {
+      ...profile,
+      enabled: override?.enabled === false ? false : profile.enabled
+    };
+  });
+  const customProfiles = custom.filter((item) => Boolean(item) && typeof item === "object").filter((item) => typeof item.id === "string" && !builtInImportProfiles.some((profile) => profile.id === item.id)).map((item) => {
+    const label = typeof item.label === "string" && item.label.trim() ? item.label.trim().slice(0, 80) : "Custom import profile";
+    const matchers = normalizeMatchers(item.matchers);
+    const id = typeof item.id === "string" && item.id.startsWith("custom-") ? item.id : `custom-${slug3(label) || "profile"}`;
+    return {
+      id,
+      label,
+      kind: normalizeKind(item.kind),
+      description: typeof item.description === "string" && item.description.trim() ? item.description.trim().slice(0, 240) : "Custom local log convention.",
+      matchers,
+      enabled: item.enabled !== false,
+      builtIn: false
+    };
+  }).filter((profile) => profile.matchers.length > 0);
+  return [...builtIns, ...customProfiles];
+}
+
+// src/lib/scan-schedule.ts
+var modes = /* @__PURE__ */ new Set(["manual", "on-open", "hourly", "daily"]);
+function normalizeScanSchedule(value) {
+  const object = value && typeof value === "object" ? value : {};
+  const mode = modes.has(object.mode) ? object.mode : "manual";
+  const parsedRetention = typeof object.retentionRuns === "number" ? object.retentionRuns : typeof object.retentionRuns === "string" ? Number(object.retentionRuns) : 30;
+  return {
+    mode,
+    retentionRuns: Number.isFinite(parsedRetention) && parsedRetention > 0 ? Math.min(500, Math.round(parsedRetention)) : 30,
+    lastScheduledScanAt: typeof object.lastScheduledScanAt === "string" ? object.lastScheduledScanAt : null,
+    lastScheduledScanStatus: object.lastScheduledScanStatus === "success" || object.lastScheduledScanStatus === "warning" || object.lastScheduledScanStatus === "failed" ? object.lastScheduledScanStatus : null,
+    lastScheduledScanMessage: typeof object.lastScheduledScanMessage === "string" ? object.lastScheduledScanMessage : null
+  };
+}
+
+// src/db/settings.ts
+var defaultSettings = {
+  customFolders: [],
+  storeRawMessageContent: false,
+  usageGuardrails: {
+    monthlyCostLimitUsd: null,
+    monthlyTokenLimit: null,
+    scoped: []
+  },
+  importProfiles: normalizeImportProfiles(null),
+  scanSchedule: normalizeScanSchedule(null)
+};
+function positiveLimit(value) {
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) return value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed) && parsed > 0) return parsed;
+  }
+  return null;
+}
+function normalizeUsageGuardrails(value) {
+  if (!value || typeof value !== "object") return defaultSettings.usageGuardrails;
+  const candidate = value;
+  return {
+    monthlyCostLimitUsd: positiveLimit(candidate.monthlyCostLimitUsd),
+    monthlyTokenLimit: positiveLimit(candidate.monthlyTokenLimit),
+    scoped: normalizeScopedUsageGuardrails(candidate.scoped)
+  };
+}
+function normalizeScope(value) {
+  if (value === "project" || value === "model" || value === "tool") return value;
+  return null;
+}
+function normalizeWarningThreshold(value) {
+  const parsed = typeof value === "number" ? value : typeof value === "string" ? Number(value) : 0.8;
+  if (!Number.isFinite(parsed)) return 0.8;
+  return Math.min(0.99, Math.max(0.1, parsed));
+}
+function normalizeScopedUsageGuardrails(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => Boolean(item) && typeof item === "object").map((item, index2) => {
+    const scope = normalizeScope(item.scope);
+    const name = typeof item.name === "string" ? item.name.trim() : "";
+    if (!scope || !name) return null;
+    const id = typeof item.id === "string" && item.id.trim() ? item.id.trim() : `${scope}-${name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || index2}`;
+    return {
+      id,
+      scope,
+      name: name.slice(0, 120),
+      monthlyCostLimitUsd: positiveLimit(item.monthlyCostLimitUsd),
+      monthlyTokenLimit: positiveLimit(item.monthlyTokenLimit),
+      warningThreshold: normalizeWarningThreshold(item.warningThreshold)
+    };
+  }).filter((item) => Boolean(item)).slice(0, 100);
+}
+function normalizeSettings(value) {
+  if (!value || typeof value !== "object") return defaultSettings;
+  const candidate = value;
+  return {
+    customFolders: Array.isArray(candidate.customFolders) ? candidate.customFolders.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean) : [],
+    storeRawMessageContent: candidate.storeRawMessageContent === true,
+    usageGuardrails: normalizeUsageGuardrails(candidate.usageGuardrails),
+    importProfiles: normalizeImportProfiles(candidate.importProfiles),
+    scanSchedule: normalizeScanSchedule(candidate.scanSchedule)
+  };
+}
+function getAppSettings() {
+  const row = db.select().from(settings).where(eq(settings.key, "app")).get();
+  return normalizeSettings(row?.value);
+}
+
+// src/lib/usage-guardrails.ts
+function number3(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function monthWindow(now) {
+  const from = new Date(now.getFullYear(), now.getMonth(), 1);
+  const to = new Date(now.getFullYear(), now.getMonth() + 1, 1);
+  return {
+    from: from.getTime(),
+    to: to.getTime()
+  };
+}
+function monthLabel(now) {
+  return new Intl.DateTimeFormat("en-US", {
+    month: "long",
+    year: "numeric"
+  }).format(now);
+}
+function metric(used, limit, warningThreshold = 0.8) {
+  if (limit == null || limit <= 0) {
+    return {
+      configured: false,
+      used,
+      limit: null,
+      percent: 0,
+      remaining: null,
+      status: "not-configured"
+    };
+  }
+  const percent = used / limit;
+  return {
+    configured: true,
+    used,
+    limit,
+    percent,
+    remaining: Math.max(0, limit - used),
+    status: percent >= 1 ? "exceeded" : percent >= warningThreshold ? "warning" : "ok"
+  };
+}
+function scopedProgress(guardrails, usage2) {
+  const scopedUsage = usage2.scoped ?? [];
+  return (guardrails.scoped ?? []).map((guardrail) => {
+    const current = scopedUsage.find(
+      (item) => item.scope === guardrail.scope && item.name.toLowerCase() === guardrail.name.toLowerCase()
+    ) ?? { scope: guardrail.scope, name: guardrail.name, cost: 0, tokens: 0 };
+    return {
+      id: guardrail.id,
+      scope: guardrail.scope,
+      name: guardrail.name,
+      warningThreshold: guardrail.warningThreshold,
+      cost: metric(current.cost, guardrail.monthlyCostLimitUsd, guardrail.warningThreshold),
+      tokens: metric(current.tokens, guardrail.monthlyTokenLimit, guardrail.warningThreshold)
+    };
+  });
+}
+function anomalies(scoped) {
+  return scoped.flatMap((item) => {
+    const findings = [];
+    if (item.cost.status === "exceeded" || item.tokens.status === "exceeded") {
+      findings.push({
+        id: `${item.id}-exceeded`,
+        severity: "blocked",
+        message: `${item.scope} ${item.name} exceeded a local monthly guardrail.`
+      });
+    } else if (item.cost.status === "warning" || item.tokens.status === "warning") {
+      findings.push({
+        id: `${item.id}-warning`,
+        severity: "warning",
+        message: `${item.scope} ${item.name} is near a local monthly guardrail.`
+      });
+    }
+    return findings;
+  });
+}
+function buildUsageGuardrailProgress({
+  guardrails,
+  usage: usage2,
+  now = /* @__PURE__ */ new Date()
+}) {
+  const scoped = scopedProgress(guardrails, usage2);
+  return {
+    monthLabel: monthLabel(now),
+    window: monthWindow(now),
+    cost: metric(usage2.cost, guardrails.monthlyCostLimitUsd),
+    tokens: metric(usage2.tokens, guardrails.monthlyTokenLimit),
+    scoped,
+    anomalies: anomalies(scoped)
+  };
+}
+function getCurrentMonthUsage(now) {
+  const window = monthWindow(now);
+  const row = sqlite.prepare(
+    `SELECT
+        COALESCE(SUM(total_tokens), 0) AS tokens,
+        COALESCE(SUM(cost), 0) AS cost
+       FROM interactions
+       WHERE timestamp >= ?
+         AND timestamp < ?`
+  ).get(window.from, window.to);
+  const scopedRows = sqlite.prepare(
+    `SELECT 'project' AS scope, COALESCE(p.name, 'Unassigned') AS name,
+        COALESCE(SUM(i.total_tokens), 0) AS tokens,
+        COALESCE(SUM(i.cost), 0) AS cost
+       FROM interactions i
+       JOIN sessions s ON s.id = i.session_id
+       LEFT JOIN projects p ON p.id = s.project_id
+       WHERE i.timestamp >= ? AND i.timestamp < ?
+       GROUP BY COALESCE(p.name, 'Unassigned')
+       UNION ALL
+       SELECT 'tool' AS scope, t.name AS name,
+        COALESCE(SUM(i.total_tokens), 0) AS tokens,
+        COALESCE(SUM(i.cost), 0) AS cost
+       FROM interactions i
+       JOIN sessions s ON s.id = i.session_id
+       JOIN tools t ON t.id = s.tool_id
+       WHERE i.timestamp >= ? AND i.timestamp < ?
+       GROUP BY t.name
+       UNION ALL
+       SELECT 'model' AS scope, COALESCE(m.name, 'unknown') AS name,
+        COALESCE(SUM(i.total_tokens), 0) AS tokens,
+        COALESCE(SUM(i.cost), 0) AS cost
+       FROM interactions i
+       LEFT JOIN models m ON m.id = i.model_id
+       WHERE i.timestamp >= ? AND i.timestamp < ?
+       GROUP BY COALESCE(m.name, 'unknown')`
+  ).all(window.from, window.to, window.from, window.to, window.from, window.to);
+  return {
+    tokens: number3(row?.tokens),
+    cost: number3(row?.cost),
+    scoped: scopedRows.map((item) => ({
+      scope: item.scope,
+      name: item.name,
+      tokens: number3(item.tokens),
+      cost: number3(item.cost)
+    }))
+  };
+}
+function getUsageGuardrailProgress(now = /* @__PURE__ */ new Date()) {
+  return buildUsageGuardrailProgress({
+    guardrails: getAppSettings().usageGuardrails,
+    usage: getCurrentMonthUsage(now),
+    now
+  });
+}
+
+// src/lib/analytics.ts
+function getAnalyticsData(filters = {}, options = {}) {
+  const overviewOnly = options.analyticsProfile === "overview";
+  const summary = timeAnalyticsQuery("analytics.summary", () => getSummary(filters));
+  const scanTrust = getScanTrustData(filters, options);
+  const dataConfidence = buildDataConfidenceScore({
+    totalInteractions: scanTrust.confidence.interactions,
+    exactTokenInteractions: scanTrust.confidence.exactTokenInteractions,
+    tokenizerEstimateInteractions: scanTrust.confidence.tokenizerEstimateInteractions ?? 0,
+    simpleEstimateInteractions: (scanTrust.confidence.simpleEstimateInteractions ?? 0) + scanTrust.confidence.highConfidenceTokenInteractions + scanTrust.confidence.lowConfidenceTokenInteractions,
+    unknownTokenInteractions: scanTrust.confidence.unknownTokenInteractions,
+    pricedCostInteractions: scanTrust.confidence.exactCostInteractions + scanTrust.confidence.estimatedCostInteractions,
+    unknownCostInteractions: scanTrust.confidence.unknownCostInteractions,
+    parserConfidence: null,
+    scanFreshness: scanTrust.health.freshness.state
+  });
+  const evidenceLinks = {
+    "processed-tokens": evidenceHref("processed-tokens"),
+    "non-cache-tokens": evidenceHref("non-cache-tokens"),
+    "cached-tokens": evidenceHref("cached-tokens"),
+    "estimated-cost": evidenceHref("estimated-cost"),
+    sessions: evidenceHref("sessions"),
+    "unknown-cost": evidenceHref("unknown-cost"),
+    guardrails: evidenceHref("guardrails"),
+    "review-queue": evidenceHref("review-queue")
+  };
+  const comparison = timeAnalyticsQuery("analytics.comparison", () => getUsageComparison(filters));
+  const usageGuardrails = timeAnalyticsQuery("analytics.guardrails", () => getUsageGuardrailProgress());
+  const trends = timeAnalyticsQuery("analytics.trends", () => getTrends(filters));
+  const tools2 = timeAnalyticsQuery("analytics.tools", () => getToolComparison(filters));
+  const models2 = overviewOnly ? [] : timeAnalyticsQuery("analytics.models", () => getModelRows(filters));
+  const projects2 = timeAnalyticsQuery("analytics.projects", () => getProjectRows(filters));
+  const sessions2 = timeAnalyticsQuery("analytics.sessions", () => getSessions(filters, options.sessionDetail ?? "full"));
+  const unknownCosts = timeAnalyticsQuery("analytics.unknownCosts", () => getUnknownCostQueue(filters));
+  const modelAliasSuggestions = overviewOnly ? [] : timeAnalyticsQuery("analytics.modelAliases", () => getModelAliasSuggestions(filters));
+  const sessionComparisons = overviewOnly ? [] : timeAnalyticsQuery("analytics.sessionComparisons", () => buildSessionComparisons(sessions2));
+  const projectSignals = overviewOnly ? [] : timeAnalyticsQuery("analytics.projectSignals", () => buildProjectSignals({
+    totalTokens: summary.totalTokens,
+    projects: projects2,
+    sessions: sessions2
+  }));
+  const recommendations = timeAnalyticsQuery("analytics.recommendations", () => buildLocalRecommendations({
+    summary,
+    tools: tools2,
+    projects: projects2,
+    unknownCosts,
+    guardrails: usageGuardrails,
+    scan: getLatestScanRecommendationStats()
+  }));
+  const reviewQueue = overviewOnly ? [] : timeAnalyticsQuery("analytics.reviewQueue", () => buildReviewQueue({
+    summary,
+    guardrails: usageGuardrails,
+    unknownCosts,
+    sessions: sessions2,
+    projects: projects2,
+    models: models2,
+    tools: tools2
+  }));
+  const insights = overviewOnly ? [] : timeAnalyticsQuery("analytics.insights", () => buildInsights({ summary, trends, models: models2, projects: projects2, sessions: sessions2 }));
+  return {
+    summary,
+    scanTrust,
+    dataConfidence,
+    evidenceLinks,
+    comparison,
+    trends,
+    tools: tools2,
+    models: models2,
+    projects: projects2,
+    sessions: sessions2,
+    unknownCosts,
+    modelAliasSuggestions,
+    usageGuardrails,
+    reviewQueue,
+    sessionComparisons,
+    projectSignals,
+    recommendations,
+    insights
+  };
+}
+
+// src/lib/evidence-pack.ts
+function buildEvidencePack(input) {
+  return {
+    schemaVersion: "tokentrace.evidence-pack.v1",
+    generatedAt: input.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    scope: input.scope,
+    totals: input.totals,
+    confidenceDrivers: [...input.confidenceDrivers].sort(),
+    sourceFiles: [...new Set(input.sourceFiles)].sort(),
+    parserNotes: [...input.parserNotes].sort(),
+    modelRateState: [...input.modelRateState].sort(),
+    repairLinks: [...new Set(input.repairLinks)].sort(),
+    redaction: {
+      rawContentIncluded: false,
+      rawContentPolicy: "excluded by default",
+      excludedFields: ["rawText", "rawTextPreview", "content", "prompt", "completion", "message"]
+    },
+    records: input.records.map((record) => {
+      const sanitized = { ...record };
+      delete sanitized.rawText;
+      delete sanitized.rawTextPreview;
+      return sanitized;
+    })
+  };
+}
+function buildMetricEvidencePack(input) {
+  const trail = buildEvidenceTrail({ metric: input.metric });
+  const analytics = getAnalyticsData();
+  return buildEvidencePack({
+    generatedAt: input.generatedAt,
+    scope: {
+      type: "metric",
+      id: input.metric,
+      label: trail.title
+    },
+    totals: trail.totals,
+    confidenceDrivers: [
+      `${trail.confidence.exact.toLocaleString()} exact interactions`,
+      `${trail.confidence.estimated.toLocaleString()} estimated interactions`,
+      `${trail.confidence.unknown.toLocaleString()} unknown interactions`,
+      `Data confidence ${analytics.dataConfidence.score}/100`
+    ],
+    sourceFiles: trail.sourceFiles.map((source) => source.sourceFile),
+    parserNotes: trail.sessions.map((session) => `${session.parser ?? "unknown parser"}: ${session.parserStatus ?? "unknown status"}`).slice(0, 20),
+    modelRateState: trail.sessions.map(
+      (session) => session.pricingHref ? `${session.model}: model-rate link available` : `${session.model}: no model-rate link`
+    ).slice(0, 20),
+    repairLinks: trail.sessions.filter((session) => session.unknownCostInteractions > 0).map((session) => `/repair?source=${encodeURIComponent(session.sourceFile)}`),
+    records: trail.sessions.map((session) => ({
+      id: session.id,
+      role: "session",
+      model: session.model,
+      sourceFile: session.sourceFile,
+      totalTokens: session.totalTokens,
+      cost: session.cost,
+      interactions: session.interactions
+    }))
+  });
+}
+
+// src/lib/mcp/types.ts
+var registryName = "io.github.abhiyoheswaran1/tokentrace";
+
+// src/lib/chatgpt-app/prototype.ts
+var CHATGPT_APP_TOOL_NAME = "get_redacted_evidence_pack";
+var CHATGPT_APP_WIDGET_URI = "ui://tokentrace/evidence-pack.html";
+var metricEnumValues = evidenceMetrics;
+var metricInputSchema = {
+  metric: z.enum(metricEnumValues).optional()
+};
+var evidencePackOutputSchema = {
+  summary: z.string(),
+  pack: z.object({
+    schemaVersion: z.literal("tokentrace.evidence-pack.v1")
+  }).passthrough()
+};
+var jsonMetricInputSchema = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    metric: {
+      type: "string",
+      enum: evidenceMetrics,
+      description: "Evidence metric to export. Defaults to processed-tokens."
+    }
+  }
+};
+var jsonEvidencePackOutputSchema = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    summary: { type: "string" },
+    pack: {
+      type: "object",
+      additionalProperties: true,
+      properties: {
+        schemaVersion: { const: "tokentrace.evidence-pack.v1" },
+        redaction: {
+          type: "object",
+          properties: {
+            rawContentIncluded: { const: false },
+            rawContentPolicy: { const: "excluded by default" }
+          }
+        }
+      },
+      required: ["schemaVersion", "redaction"]
+    }
+  },
+  required: ["summary", "pack"]
+};
+function chatGptAppToolDescriptors() {
+  return [
+    {
+      name: CHATGPT_APP_TOOL_NAME,
+      title: "Get redacted evidence pack",
+      description: "Return a selected TokenTrace evidence pack for ChatGPT review. The pack is read-only and excludes raw prompts, completions, and message bodies.",
+      inputSchema: jsonMetricInputSchema,
+      outputSchema: jsonEvidencePackOutputSchema,
+      annotations: {
+        readOnlyHint: true,
+        openWorldHint: false,
+        destructiveHint: false
+      },
+      _meta: {
+        ui: { resourceUri: CHATGPT_APP_WIDGET_URI },
+        "openai/outputTemplate": CHATGPT_APP_WIDGET_URI,
+        "openai/toolInvocation/invoking": "Preparing redacted evidence pack...",
+        "openai/toolInvocation/invoked": "Redacted evidence pack ready."
+      }
+    }
+  ];
+}
+function chatGptAppWidgetResource() {
+  return {
+    uri: CHATGPT_APP_WIDGET_URI,
+    mimeType: RESOURCE_MIME_TYPE,
+    text: widgetHtml(),
+    _meta: {
+      ui: {
+        csp: {
+          connectDomains: [],
+          resourceDomains: []
+        }
+      },
+      "openai/widgetDescription": "Shows a redacted TokenTrace evidence pack summary with totals and confidence drivers."
+    }
+  };
+}
+async function buildChatGptEvidencePackToolResult(args2 = {}) {
+  const metric2 = args2.metric ?? "processed-tokens";
+  const pack = buildMetricEvidencePack({ metric: metric2 });
+  const summary = [
+    `Redacted TokenTrace evidence pack for ${pack.scope.label}.`,
+    `Raw content included: ${pack.redaction.rawContentIncluded ? "yes" : "no"}.`,
+    `Records: ${pack.records.length.toLocaleString()}; source files: ${pack.sourceFiles.length.toLocaleString()}.`
+  ].join(" ");
+  return {
+    structuredContent: {
+      summary,
+      pack
+    },
+    content: [
+      {
+        type: "text",
+        text: `Prepared a redacted evidence pack for ${pack.scope.label}. Raw prompts and message bodies are excluded.`
+      }
+    ],
+    _meta: {
+      widgetMode: "evidence-pack-summary",
+      rawContentIncluded: false,
+      redactionPolicy: pack.redaction.rawContentPolicy,
+      sourceFileCount: pack.sourceFiles.length,
+      recordCount: pack.records.length
+    }
+  };
+}
+function createTokenTraceChatGptAppServer() {
+  const [descriptor] = chatGptAppToolDescriptors();
+  if (!descriptor) throw new Error("TokenTrace ChatGPT app tool descriptor is missing.");
+  const server = new McpServer(
+    {
+      name: "tokentrace-chatgpt-app",
+      version: "0.1.0"
+    },
+    {
+      instructions: "TokenTrace is local-first. Use get_redacted_evidence_pack only for selected, redacted evidence exports; do not request raw prompts or local message bodies."
+    }
+  );
+  registerAppResource(
+    server,
+    "TokenTrace evidence pack widget",
+    CHATGPT_APP_WIDGET_URI,
+    {
+      description: "Compact redacted evidence-pack summary for ChatGPT developer-mode testing.",
+      _meta: chatGptAppWidgetResource()._meta
+    },
+    async () => ({
+      contents: [chatGptAppWidgetResource()]
+    })
+  );
+  registerAppTool(
+    server,
+    CHATGPT_APP_TOOL_NAME,
+    {
+      title: "Get redacted evidence pack",
+      description: "Return a selected TokenTrace evidence pack for ChatGPT review. The pack is read-only and excludes raw prompts, completions, and message bodies.",
+      inputSchema: metricInputSchema,
+      outputSchema: evidencePackOutputSchema,
+      annotations: {
+        readOnlyHint: true,
+        openWorldHint: false,
+        destructiveHint: false
+      },
+      _meta: descriptor._meta
+    },
+    async (args2) => buildChatGptEvidencePackToolResult(args2)
+  );
+  return server;
+}
+function check(id, detail, fn) {
+  return Promise.resolve().then(fn).then(() => ({ id, ok: true, detail })).catch((error) => ({
+    id,
+    ok: false,
+    detail: error instanceof Error ? error.message : String(error)
+  }));
+}
+async function runChatGptAppSelfTest() {
+  const checks = [];
+  checks.push(
+    await check("tool-descriptor", "Tool descriptor advertises a read-only Apps SDK evidence-pack tool.", () => {
+      const [tool] = chatGptAppToolDescriptors();
+      if (tool?.name !== CHATGPT_APP_TOOL_NAME) throw new Error("missing get_redacted_evidence_pack tool");
+      if (tool._meta.ui.resourceUri !== CHATGPT_APP_WIDGET_URI) throw new Error("tool is missing widget URI");
+      if (tool.annotations.readOnlyHint !== true) throw new Error("tool is not marked read-only");
+      if (tool.annotations.openWorldHint !== false) throw new Error("tool openWorldHint must be false");
+      if (tool.annotations.destructiveHint !== false) throw new Error("tool destructiveHint must be false");
+    })
+  );
+  checks.push(
+    await check("widget-resource", "Widget resource is a text/html;profile=mcp-app document.", () => {
+      const resource = chatGptAppWidgetResource();
+      if (resource.mimeType !== RESOURCE_MIME_TYPE) throw new Error("widget resource has wrong MIME type");
+      if (!resource.text.includes("ui/notifications/tool-result")) {
+        throw new Error("widget does not listen for MCP Apps tool results");
+      }
+    })
+  );
+  checks.push(
+    await check("tool-result", "Tool result returns a redacted evidence-pack payload.", async () => {
+      const result = await buildChatGptEvidencePackToolResult();
+      if (result.structuredContent.pack.schemaVersion !== "tokentrace.evidence-pack.v1") {
+        throw new Error("tool result has the wrong evidence-pack schema");
+      }
+      if (result.structuredContent.pack.redaction.rawContentIncluded !== false) {
+        throw new Error("tool result must not include raw content");
+      }
+    })
+  );
+  checks.push(
+    await check("server-registration", "MCP server can be constructed with Apps SDK tool and resource registrations.", () => {
+      const server = createTokenTraceChatGptAppServer();
+      void server.close();
+    })
+  );
+  return {
+    ok: checks.every((entry) => entry.ok),
+    registryName,
+    app: "TokenTrace ChatGPT app prototype",
+    mcpPath: "/mcp",
+    widgetUri: CHATGPT_APP_WIDGET_URI,
+    tools: chatGptAppToolDescriptors().map((tool) => tool.name),
+    mutatedLocalState: false,
+    checks
+  };
+}
+function widgetHtml() {
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>TokenTrace Evidence Pack</title>
+    <style>
+      :root {
+        color: #172026;
+        background: #ffffff;
+        font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+      }
+      * {
+        box-sizing: border-box;
+      }
+      body {
+        margin: 0;
+        padding: 16px;
+        color: #172026;
+        background: #ffffff;
+      }
+      main {
+        display: grid;
+        gap: 14px;
+        max-width: 680px;
+      }
+      h1, h2, p {
+        margin: 0;
+      }
+      h1 {
+        font-size: 1rem;
+        font-weight: 680;
+      }
+      h2 {
+        font-size: 0.78rem;
+        font-weight: 680;
+        color: #41515c;
+        text-transform: uppercase;
+      }
+      .summary {
+        display: grid;
+        gap: 6px;
+      }
+      .summary p {
+        color: #52616b;
+        font-size: 0.9rem;
+        line-height: 1.45;
+      }
+      .grid {
+        display: grid;
+        grid-template-columns: repeat(2, minmax(0, 1fr));
+        gap: 8px;
+      }
+      .metric {
+        border: 1px solid #d9e0e6;
+        border-radius: 8px;
+        padding: 10px;
+        min-width: 0;
+      }
+      .metric span {
+        display: block;
+        color: #5d6c76;
+        font-size: 0.74rem;
+      }
+      .metric strong {
+        display: block;
+        margin-top: 4px;
+        font-size: 1rem;
+        font-weight: 700;
+      }
+      ul {
+        margin: 0;
+        padding-left: 18px;
+        color: #36464f;
+        font-size: 0.86rem;
+        line-height: 1.45;
+      }
+      .empty {
+        color: #6d7a83;
+        font-size: 0.86rem;
+      }
+      .badge {
+        width: fit-content;
+        border: 1px solid #bfd8c5;
+        border-radius: 999px;
+        padding: 3px 8px;
+        color: #1f6b3b;
+        background: #f3fbf5;
+        font-size: 0.76rem;
+        font-weight: 620;
+      }
+      @media (max-width: 440px) {
+        body {
+          padding: 12px;
+        }
+        .grid {
+          grid-template-columns: 1fr;
+        }
+      }
+    </style>
+  </head>
+  <body>
+    <main>
+      <section class="summary">
+        <span class="badge" id="redaction">rawContentIncluded: false</span>
+        <h1 id="title">TokenTrace evidence pack</h1>
+        <p id="summary">Waiting for a redacted evidence pack.</p>
+      </section>
+      <section class="grid" aria-label="Evidence pack totals">
+        <div class="metric"><span>Tokens</span><strong id="tokens">0</strong></div>
+        <div class="metric"><span>Cost</span><strong id="cost">$0.00</strong></div>
+        <div class="metric"><span>Sessions</span><strong id="sessions">0</strong></div>
+        <div class="metric"><span>Interactions</span><strong id="interactions">0</strong></div>
+      </section>
+      <section>
+        <h2>Confidence drivers</h2>
+        <ul id="drivers"><li class="empty">No evidence loaded yet.</li></ul>
+      </section>
+      <section>
+        <h2>Source files</h2>
+        <p class="empty" id="sources">No source-file metadata loaded yet.</p>
+      </section>
+    </main>
+    <script>
+      const state = { pack: window.openai?.toolOutput?.pack ?? null, summary: window.openai?.toolOutput?.summary ?? "" };
+      const nf = new Intl.NumberFormat();
+      const usd = new Intl.NumberFormat(undefined, { style: "currency", currency: "USD" });
+
+      function setText(id, value) {
+        document.getElementById(id).textContent = value;
+      }
+
+      function renderDrivers(items) {
+        const list = document.getElementById("drivers");
+        list.textContent = "";
+        if (!items || items.length === 0) {
+          const item = document.createElement("li");
+          item.className = "empty";
+          item.textContent = "No confidence drivers reported.";
+          list.appendChild(item);
+          return;
+        }
+        for (const value of items.slice(0, 6)) {
+          const item = document.createElement("li");
+          item.textContent = value;
+          list.appendChild(item);
+        }
+      }
+
+      function render() {
+        const pack = state.pack;
+        if (!pack) return;
+        setText("title", pack.scope?.label ? "Evidence: " + pack.scope.label : "TokenTrace evidence pack");
+        setText("summary", state.summary || "Redacted evidence pack loaded.");
+        setText("tokens", nf.format(pack.totals?.tokens ?? 0));
+        setText("cost", usd.format(pack.totals?.cost ?? 0));
+        setText("sessions", nf.format(pack.totals?.sessions ?? 0));
+        setText("interactions", nf.format(pack.totals?.interactions ?? 0));
+        setText("redaction", "rawContentIncluded: " + String(pack.redaction?.rawContentIncluded === true));
+        renderDrivers(pack.confidenceDrivers);
+        setText("sources", nf.format(pack.sourceFiles?.length ?? 0) + " source file(s); " + nf.format(pack.records?.length ?? 0) + " record(s).");
+      }
+
+      window.addEventListener("message", (event) => {
+        if (event.source !== window.parent) return;
+        const message = event.data;
+        if (!message || message.jsonrpc !== "2.0") return;
+        if (message.method !== "ui/notifications/tool-result") return;
+        const data = message.params?.structuredContent;
+        state.pack = data?.pack ?? null;
+        state.summary = data?.summary ?? "";
+        render();
+      }, { passive: true });
+
+      render();
+    </script>
+  </body>
+</html>`;
+}
+
+// src/lib/chatgpt-app/server.ts
+var MCP_PATH = "/mcp";
+var MCP_METHODS = /* @__PURE__ */ new Set(["POST", "GET", "DELETE"]);
+function corsHeaders() {
+  return {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "POST, GET, DELETE, OPTIONS",
+    "Access-Control-Allow-Headers": "content-type, mcp-session-id, mcp-protocol-version",
+    "Access-Control-Expose-Headers": "Mcp-Session-Id"
+  };
+}
+function directMcpVisitHtml(mcpUrl) {
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>TokenTrace ChatGPT app prototype</title>
+    <style>
+      :root { color: #172026; background: #ffffff; font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; }
+      body { margin: 0; padding: 24px; }
+      main { max-width: 720px; display: grid; gap: 14px; }
+      h1, p { margin: 0; }
+      h1 { font-size: 1.25rem; }
+      p { color: #52616b; line-height: 1.5; }
+      code { background: #eef2f5; border: 1px solid #d8e0e6; border-radius: 6px; padding: 2px 5px; }
+      pre { white-space: pre-wrap; background: #101820; color: #edf5f7; border-radius: 8px; padding: 12px; overflow: auto; }
+    </style>
+  </head>
+  <body>
+    <main>
+      <h1>TokenTrace ChatGPT app prototype</h1>
+      <p>This is the MCP endpoint for ChatGPT developer mode and MCP clients, not a normal browser page.</p>
+      <p>Real MCP clients must call <code>${mcpUrl}</code> with an <code>Accept</code> header that includes <code>text/event-stream</code>.</p>
+      <p>For ChatGPT, expose this local server through an HTTPS tunnel and use the tunneled <code>/mcp</code> URL as the connector URL.</p>
+      <pre>tokentrace chatgpt-app selftest --json
+tokentrace chatgpt-app --port 8787 --hostname 127.0.0.1</pre>
+    </main>
+  </body>
+</html>`;
+}
+function acceptsMcpStream(req) {
+  const accept = req.headers.accept ?? "";
+  return accept.includes("text/event-stream");
+}
+function createChatGptAppHttpServer() {
+  return createServer((req, res) => {
+    void handleChatGptAppHttpRequest(req, res);
+  });
+}
+async function handleChatGptAppHttpRequest(req, res) {
+  if (!req.url) {
+    res.writeHead(400, { "content-type": "text/plain; charset=utf-8" }).end("Missing URL");
+    return;
+  }
+  const url = new URL(req.url, `http://${req.headers.host ?? "localhost"}`);
+  if (req.method === "OPTIONS" && url.pathname === MCP_PATH) {
+    res.writeHead(204, corsHeaders());
+    res.end();
+    return;
+  }
+  if (req.method === "GET" && url.pathname === "/") {
+    res.writeHead(200, { "content-type": "text/plain; charset=utf-8" }).end("TokenTrace ChatGPT app prototype. Connect ChatGPT developer mode to /mcp.");
+    return;
+  }
+  if (req.method === "GET" && url.pathname === MCP_PATH && !acceptsMcpStream(req)) {
+    res.writeHead(200, { "content-type": "text/html; charset=utf-8" }).end(directMcpVisitHtml(`${url.origin}${MCP_PATH}`));
+    return;
+  }
+  if (url.pathname === MCP_PATH && req.method && MCP_METHODS.has(req.method)) {
+    for (const [key, value] of Object.entries(corsHeaders())) {
+      res.setHeader(key, value);
+    }
+    const mcpServer = createTokenTraceChatGptAppServer();
+    const transport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: void 0,
+      enableJsonResponse: true
+    });
+    res.on("close", () => {
+      void transport.close();
+      void mcpServer.close();
+    });
+    try {
+      await mcpServer.connect(transport);
+      await transport.handleRequest(req, res);
+    } catch (error) {
+      console.error("Error handling TokenTrace ChatGPT app MCP request:", error);
+      if (!res.headersSent) {
+        res.writeHead(500, { "content-type": "text/plain; charset=utf-8" }).end("Internal server error");
+      }
+    }
+    return;
+  }
+  res.writeHead(404, { "content-type": "text/plain; charset=utf-8" }).end("Not Found");
+}
+async function listenChatGptAppServer(options = {}) {
+  const hostname = options.hostname ?? "127.0.0.1";
+  const port = options.port ?? 8787;
+  const server = createChatGptAppHttpServer();
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, hostname, () => {
+      server.off("error", reject);
+      resolve();
+    });
+  });
+  const address = server.address();
+  const actualPort = typeof address === "object" && address ? address.port : port;
+  const urlHost = hostname === "0.0.0.0" ? "127.0.0.1" : hostname;
+  const url = `http://${urlHost}:${actualPort}`;
+  return {
+    server,
+    url,
+    mcpUrl: `${url}${MCP_PATH}`,
+    close: () => new Promise((resolve, reject) => {
+      server.close((error) => {
+        if (error) reject(error);
+        else resolve();
+      });
+    })
+  };
+}
+
+// scripts/chatgpt-app.ts
+function usage() {
+  return `TokenTrace ChatGPT app prototype
+
+Usage:
+  tokentrace chatgpt-app
+  tokentrace chatgpt-app --port 8787 --hostname 127.0.0.1
+  tokentrace chatgpt-app selftest --json
+
+Options:
+  -p, --port <port>          Local HTTP port. Defaults to 8787.
+  -H, --hostname <host>      Local bind host. Defaults to 127.0.0.1.
+  -h, --help                 Print help
+
+ChatGPT developer mode requires an HTTPS-reachable /mcp URL. For local testing,
+start this server and expose it with a secure tunnel.`;
+}
+function readPort(value) {
+  const port = Number(value);
+  if (!Number.isInteger(port) || port < 0 || port > 65535) {
+    throw new Error(`Invalid --port value: ${value ?? "(missing)"}`);
+  }
+  return port;
+}
+function parseServeArgs(args2) {
+  const options = {
+    hostname: "127.0.0.1",
+    port: Number(process.env.TOKENTRACE_CHATGPT_APP_PORT ?? process.env.PORT ?? 8787)
+  };
+  for (let index2 = 0; index2 < args2.length; index2 += 1) {
+    const arg = args2[index2];
+    if (arg === "--help" || arg === "-h") {
+      process.stdout.write(`${usage()}
+`);
+      process.exit(0);
+    }
+    if (arg === "--port" || arg === "-p") {
+      options.port = readPort(args2[index2 + 1]);
+      index2 += 1;
+      continue;
+    }
+    if (arg?.startsWith("--port=")) {
+      options.port = readPort(arg.slice("--port=".length));
+      continue;
+    }
+    if (arg === "--hostname" || arg === "-H") {
+      const hostname = args2[index2 + 1];
+      if (!hostname) throw new Error("Missing --hostname value.");
+      options.hostname = hostname;
+      index2 += 1;
+      continue;
+    }
+    if (arg?.startsWith("--hostname=")) {
+      const hostname = arg.slice("--hostname=".length);
+      if (!hostname) throw new Error("Missing --hostname value.");
+      options.hostname = hostname;
+      continue;
+    }
+    throw new Error(`Unknown chatgpt-app argument: ${arg}`);
+  }
+  return options;
+}
+var args = process.argv.slice(2);
+if (args[0] === "selftest") {
+  if (args.length > 2 || args[1] && args[1] !== "--json") {
+    console.error("Usage: tokentrace chatgpt-app selftest --json");
+    process.exit(1);
+  }
+  const result = await runChatGptAppSelfTest();
+  if (args.includes("--json")) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+  } else {
+    process.stdout.write(result.ok ? "TokenTrace ChatGPT app self-test passed.\n" : "TokenTrace ChatGPT app self-test failed.\n");
+  }
+  process.exit(result.ok ? 0 : 1);
+}
+try {
+  const options = parseServeArgs(args);
+  const running = await listenChatGptAppServer(options);
+  console.log(`TokenTrace ChatGPT app prototype listening on ${running.mcpUrl}`);
+  console.log("For ChatGPT developer mode, expose this local server through an HTTPS tunnel and use the /mcp URL.");
+  const shutdown = async () => {
+    await running.close();
+    process.exit(0);
+  };
+  process.once("SIGINT", () => {
+    void shutdown();
+  });
+  process.once("SIGTERM", () => {
+    void shutdown();
+  });
+} catch (error) {
+  console.error(error instanceof Error ? error.message : error);
+  process.exit(1);
+}