tokentrace 0.8.0 → 0.8.2

package/dist/runtime/digest.mjs

@@ -1,19 +1,94 @@
 import { createRequire as __tokentraceCreateRequire } from 'node:module'; const require = __tokentraceCreateRequire(import.meta.url);
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// 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 = `
+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);
+  }
+}
+var ddl;
+var init_migrate_core = __esm({
+  "src/db/migrate-core.ts"() {
+    "use strict";
+    ddl = `
 PRAGMA journal_mode = WAL;
 PRAGMA foreign_keys = ON;
 
@@ -153,80 +228,8 @@ CREATE TABLE IF NOT EXISTS unknown_cost_reviews (
   updated_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
 );
 `;
-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/schema.ts
 var schema_exports = {};
@@ -258,220 +261,230 @@ import {
   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)
-  })
-);
-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)
-  })
-);
-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 providers, tools, models, projects, sessions, interactions, toolCalls, scanRuns, scanFiles, settings, unknownCostReviews, providerRelations, toolRelations, modelRelations, projectRelations, sessionRelations, interactionRelations;
+var init_schema = __esm({
+  "src/db/schema.ts"() {
+    "use strict";
+    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())
+    });
+    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
+        )
+      })
+    );
+    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
+        )
+      })
+    );
+    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)
+      })
+    );
+    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)
+      })
+    );
+    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)
+      })
+    );
+    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)
+      })
+    );
+    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`'[]'`)
+    });
+    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)
+      })
+    );
+    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())
+    });
+    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())
+    });
+    providerRelations = relations(providers, ({ many }) => ({
+      tools: many(tools),
+      models: many(models)
+    }));
+    toolRelations = relations(tools, ({ one, many }) => ({
+      provider: one(providers, {
+        fields: [tools.providerId],
+        references: [providers.id]
+      }),
+      sessions: many(sessions)
+    }));
+    modelRelations = relations(models, ({ one, many }) => ({
+      provider: one(providers, {
+        fields: [models.providerId],
+        references: [providers.id]
+      }),
+      interactions: many(interactions)
+    }));
+    projectRelations = relations(projects, ({ many }) => ({
+      sessions: many(sessions)
+    }));
+    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)
+    }));
+    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)
+    }));
+  }
 });
