@chrysb/alphaclaw 0.4.2 → 0.4.4

package/lib/public/js/components/usage-tab/overview-section.js

@@ -26,40 +26,78 @@ const SummaryCard = ({ title, tokens, cost }) => html`
 `;
 
 const AgentCostDistribution = ({ summary }) => {
-  const agents = Array.isArray(summary?.costByAgent?.agents) ? summary.costByAgent.agents : [];
-  const [selectedAgent, setSelectedAgent] = useState(() => String(agents[0]?.agent || ""));
+  const agents = Array.isArray(summary?.costByAgent?.agents)
+    ? summary.costByAgent.agents
+    : [];
+  const missingPricingModels = Array.from(
+    new Set(
+      (summary?.daily || [])
+        .flatMap((dayRow) => dayRow?.models || [])
+        .filter(
+          (modelRow) =>
+            !modelRow?.pricingFound && Number(modelRow?.totalTokens || 0) > 0,
+        )
+        .map(
+          (modelRow) =>
+            String(modelRow?.model || "unknown").trim() || "unknown",
+        ),
+    ),
+  ).sort((leftValue, rightValue) => leftValue.localeCompare(rightValue));
+  const missingPricingPreview = missingPricingModels.slice(0, 3).join(", ");
+  const hasMoreMissingPricingModels = missingPricingModels.length > 3;
+  const missingPricingLabel = missingPricingModels.length
+    ? hasMoreMissingPricingModels
+      ? `${missingPricingPreview}, +${missingPricingModels.length - 3} more`
+      : missingPricingPreview
+    : "";
+  const [selectedAgent, setSelectedAgent] = useState(() =>
+    String(agents[0]?.agent || ""),
+  );
   useEffect(() => {
     if (agents.length === 0) {
       if (selectedAgent) setSelectedAgent("");
       return;
     }
-    const hasSelectedAgent = agents.some((row) => String(row.agent || "") === selectedAgent);
+    const hasSelectedAgent = agents.some(
+      (row) => String(row.agent || "") === selectedAgent,
+    );
     if (!hasSelectedAgent) setSelectedAgent(String(agents[0]?.agent || ""));
   }, [agents, selectedAgent]);
   const selectedAgentRow =
-    agents.find((row) => String(row.agent || "") === selectedAgent) || agents[0] || null;
+    agents.find((row) => String(row.agent || "") === selectedAgent) ||
+    agents[0] ||
+    null;
 
   return html`
     <div class="bg-surface border border-border rounded-xl p-4">
       ${agents.length === 0
         ? html`
-            <div class="flex flex-wrap items-start sm:items-center justify-between gap-3 mb-3">
-              <h2 class="card-label text-xs">Cost breakdown</h2>
+            <div
+              class="flex flex-wrap items-start sm:items-center justify-between gap-3 mb-3"
+            >
+              <h2 class="card-label text-xs">Estimated cost breakdown</h2>
             </div>
-            <p class="text-xs text-gray-500">No agent usage recorded for this range.</p>
+            <p class="text-xs text-gray-500">
+              No agent usage recorded for this range.
+            </p>
           `
         : html`
             <div class="space-y-3">
-              <div class="flex flex-wrap items-start sm:items-center justify-between gap-3">
-                <h2 class="card-label text-xs">Cost breakdown</h2>
-                <div class="inline-flex flex-wrap items-center gap-3 text-xs text-gray-500">
-                  <span class="text-gray-300">${formatUsd(selectedAgentRow?.totalCost)}</span>
-                  <span>${formatInteger(selectedAgentRow?.totalTokens)} tok</span>
-                  <label class="inline-flex items-center gap-2 text-xs text-gray-500">
+              <div
+                class="flex flex-wrap items-start sm:items-center justify-between gap-3"
+              >
+                <h2 class="card-label text-xs">Estimated cost breakdown</h2>
+                <div
+                  class="inline-flex flex-wrap items-center gap-3 text-xs text-gray-500"
+                >
+                  <label
+                    class="inline-flex items-center gap-2 text-xs text-gray-500"
+                  >
                     <select
                       class="bg-black/30 border border-border rounded-lg text-xs px-2.5 py-1.5 text-gray-200 focus:border-gray-500"
                       value=${String(selectedAgentRow?.agent || "")}
-                      onChange=${(e) => setSelectedAgent(String(e.currentTarget?.value || ""))}
+                      onChange=${(e) =>
+                        setSelectedAgent(String(e.currentTarget?.value || ""))}
                     >
                       ${agents.map(
                         (agentRow) => html`
@@ -74,17 +112,29 @@ const AgentCostDistribution = ({ summary }) => {
               </div>
               <div class="grid grid-cols-1 sm:grid-cols-3 gap-2">
                 ${kUsageSourceOrder.map((sourceName) => {
-                  const sourceRow = (selectedAgentRow?.sourceBreakdown || []).find(
-                    (row) => String(row.source || "") === sourceName,
-                  ) || { source: sourceName, totalCost: 0, totalTokens: 0, turnCount: 0 };
+                  const sourceRow = (
+                    selectedAgentRow?.sourceBreakdown || []
+                  ).find((row) => String(row.source || "") === sourceName) || {
+                    source: sourceName,
+                    totalCost: 0,
+                    totalTokens: 0,
+                    turnCount: 0,
+                  };
                   return html`
                     <div class="ac-surface-inset px-2.5 py-2">
-                      <p class="text-[11px] text-gray-500">${renderSourceLabel(sourceRow.source)}</p>
-                      <p class="text-xs text-gray-300 mt-0.5">${formatUsd(sourceRow.totalCost)}</p>
+                      <p class="text-[11px] text-gray-500">
+                        ${renderSourceLabel(sourceRow.source)}
+                      </p>
+                      <p class="text-xs text-gray-300 mt-0.5">
+                        ${formatUsd(sourceRow.totalCost)}
+                      </p>
                       <p class="text-[11px] text-gray-500 mt-0.5">
-                        ${formatInteger(sourceRow.totalTokens)} tok
-                        ·
-                        ${formatCountLabel(sourceRow.turnCount, "turn", "turns")}
+                        ${formatInteger(sourceRow.totalTokens)} tok ·
+                        ${formatCountLabel(
+                          sourceRow.turnCount,
+                          "turn",
+                          "turns",
+                        )}
                       </p>
                     </div>
                   `;
@@ -92,6 +142,19 @@ const AgentCostDistribution = ({ summary }) => {
               </div>
             </div>
           `}
+      ${missingPricingModels.length
+        ? html`
+            <div class="mt-3">
+              <p class="text-[11px] text-gray-500">
+                <span>
+                  . Missing model pricing for ${missingPricingModels.length}
+                  ${missingPricingModels.length === 1 ? "model" : "models"}:
+                  ${missingPricingLabel}.
+                </span>
+              </p>
+            </div>
+          `
+        : null}
     </div>
   `;
 };
@@ -107,7 +170,11 @@ export const OverviewSection = ({
 }) => html`
   <div class="space-y-4">
     <div class="grid grid-cols-1 md:grid-cols-3 gap-3">
-      <${SummaryCard} title="Today" tokens=${periodSummary.today.tokens} cost=${periodSummary.today.cost} />
+      <${SummaryCard}
+        title="Today"
+        tokens=${periodSummary.today.tokens}
+        cost=${periodSummary.today.cost}
+      />
       <${SummaryCard}
         title="Last 7 days"
         tokens=${periodSummary.week.tokens}
@@ -120,11 +187,18 @@ export const OverviewSection = ({
       />
     </div>
     <div class="bg-surface border border-border rounded-xl p-4">
-      <div class="flex flex-col sm:flex-row sm:items-center justify-between gap-2 mb-3">
-        <h2 class="card-label text-xs">Daily ${metric === "tokens" ? "tokens" : "cost"} by model</h2>
+      <div
+        class="flex flex-col sm:flex-row sm:items-center justify-between gap-2 mb-3"
+      >
+        <h2 class="card-label text-xs">
+          Daily ${metric === "tokens" ? "tokens" : "cost"} by model
+        </h2>
         <div class="flex items-center gap-2">
           <${SegmentedControl}
-            options=${kRangeOptions.map((option) => ({ label: option.label, value: option.value }))}
+            options=${kRangeOptions.map((option) => ({
+              label: option.label,
+              value: option.value,
+            }))}
             value=${days}
             onChange=${onDaysChange}
           />

package/lib/public/js/lib/api.js

@@ -576,6 +576,37 @@ export const deleteBrowseFile = async (filePath) => {
   return parseJsonOrThrow(res, 'Could not delete file');
 };
 
+export const downloadBrowseFile = async (filePath) => {
+  const params = new URLSearchParams({ path: String(filePath || "") });
+  const res = await authFetch(`/api/browse/download?${params.toString()}`);
+  if (!res.ok) {
+    const errorText = await res.text();
+    throw new Error(errorText || "Could not download file");
+  }
+  const fileBlob = await res.blob();
+  const urlApi = window?.URL || URL;
+  if (!urlApi?.createObjectURL || !urlApi?.revokeObjectURL) {
+    throw new Error("Download is not supported in this browser");
+  }
+  const downloadUrl = urlApi.createObjectURL(fileBlob);
+  const fileName =
+    String(filePath || "")
+      .split("/")
+      .filter(Boolean)
+      .pop() || "download";
+  try {
+    const downloadLink = document.createElement("a");
+    downloadLink.href = downloadUrl;
+    downloadLink.download = fileName;
+    document.body?.appendChild(downloadLink);
+    downloadLink.click();
+    downloadLink.remove();
+  } finally {
+    urlApi.revokeObjectURL(downloadUrl);
+  }
+  return { ok: true };
+};
+
 export const restoreBrowseFile = async (filePath) => {
   const res = await authFetch('/api/browse/restore', {
     method: 'POST',

package/lib/server/db/usage/index.js

@@ -0,0 +1,35 @@
+const fs = require("fs");
+const path = require("path");
+const { DatabaseSync } = require("node:sqlite");
+const { ensureSchema } = require("./schema");
+const { getDailySummary } = require("./summary");
+const { getSessionsList, getSessionDetail } = require("./sessions");
+const { getSessionTimeSeries } = require("./timeseries");
+const { kGlobalModelPricing } = require("./pricing");
+
+let db = null;
+let usageDbPath = "";
+
+const ensureDb = () => {
+  if (!db) throw new Error("Usage DB not initialized");
+  return db;
+};
+
+const initUsageDb = ({ rootDir }) => {
+  const dbDir = path.join(rootDir, "db");
+  fs.mkdirSync(dbDir, { recursive: true });
+  usageDbPath = path.join(dbDir, "usage.db");
+  db = new DatabaseSync(usageDbPath);
+  ensureSchema(db);
+  return { path: usageDbPath };
+};
+
+module.exports = {
+  initUsageDb,
+  getDailySummary: (options = {}) => getDailySummary({ database: ensureDb(), ...options }),
+  getSessionsList: (options = {}) => getSessionsList({ database: ensureDb(), ...options }),
+  getSessionDetail: (options = {}) => getSessionDetail({ database: ensureDb(), ...options }),
+  getSessionTimeSeries: (options = {}) =>
+    getSessionTimeSeries({ database: ensureDb(), ...options }),
+  kGlobalModelPricing,
+};

package/lib/server/db/usage/pricing.js

@@ -0,0 +1,82 @@
+const kTokensPerMillion = 1_000_000;
+const kLongContextThresholdTokens = 200_000;
+const kGlobalModelPricing = {
+  "claude-opus-4-6": {
+    input: (tokens) => (tokens > kLongContextThresholdTokens ? 10.0 : 5.0),
+    output: (tokens) => (tokens > kLongContextThresholdTokens ? 37.5 : 25.0),
+  },
+  "claude-sonnet-4-6": { input: 3.0, output: 15.0 },
+  "claude-haiku-4-6": { input: 0.8, output: 4.0 },
+  "gpt-5": { input: 1.25, output: 10.0 },
+  "gpt-5.1-codex": { input: 2.5, output: 10.0 },
+  "gpt-5.3-codex": { input: 2.5, output: 10.0 },
+  "gpt-4.1": { input: 2.0, output: 8.0 },
+  "gpt-4o": { input: 2.5, output: 10.0 },
+  "gpt-4o-mini": { input: 0.15, output: 0.6 },
+  "gemini-3-pro-preview": { input: 2.0, output: 12.0 },
+  "gemini-3-flash-preview": { input: 0.5, output: 3.0 },
+  "gemini-2.0-flash": { input: 0.1, output: 0.4 },
+};
+
+const toInt = (value, fallbackValue = 0) => {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) ? parsed : fallbackValue;
+};
+
+const resolvePricing = (model) => {
+  const normalized = String(model || "").toLowerCase();
+  if (!normalized) return null;
+  const exact = kGlobalModelPricing[normalized];
+  if (exact) return exact;
+  const matchKey = Object.keys(kGlobalModelPricing).find((key) =>
+    normalized.includes(key),
+  );
+  return matchKey ? kGlobalModelPricing[matchKey] : null;
+};
+
+const resolvePerMillionRate = (rate, tokens) => {
+  if (typeof rate === "function") {
+    return Number(rate(toInt(tokens)));
+  }
+  return Number(rate || 0);
+};
+
+const deriveCostBreakdown = ({
+  inputTokens = 0,
+  outputTokens = 0,
+  cacheReadTokens = 0,
+  cacheWriteTokens = 0,
+  model = "",
+}) => {
+  const pricing = resolvePricing(model);
+  if (!pricing) {
+    return {
+      inputCost: 0,
+      outputCost: 0,
+      cacheReadCost: 0,
+      cacheWriteCost: 0,
+      totalCost: 0,
+      pricingFound: false,
+    };
+  }
+  const inputRate = resolvePerMillionRate(pricing.input, inputTokens);
+  const outputRate = resolvePerMillionRate(pricing.output, outputTokens);
+  const inputCost = (inputTokens / kTokensPerMillion) * inputRate;
+  const outputCost = (outputTokens / kTokensPerMillion) * outputRate;
+  const cacheReadCost = 0;
+  const cacheWriteRate = resolvePerMillionRate(pricing.input, cacheWriteTokens);
+  const cacheWriteCost = (cacheWriteTokens / kTokensPerMillion) * cacheWriteRate;
+  return {
+    inputCost,
+    outputCost,
+    cacheReadCost,
+    cacheWriteCost,
+    totalCost: inputCost + outputCost + cacheReadCost + cacheWriteCost,
+    pricingFound: true,
+  };
+};
+
+module.exports = {
+  kGlobalModelPricing,
+  deriveCostBreakdown,
+};

package/lib/server/db/usage/schema.js

@@ -0,0 +1,87 @@
+const safeAlterTable = (database, sql) => {
+  try {
+    database.exec(sql);
+  } catch (err) {
+    const message = String(err?.message || "").toLowerCase();
+    if (!message.includes("duplicate column name")) throw err;
+  }
+};
+
+const ensureSchema = (database) => {
+  database.exec("PRAGMA journal_mode=WAL;");
+  database.exec("PRAGMA synchronous=NORMAL;");
+  database.exec("PRAGMA busy_timeout=5000;");
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS usage_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      timestamp INTEGER NOT NULL,
+      session_id TEXT,
+      session_key TEXT,
+      run_id TEXT,
+      provider TEXT NOT NULL,
+      model TEXT NOT 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,
+      total_tokens INTEGER NOT NULL DEFAULT 0
+    );
+  `);
+  database.exec(`
+    CREATE INDEX IF NOT EXISTS idx_usage_events_ts
+    ON usage_events(timestamp DESC);
+  `);
+  database.exec(`
+    CREATE INDEX IF NOT EXISTS idx_usage_events_session
+    ON usage_events(session_id);
+  `);
+  safeAlterTable(
+    database,
+    "ALTER TABLE usage_events ADD COLUMN session_key TEXT;",
+  );
+  database.exec(`
+    CREATE INDEX IF NOT EXISTS idx_usage_events_session_key
+    ON usage_events(session_key);
+  `);
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS usage_daily (
+      date TEXT NOT NULL,
+      model TEXT NOT NULL,
+      provider TEXT,
+      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,
+      total_tokens INTEGER NOT NULL DEFAULT 0,
+      turn_count INTEGER NOT NULL DEFAULT 0,
+      PRIMARY KEY (date, model)
+    );
+  `);
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS tool_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      timestamp INTEGER NOT NULL,
+      session_id TEXT,
+      session_key TEXT,
+      tool_name TEXT NOT NULL,
+      success INTEGER NOT NULL DEFAULT 1,
+      duration_ms INTEGER
+    );
+  `);
+  database.exec(`
+    CREATE INDEX IF NOT EXISTS idx_tool_events_session
+    ON tool_events(session_id);
+  `);
+  safeAlterTable(
+    database,
+    "ALTER TABLE tool_events ADD COLUMN session_key TEXT;",
+  );
+  database.exec(`
+    CREATE INDEX IF NOT EXISTS idx_tool_events_session_key
+    ON tool_events(session_key);
+  `);
+};
+
+module.exports = {
+  ensureSchema,
+};

package/lib/server/db/usage/sessions.js

@@ -0,0 +1,217 @@
+const {
+  kDefaultSessionLimit,
+  kMaxSessionLimit,
+  coerceInt,
+  clampInt,
+  getUsageMetricsFromEventRow,
+} = require("./shared");
+
+const getSessionsList = ({ database, limit = kDefaultSessionLimit } = {}) => {
+  const safeLimit = clampInt(limit, 1, kMaxSessionLimit, kDefaultSessionLimit);
+  const rows = database
+    .prepare(`
+      SELECT
+        COALESCE(NULLIF(session_key, ''), NULLIF(session_id, '')) AS session_ref,
+        MAX(session_key) AS session_key,
+        MAX(session_id) AS session_id,
+        MIN(timestamp) AS first_activity_ms,
+        MAX(timestamp) AS last_activity_ms,
+        COUNT(*) AS turn_count,
+        SUM(input_tokens) AS input_tokens,
+        SUM(output_tokens) AS output_tokens,
+        SUM(cache_read_tokens) AS cache_read_tokens,
+        SUM(cache_write_tokens) AS cache_write_tokens,
+        SUM(total_tokens) AS total_tokens
+      FROM usage_events
+      WHERE COALESCE(NULLIF(session_key, ''), NULLIF(session_id, '')) IS NOT NULL
+      GROUP BY session_ref
+      ORDER BY last_activity_ms DESC
+      LIMIT $limit
+    `)
+    .all({ $limit: safeLimit });
+  return rows.map((row) => {
+    const eventRows = database
+      .prepare(`
+        SELECT
+          model,
+          input_tokens,
+          output_tokens,
+          cache_read_tokens,
+          cache_write_tokens,
+          total_tokens
+        FROM usage_events
+        WHERE COALESCE(NULLIF(session_key, ''), NULLIF(session_id, '')) = $sessionRef
+      `)
+      .all({ $sessionRef: row.session_ref });
+    let totalCost = 0;
+    const modelTokenTotals = new Map();
+    for (const eventRow of eventRows) {
+      const metrics = getUsageMetricsFromEventRow(eventRow);
+      totalCost += metrics.totalCost;
+      const model = String(eventRow.model || "");
+      modelTokenTotals.set(model, (modelTokenTotals.get(model) || 0) + metrics.totalTokens);
+    }
+    const dominantModel = Array.from(modelTokenTotals.entries())
+      .sort((a, b) => b[1] - a[1])[0]?.[0] || "";
+    return {
+      sessionId: row.session_ref,
+      sessionKey: String(row.session_key || ""),
+      rawSessionId: String(row.session_id || ""),
+      firstActivityMs: coerceInt(row.first_activity_ms),
+      lastActivityMs: coerceInt(row.last_activity_ms),
+      durationMs: Math.max(
+        0,
+        coerceInt(row.last_activity_ms) - coerceInt(row.first_activity_ms),
+      ),
+      turnCount: coerceInt(row.turn_count),
+      inputTokens: coerceInt(row.input_tokens),
+      outputTokens: coerceInt(row.output_tokens),
+      cacheReadTokens: coerceInt(row.cache_read_tokens),
+      cacheWriteTokens: coerceInt(row.cache_write_tokens),
+      totalTokens: coerceInt(row.total_tokens),
+      totalCost,
+      dominantModel,
+    };
+  });
+};
+
+const getSessionDetail = ({ database, sessionId }) => {
+  const safeSessionRef = String(sessionId || "").trim();
+  if (!safeSessionRef) return null;
+  const summaryRow = database
+    .prepare(`
+      SELECT
+        MAX(session_key) AS session_key,
+        MAX(session_id) AS session_id,
+        MIN(timestamp) AS first_activity_ms,
+        MAX(timestamp) AS last_activity_ms,
+        COUNT(*) AS turn_count,
+        SUM(input_tokens) AS input_tokens,
+        SUM(output_tokens) AS output_tokens,
+        SUM(cache_read_tokens) AS cache_read_tokens,
+        SUM(cache_write_tokens) AS cache_write_tokens,
+        SUM(total_tokens) AS total_tokens
+      FROM usage_events
+      WHERE COALESCE(NULLIF(session_key, ''), NULLIF(session_id, '')) = $sessionRef
+    `)
+    .get({ $sessionRef: safeSessionRef });
+  if (!summaryRow || !coerceInt(summaryRow.turn_count)) return null;
+
+  const modelEvents = database
+    .prepare(`
+      SELECT
+        provider,
+        model,
+        input_tokens,
+        output_tokens,
+        cache_read_tokens,
+        cache_write_tokens,
+        total_tokens
+      FROM usage_events
+      WHERE COALESCE(NULLIF(session_key, ''), NULLIF(session_id, '')) = $sessionRef
+    `)
+    .all({ $sessionRef: safeSessionRef });
+  const byProviderModel = new Map();
+  for (const eventRow of modelEvents) {
+    const provider = String(eventRow.provider || "unknown");
+    const model = String(eventRow.model || "unknown");
+    const mapKey = `${provider}\u0000${model}`;
+    if (!byProviderModel.has(mapKey)) {
+      byProviderModel.set(mapKey, {
+        provider,
+        model,
+        turnCount: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        totalTokens: 0,
+        totalCost: 0,
+        inputCost: 0,
+        outputCost: 0,
+        cacheReadCost: 0,
+        cacheWriteCost: 0,
+        pricingFound: false,
+      });
+    }
+    const aggregate = byProviderModel.get(mapKey);
+    const metrics = getUsageMetricsFromEventRow(eventRow);
+    aggregate.turnCount += 1;
+    aggregate.inputTokens += metrics.inputTokens;
+    aggregate.outputTokens += metrics.outputTokens;
+    aggregate.cacheReadTokens += metrics.cacheReadTokens;
+    aggregate.cacheWriteTokens += metrics.cacheWriteTokens;
+    aggregate.totalTokens += metrics.totalTokens;
+    aggregate.totalCost += metrics.totalCost;
+    aggregate.inputCost += metrics.inputCost;
+    aggregate.outputCost += metrics.outputCost;
+    aggregate.cacheReadCost += metrics.cacheReadCost;
+    aggregate.cacheWriteCost += metrics.cacheWriteCost;
+    aggregate.pricingFound = aggregate.pricingFound || metrics.pricingFound;
+  }
+  const modelRows = Array.from(byProviderModel.values()).sort(
+    (a, b) => b.totalTokens - a.totalTokens,
+  );
+
+  const toolRows = database
+    .prepare(`
+      SELECT
+        tool_name,
+        COUNT(*) AS call_count,
+        SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END) AS success_count,
+        SUM(CASE WHEN success = 0 THEN 1 ELSE 0 END) AS error_count,
+        AVG(duration_ms) AS avg_duration_ms,
+        MIN(duration_ms) AS min_duration_ms,
+        MAX(duration_ms) AS max_duration_ms
+      FROM tool_events
+      WHERE COALESCE(NULLIF(session_key, ''), NULLIF(session_id, '')) = $sessionRef
+      GROUP BY tool_name
+      ORDER BY call_count DESC
+    `)
+    .all({ $sessionRef: safeSessionRef })
+    .map((row) => {
+      const callCount = coerceInt(row.call_count);
+      const successCount = coerceInt(row.success_count);
+      const errorCount = coerceInt(row.error_count);
+      return {
+        toolName: row.tool_name,
+        callCount,
+        successCount,
+        errorCount,
+        errorRate: callCount > 0 ? errorCount / callCount : 0,
+        avgDurationMs: Number(row.avg_duration_ms || 0),
+        minDurationMs: coerceInt(row.min_duration_ms),
+        maxDurationMs: coerceInt(row.max_duration_ms),
+      };
+    });
+
+  const firstActivityMs = coerceInt(summaryRow.first_activity_ms);
+  const lastActivityMs = coerceInt(summaryRow.last_activity_ms);
+  const totalCost = modelRows.reduce(
+    (sum, modelRow) => sum + Number(modelRow.totalCost || 0),
+    0,
+  );
+
+  return {
+    sessionId: safeSessionRef,
+    sessionKey: String(summaryRow.session_key || ""),
+    rawSessionId: String(summaryRow.session_id || ""),
+    firstActivityMs,
+    lastActivityMs,
+    durationMs: Math.max(0, lastActivityMs - firstActivityMs),
+    turnCount: coerceInt(summaryRow.turn_count),
+    inputTokens: coerceInt(summaryRow.input_tokens),
+    outputTokens: coerceInt(summaryRow.output_tokens),
+    cacheReadTokens: coerceInt(summaryRow.cache_read_tokens),
+    cacheWriteTokens: coerceInt(summaryRow.cache_write_tokens),
+    totalTokens: coerceInt(summaryRow.total_tokens),
+    totalCost,
+    modelBreakdown: modelRows,
+    toolUsage: toolRows,
+  };
+};
+
+module.exports = {
+  getSessionsList,
+  getSessionDetail,
+};