-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");
+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";
 function databaseUrlPath(value) {
   if (!value?.startsWith("file:")) return null;
   try {
@@ -480,13 +493,22 @@ function databaseUrlPath(value) {
     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("busy_timeout = 10000");
-sqlite.pragma("foreign_keys = ON");
-applyMigrations(sqlite);
-var db = drizzle(sqlite, { schema: schema_exports });
+var defaultDbPath, dbPath, sqlite, db;
+var init_client = __esm({
+  "src/db/client.ts"() {
+    "use strict";
+    init_migrate_core();
+    init_schema();
+    defaultDbPath = path.join(process.cwd(), ".tokentrace", "tokentrace.db");
+    dbPath = process.env.TOKENTRACE_DB ?? databaseUrlPath(process.env.DATABASE_URL) ?? defaultDbPath;
+    fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+    sqlite = new Database(dbPath);
+    sqlite.pragma("busy_timeout = 10000");
+    sqlite.pragma("foreign_keys = ON");
+    applyMigrations(sqlite);
+    db = drizzle(sqlite, { schema: schema_exports });
+  }
+});
 
 // src/lib/scan-health.ts
 function increment(target, key, amount = 1) {
@@ -538,7 +560,6 @@ function joinHealthParts(parts) {
   if (parts.length <= 1) return parts[0] ?? "";
   return `${parts.slice(0, -1).join(", ")} and ${parts[parts.length - 1]}`;
 }
-var staleAfterMs = 7 * 24 * 60 * 60 * 1e3;
 function isSuccessfulRun(scanRun) {
   return scanRun.completedAt != null && scanRun.recordsImported > 0 && scanRun.errors.length === 0;
 }
@@ -687,6 +708,13 @@ function buildScanHealth({
     actions
   };
 }
+var staleAfterMs;
+var init_scan_health = __esm({
+  "src/lib/scan-health.ts"() {
+    "use strict";
+    staleAfterMs = 7 * 24 * 60 * 60 * 1e3;
+  }
+});
 
 // src/lib/model-aliases.ts
 function unique(values) {
@@ -738,11 +766,17 @@ function modelNameCandidates(modelName) {
   addSnapshotDateCandidates(trimmed, candidates);
   return unique(candidates);
 }
+var init_model_aliases = __esm({
+  "src/lib/model-aliases.ts"() {
+    "use strict";
+  }
+});
 
 // src/lib/format.ts
 function formatTokens(value) {
   const number3 = value ?? 0;
-  if (number3 >= 1e6) return `${(number3 / 1e6).toFixed(2)}M`;
+  if (number3 >= 999995e3) return `${(number3 / 1e9).toFixed(2)}B`;
+  if (number3 >= 999950) return `${(number3 / 1e6).toFixed(2)}M`;
   if (number3 >= 1e3) return `${(number3 / 1e3).toFixed(1)}K`;
   return number3.toLocaleString();
 }
@@ -769,6 +803,11 @@ function formatDate(value) {
 function percent(value) {
   return `${Math.round((value ?? 0) * 100)}%`;
 }
+var init_format = __esm({
+  "src/lib/format.ts"() {
+    "use strict";
+  }
+});
 
 // src/lib/recommendations.ts
 function recommendation(id, severity, title, evidence, action2, href) {
@@ -897,17 +936,15 @@ function buildLocalRecommendations(input) {
   const rank = { high: 0, medium: 1, low: 2 };
   return recommendations.sort((a, b) => rank[a.severity] - rank[b.severity]).slice(0, 8);
 }
+var init_recommendations = __esm({
+  "src/lib/recommendations.ts"() {
+    "use strict";
+    init_format();
+  }
+});
 
 // src/db/settings.ts
 import { eq } from "drizzle-orm";
-var defaultSettings = {
-  customFolders: [],
-  storeRawMessageContent: false,
-  usageGuardrails: {
-    monthlyCostLimitUsd: null,
-    monthlyTokenLimit: null
-  }
-};
 function positiveLimit(value) {
   if (typeof value === "number" && Number.isFinite(value) && value > 0) return value;
   if (typeof value === "string" && value.trim()) {
@@ -928,8 +965,8 @@ 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") : [],
-    storeRawMessageContent: Boolean(candidate.storeRawMessageContent),
+    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)
   };
 }
@@ -937,6 +974,22 @@ function getAppSettings() {
   const row = db.select().from(settings).where(eq(settings.key, "app")).get();
   return normalizeSettings(row?.value);
 }
+var defaultSettings;
+var init_settings = __esm({
+  "src/db/settings.ts"() {
+    "use strict";
+    init_client();
+    init_schema();
+    defaultSettings = {
+      customFolders: [],
+      storeRawMessageContent: false,
+      usageGuardrails: {
+        monthlyCostLimitUsd: null,
+        monthlyTokenLimit: null
+      }
+    };
+  }
+});
 
 // src/lib/usage-guardrails.ts
 function number(value) {
@@ -1011,6 +1064,13 @@ function getUsageGuardrailProgress(now = /* @__PURE__ */ new Date()) {
     now
   });
 }
+var init_usage_guardrails = __esm({
+  "src/lib/usage-guardrails.ts"() {
+    "use strict";
+    init_client();
+    init_settings();
+  }
+});
 
 // src/lib/review-queue.ts
 function slug(value) {
@@ -1166,6 +1226,12 @@ function buildReviewQueue(input) {
   };
   return items.sort((a, b) => severityRank[a.severity] - severityRank[b.severity] || categoryRank[a.category] - categoryRank[b.category]).slice(0, 8);
 }
+var init_review_queue = __esm({
+  "src/lib/review-queue.ts"() {
+    "use strict";
+    init_format();
+  }
+});
 
 // src/lib/session-comparison.ts
 function median(values) {
@@ -1227,6 +1293,12 @@ function buildSessionComparisons(sessions2) {
   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);
 }
+var init_session_comparison = __esm({
+  "src/lib/session-comparison.ts"() {
+    "use strict";
+    init_format();
+  }
+});
 
 // src/lib/project-signals.ts
 function slug2(value) {
@@ -1335,6 +1407,12 @@ function buildProjectSignals(input) {
   };
   return signals.sort((a, b) => signalRank[a.signal] - signalRank[b.signal] || severityRank[a.severity] - severityRank[b.severity]).slice(0, 12);
 }
+var init_project_signals = __esm({
+  "src/lib/project-signals.ts"() {
+    "use strict";
+    init_format();
+  }
+});
 
 // src/lib/evidence-trail.ts
 function withQuery2(path2, params) {
@@ -1348,8 +1426,22 @@ function withQuery2(path2, params) {
 function evidenceHref(metric2, params = {}) {
   return withQuery2("/evidence", { metric: metric2, ...params });
 }
+var init_evidence_trail = __esm({
+  "src/lib/evidence-trail.ts"() {
+    "use strict";
+    init_client();
+  }
+});
 
 // src/lib/analytics.ts
+var analytics_exports = {};
+__export(analytics_exports, {
+  getAnalyticsData: () => getAnalyticsData,
+  getDebugData: () => getDebugData,
+  getPricedModelCount: () => getPricedModelCount,
+  getScanConfidenceSummary: () => getScanConfidenceSummary,
+  getScanTrustData: () => getScanTrustData
+});
 function number2(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : 0;
 }
@@ -1476,7 +1568,6 @@ function getSummary(filters = {}) {
     mostUsedModel: model?.name ?? "No data"
   };
 }
-var sevenDaysMs = 7 * 24 * 60 * 60 * 1e3;
 function comparisonSnapshot(summary) {
   return {
     totalTokens: summary.totalTokens,
@@ -2126,6 +2217,12 @@ function getAnalyticsData(filters = {}) {
     insights
   };
 }
+function getDebugData() {
+  return {
+    scanRuns: getScanRunRows(50),
+    scanFiles: getScanFileRows(500)
+  };
+}
 function getScanRunRows(limit) {
   return rows(
     `SELECT id, started_at AS startedAt, completed_at AS completedAt,
@@ -2175,26 +2272,27 @@ function getScanConfidenceSummary() {
        FROM interactions`
   ).get();
   const unknownCostCauses = sqlite.prepare(
-    `SELECT
-        COALESCE(SUM(CASE WHEN cost IS NULL AND lower(m.name) = 'unknown' THEN 1 ELSE 0 END), 0) AS missingModelName,
-        COALESCE(SUM(CASE WHEN cost IS NULL
-          AND COALESCE(i.total_tokens, 0) <= 0 THEN 1 ELSE 0 END), 0) AS missingTokenCount,
-        COALESCE(SUM(CASE WHEN cost IS NULL
-          AND lower(m.name) <> 'unknown'
-          AND COALESCE(i.total_tokens, 0) > 0
-          AND (m.input_token_price IS NULL OR m.output_token_price IS NULL)
-          THEN 1 ELSE 0 END), 0) AS missingPricing,
-        COALESCE(SUM(CASE WHEN cost IS NULL
-          AND NOT (
-            lower(m.name) = 'unknown'
-            OR COALESCE(i.total_tokens, 0) <= 0
-            OR (lower(m.name) <> 'unknown'
+    `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 1 ELSE 0 END), 0) AS other
-       FROM interactions i
-       LEFT JOIN models m ON m.id = i.model_id`
+              AND (m.input_token_price IS NULL OR m.output_token_price IS NULL)
+              THEN 'missingPricing'
+            ELSE 'other'
+          END AS cause
+        FROM interactions i
+        LEFT JOIN models m ON m.id = i.model_id
+        WHERE i.cost IS NULL
+      )
+      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();
   return {
     interactions: number2(row.interactions),
@@ -2239,8 +2337,29 @@ function getScanTrustData() {
     })
   };
 }
+var sevenDaysMs;
+var init_analytics = __esm({
+  "src/lib/analytics.ts"() {
+    "use strict";
+    init_client();
+    init_scan_health();
+    init_model_aliases();
+    init_recommendations();
+    init_usage_guardrails();
+    init_review_queue();
+    init_session_comparison();
+    init_project_signals();
+    init_evidence_trail();
+    sevenDaysMs = 7 * 24 * 60 * 60 * 1e3;
+  }
+});
 
 // src/lib/daily-digest.ts
+var daily_digest_exports = {};
+__export(daily_digest_exports, {
+  buildDailyDigest: () => buildDailyDigest,
+  renderDailyDigestText: () => renderDailyDigestText
+});
 function fallbackReviewItem() {
   return {
     id: "baseline",
@@ -2299,13 +2418,65 @@ function renderDailyDigestText(digest2) {
     digest2.latestScan ? `Latest scan: ${digest2.latestScan.headline}, ${digest2.latestScan.recordsImported.toLocaleString()} records from ${digest2.latestScan.filesScanned.toLocaleString()} files` : "Latest scan: no scan yet"
   ].join("\n");
 }
+var init_daily_digest = __esm({
+  "src/lib/daily-digest.ts"() {
+    "use strict";
+    init_format();
+  }
+});
+
+// src/lib/report-cli.ts
+function jsonReportUsage(command) {
+  return `Usage: tokentrace ${command} [--json]
+
+Options:
+  --json       Print report as JSON
+  -h, --help   Print ${command} help`;
+}
+function parseJsonReportArgs(argv) {
+  const options2 = {
+    help: false,
+    json: false
+  };
+  for (const arg of argv) {
+    if (arg === "--help" || arg === "-h") {
+      options2.help = true;
+      continue;
+    }
+    if (arg === "--json") {
+      options2.json = true;
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+  return options2;
+}
 
 // scripts/digest.ts
 var args = process.argv.slice(2);
-var data = getAnalyticsData();
-var trust = getScanTrustData();
+var options;
+try {
+  options = parseJsonReportArgs(args);
+} catch (error) {
+  console.error(error instanceof Error ? error.message : "Invalid digest arguments.");
+  console.error(jsonReportUsage("digest"));
+  process.exit(1);
+}
+if (options.help) {
+  console.log(jsonReportUsage("digest"));
+  process.exit(0);
+}
+var [{ getAnalyticsData: getAnalyticsData2, getScanTrustData: getScanTrustData2 }, { buildDailyDigest: buildDailyDigest2, renderDailyDigestText: renderDailyDigestText2 }] = await Promise.all([
+  Promise.resolve().then(() => (init_analytics(), analytics_exports)),
+  Promise.resolve().then(() => (init_daily_digest(), daily_digest_exports))
+]);
+var data = getAnalyticsData2();
+var trust = getScanTrustData2();
 var latestRun = trust.health.latestRun;
-var digest = buildDailyDigest({
+var digest = buildDailyDigest2({
   summary: data.summary,
   usageGuardrails: data.usageGuardrails,
   reviewQueue: data.reviewQueue,
@@ -2317,8 +2488,8 @@ var digest = buildDailyDigest({
     filesScanned: latestRun.filesScanned
   } : null
 });
-if (args.includes("--json")) {
+if (options.json) {
   console.log(JSON.stringify(digest, null, 2));
 } else {
-  console.log(renderDailyDigestText(digest));
+  console.log(renderDailyDigestText2(digest));
 }