agentfit 0.1.2 → 0.1.5

package/generated/prisma/models.ts

@@ -12,4 +12,5 @@ export type * from './models/Session'
 export type * from './models/Image'
 export type * from './models/SyncLog'
 export type * from './models/Report'
+export type * from './models/SessionAnalysis'
 export type * from './commonInputTypes'

package/lib/config.ts

@@ -0,0 +1,45 @@
+// ─── User Configuration ─────────────────────────────────────────────
+// Stored in ~/.agentfit/config.json — separate from DB and backups.
+
+import fs from 'fs'
+import path from 'path'
+import os from 'os'
+
+const CONFIG_DIR = path.join(os.homedir(), '.agentfit')
+const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json')
+
+interface Config {
+  openaiApiKey?: string
+}
+
+export function readConfig(): Config {
+  try {
+    if (!fs.existsSync(CONFIG_PATH)) return {}
+    return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'))
+  } catch {
+    return {}
+  }
+}
+
+export function writeConfig(updates: Partial<Config>) {
+  const current = readConfig()
+  const merged = { ...current, ...updates }
+
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true })
+  }
+
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(merged, null, 2) + '\n', { mode: 0o600 })
+}
+
+export function getOpenAIKey(): string | undefined {
+  return readConfig().openaiApiKey
+}
+
+export function setOpenAIKey(key: string) {
+  writeConfig({ openaiApiKey: key })
+}
+
+export function clearOpenAIKey() {
+  writeConfig({ openaiApiKey: undefined })
+}

package/lib/db.ts

@@ -3,7 +3,7 @@ import { PrismaLibSql } from '@prisma/adapter-libsql'
 import path from 'path'
 
 function createPrisma() {
-  const dbUrl = process.env.DATABASE_URL || `file:${path.resolve(process.cwd(), 'agentfit.db')}`
+  const dbUrl = `file:${path.resolve(process.cwd(), 'agentfit.db')}`
   const adapter = new PrismaLibSql({ url: dbUrl })
   return new PrismaClient({ adapter })
 }

package/lib/openai.ts

@@ -0,0 +1,253 @@
+// ─── OpenAI Message Classification Engine ──────────────────────────
+// Classifies user messages from Claude Code sessions by type, role,
+// skill level, and sentiment using OpenAI's API.
+// Ported from bizpub-cc/scripts/prepare_batch.py
+
+import OpenAI from 'openai'
+import type { ChatMessage } from './session-detail'
+
+// ─── Types ──────────────────────────────────────────────────────────
+
+export interface MessageClassification {
+  messageIndex: number
+  messagePreview: string
+  messageType: string
+  role: string
+  skillLevel: string
+  sentiment: string
+}
+
+export interface ClassificationResult {
+  classifications: MessageClassification[]
+  model: string
+  totalMessages: number
+  inputTokens: number
+  outputTokens: number
+  costUSD: number
+}
+
+export interface CostEstimate {
+  messageCount: number
+  estimatedInputTokens: number
+  estimatedOutputTokens: number
+  estimatedCostUSD: number
+}
+
+// ─── Constants ──────────────────────────────────────────────────────
+
+const MODEL = 'gpt-4.1-mini'
+
+// gpt-4.1-mini pricing (per 1M tokens)
+const INPUT_PRICE_PER_M = 0.40
+const OUTPUT_PRICE_PER_M = 1.60
+
+const SYSTEM_PROMPT = `You are a message classifier for software development conversations. Given user messages from an AI coding agent session (e.g., Claude Code, Codex), classify each on these dimensions:
+
+1. **message_type**: One of:
+   - instruction: Direct command to do something ("add a button", "fix the bug", "deploy")
+   - question: Asking for information or explanation ("how does X work?", "what's wrong?")
+   - feedback: Reacting to agent output ("looks good", "no that's wrong", "yes")
+   - context: Providing background info, pasting errors, sharing URLs/specs
+   - navigation: File/code navigation ("show me the file", "read X", "search for Y")
+   - meta: About the conversation itself ("let's move on", "forget that", "start over")
+
+2. **role**: What professional role this message implies:
+   - product_ux: UI/UX decisions, user flows, design choices, layout
+   - architect: System design, tech stack, data modeling, API design
+   - frontend_dev: UI components, styling, client-side code
+   - backend_dev: API routes, server logic, database queries, auth
+   - data_engineer: Data pipelines, parsing, ETL, batch processing
+   - domain_expert: Domain-specific knowledge, business rules
+   - qa_tester: Testing, validation, edge cases, bug reports
+   - devops: Deployment, CI/CD, environment config, hosting
+   - project_manager: Planning, priorities, scope, task management
+
+3. **skill_level**: Technical skill needed to formulate this message:
+   - non_technical: Anyone could say this, no programming knowledge needed
+   - junior: Basic programming concepts, simple instructions
+   - mid: Working knowledge of frameworks and tools
+   - senior: Deep implementation details, debugging, architecture trade-offs
+   - expert: Cutting-edge technical or deep domain expertise
+
+4. **sentiment**: Emotional tone:
+   - neutral: Matter-of-fact
+   - positive: Satisfied, excited, appreciative
+   - frustrated: Annoyed, impatient, something isn't working
+   - exploratory: Curious, brainstorming, trying things out
+
+You will receive a numbered list of user messages, each possibly with assistant context.
+Respond with ONLY a JSON array of objects in the same order, no explanation:
+[{"message_type": "...", "role": "...", "skill_level": "...", "sentiment": "..."}, ...]`
+
+// ─── Helpers ────────────────────────────────────────────────────────
+
+function truncateText(text: string, maxChars: number): string {
+  if (text.length <= maxChars) return text
+  const half = Math.floor(maxChars / 2)
+  return text.slice(0, half) + ' ... ' + text.slice(-half)
+}
+
+interface UserMessageWithContext {
+  index: number
+  text: string
+  assistantContext: string
+  preview: string
+}
+
+/**
+ * Extract user messages from a chat log with preceding assistant context.
+ */
+export function extractUserMessages(chatLog: ChatMessage[]): UserMessageWithContext[] {
+  const messages: UserMessageWithContext[] = []
+  let lastAssistantText = ''
+
+  for (const msg of chatLog) {
+    if (msg.role === 'assistant' && !msg.isThinking && !msg.toolName) {
+      lastAssistantText = msg.content
+    } else if (msg.role === 'user') {
+      const text = msg.content.trim()
+      if (!text || text.length < 3) continue
+
+      messages.push({
+        index: msg.stepIndex,
+        text: text.length > 1500 ? text.slice(0, 1500) + '... [truncated]' : text,
+        assistantContext: lastAssistantText
+          ? truncateText(lastAssistantText, 2000)
+          : '',
+        preview: text.slice(0, 80),
+      })
+    }
+  }
+
+  return messages
+}
+
+/**
+ * Estimate the cost of classifying messages without making an API call.
+ */
+export function estimateCost(messages: UserMessageWithContext[]): CostEstimate {
+  const systemChars = SYSTEM_PROMPT.length
+  let userChars = 0
+
+  for (const msg of messages) {
+    userChars += msg.text.length
+    if (msg.assistantContext) {
+      userChars += msg.assistantContext.length + 30 // "[Previous assistant message: ]\n\n"
+    }
+    userChars += 20 // numbering overhead
+  }
+
+  // Rough token estimate: ~4 chars per token
+  const inputTokens = Math.ceil((systemChars + userChars) / 4)
+  // ~50 output tokens per message (JSON classification)
+  const outputTokens = messages.length * 50
+
+  const costUSD =
+    (inputTokens / 1_000_000) * INPUT_PRICE_PER_M +
+    (outputTokens / 1_000_000) * OUTPUT_PRICE_PER_M
+
+  return {
+    messageCount: messages.length,
+    estimatedInputTokens: inputTokens,
+    estimatedOutputTokens: outputTokens,
+    estimatedCostUSD: costUSD,
+  }
+}
+
+/**
+ * Build the user prompt content for a batch of messages.
+ */
+function buildBatchPrompt(messages: UserMessageWithContext[]): string {
+  return messages
+    .map((msg, i) => {
+      const parts: string[] = [`${i + 1}.`]
+      if (msg.assistantContext) {
+        parts.push(`[Previous assistant message: ${msg.assistantContext}]`)
+      }
+      parts.push(`User message: ${msg.text}`)
+      return parts.join('\n')
+    })
+    .join('\n\n')
+}
+
+// Max messages per API call to stay within context limits
+const BATCH_SIZE = 20
+
+/**
+ * Classify user messages by calling the OpenAI API.
+ * Batches messages to reduce API calls.
+ */
+export async function classifyMessages(
+  apiKey: string,
+  messages: UserMessageWithContext[]
+): Promise<ClassificationResult> {
+  const client = new OpenAI({ apiKey })
+
+  const classifications: MessageClassification[] = []
+  let totalInputTokens = 0
+  let totalOutputTokens = 0
+
+  // Process in batches
+  for (let i = 0; i < messages.length; i += BATCH_SIZE) {
+    const batch = messages.slice(i, i + BATCH_SIZE)
+    const userContent = buildBatchPrompt(batch)
+
+    const response = await client.chat.completions.create({
+      model: MODEL,
+      messages: [
+        { role: 'system', content: SYSTEM_PROMPT },
+        { role: 'user', content: userContent },
+      ],
+      temperature: 0.0,
+      response_format: { type: 'json_object' },
+    })
+
+    const choice = response.choices[0]
+    const content = choice?.message?.content || '[]'
+
+    totalInputTokens += response.usage?.prompt_tokens || 0
+    totalOutputTokens += response.usage?.completion_tokens || 0
+
+    // Parse response — could be a JSON array or an object with an array
+    let parsed: Array<{
+      message_type?: string
+      role?: string
+      skill_level?: string
+      sentiment?: string
+    }>
+    try {
+      const raw = JSON.parse(content)
+      parsed = Array.isArray(raw) ? raw : raw.classifications || raw.results || Object.values(raw)[0] || []
+      if (!Array.isArray(parsed)) parsed = [parsed]
+    } catch {
+      // If parsing fails, skip this batch
+      continue
+    }
+
+    for (let j = 0; j < batch.length; j++) {
+      const msg = batch[j]
+      const cls = parsed[j] || {}
+      classifications.push({
+        messageIndex: msg.index,
+        messagePreview: msg.preview,
+        messageType: cls.message_type || 'unknown',
+        role: cls.role || 'unknown',
+        skillLevel: cls.skill_level || 'unknown',
+        sentiment: cls.sentiment || 'unknown',
+      })
+    }
+  }
+
+  const costUSD =
+    (totalInputTokens / 1_000_000) * INPUT_PRICE_PER_M +
+    (totalOutputTokens / 1_000_000) * OUTPUT_PRICE_PER_M
+
+  return {
+    classifications,
+    model: MODEL,
+    totalMessages: messages.length,
+    inputTokens: totalInputTokens,
+    outputTokens: totalOutputTokens,
+    costUSD,
+  }
+}

package/lib/parse-codex.ts

@@ -156,6 +156,7 @@ export function parseCodexSession(filePath: string): SessionSummary | null {
       totalTokens,
       costUSD: 0, // Codex doesn't expose per-session costs in logs
       model: model || 'gpt-5',
+      modelCounts: model ? { [model]: assistantMessages } : { 'gpt-5': assistantMessages },
       toolCalls,
       toolCallsTotal: Object.values(toolCalls).reduce((a, b) => a + b, 0),
       skillCalls: {},
@@ -164,6 +165,7 @@ export function parseCodexSession(filePath: string): SessionSummary | null {
       userInterruptions: 0,
       systemPromptEdits: 0,
       permissionModes: {},
+      cliVersion: 'codex',
     }
   } catch {
     return null

package/lib/parse-logs.ts

@@ -25,6 +25,7 @@ export interface SessionSummary {
   totalTokens: number
   costUSD: number
   model: string
+  modelCounts: Record<string, number> // per-message model counts
   toolCalls: Record<string, number>
   toolCallsTotal: number
   skillCalls: Record<string, number>
@@ -34,6 +35,7 @@ export interface SessionSummary {
   userInterruptions: number
   permissionModes: Record<string, number> // default, acceptEdits, bypassPermissions, plan
   systemPromptEdits: number // edits/writes to CLAUDE.md, AGENTS.md, agent.md
+  cliVersion: string // Claude Code CLI version from JSONL logs
 }
 
 export interface ProjectSummary {
@@ -125,6 +127,7 @@ function getProjectName(projectPath: string): string {
 
 interface LogEntry {
   type?: string
+  version?: string
   message?: {
     role?: string
     content?: unknown[]
@@ -155,12 +158,14 @@ function parseSessionFile(
     let cacheCreationTokens = 0
     let cacheReadTokens = 0
     let costUSD = 0
-    let model = ''
+    let currentModel = '' // tracks model for cost calculation per message
+    const modelCounts: Record<string, number> = {} // count messages per model
     let startTime = ''
     let endTime = ''
     const toolCalls: Record<string, number> = {}
     const permissionModes: Record<string, number> = {}
     let systemPromptEdits = 0
+    let cliVersion = ''
 
     for (const line of lines) {
       if (!line.trim()) continue
@@ -177,6 +182,10 @@ function parseSessionFile(
         endTime = entry.timestamp
       }
 
+      if (entry.version && !cliVersion) {
+        cliVersion = entry.version
+      }
+
       if (entry.type === 'user') {
         userMessages++
         // Track permission mode
@@ -190,7 +199,8 @@ function parseSessionFile(
 
         // Model
         if (msg.model && msg.model !== '<synthetic>') {
-          model = msg.model
+          currentModel = msg.model
+          modelCounts[msg.model] = (modelCounts[msg.model] || 0) + 1
         }
 
         // Usage
@@ -201,8 +211,8 @@ function parseSessionFile(
           cacheCreationTokens += u.cache_creation_input_tokens || 0
           cacheReadTokens += u.cache_read_input_tokens || 0
 
-          if (model) {
-            costUSD += calculateCost(model, u, allPricing)
+          if (currentModel) {
+            costUSD += calculateCost(currentModel, u, allPricing)
           }
         }
 
@@ -258,7 +268,8 @@ function parseSessionFile(
       cacheReadTokens,
       totalTokens: inputTokens + outputTokens + cacheCreationTokens + cacheReadTokens,
       costUSD,
-      model: model || 'unknown',
+      model: Object.entries(modelCounts).sort((a, b) => b[1] - a[1])[0]?.[0] || 'unknown',
+      modelCounts,
       toolCalls,
       toolCallsTotal: Object.values(toolCalls).reduce((a, b) => a + b, 0),
       skillCalls: {},
@@ -267,6 +278,7 @@ function parseSessionFile(
       userInterruptions: 0,
       permissionModes,
       systemPromptEdits,
+      cliVersion: cliVersion || 'unknown',
     }
   } catch {
     return null
@@ -384,10 +396,12 @@ export async function parseAllLogs(): Promise<UsageData> {
   // Build projects array sorted by cost desc
   const projects = Array.from(projectMap.values()).sort((a, b) => b.totalCost - a.totalCost)
 
-  // Build overview
+  // Build overview — aggregate model counts at message level
   const models: Record<string, number> = {}
   for (const s of sessions) {
-    models[s.model] = (models[s.model] || 0) + 1
+    for (const [m, count] of Object.entries(s.modelCounts)) {
+      models[m] = (models[m] || 0) + count
+    }
   }
 
   const overview: OverviewStats = {

package/lib/queries.ts

@@ -43,6 +43,8 @@ export async function getUsageData(): Promise<UsageData> {
     userInterruptions: s.userInterruptions,
     permissionModes: JSON.parse(s.permissionModesJson || '{}') as Record<string, number>,
     systemPromptEdits: s.systemPromptEdits,
+    cliVersion: s.cliVersion,
+    modelCounts: JSON.parse(s.modelCountsJson || '{}') as Record<string, number>,
   }))
 
   // Aggregate projects
@@ -126,7 +128,9 @@ export async function getUsageData(): Promise<UsageData> {
   const skillUsage: Record<string, number> = {}
   const permissionModes: Record<string, number> = {}
   for (const s of sessions) {
-    models[s.model] = (models[s.model] || 0) + 1
+    for (const [m, count] of Object.entries(s.modelCounts)) {
+      models[m] = (models[m] || 0) + count
+    }
     for (const [skill, count] of Object.entries(s.skillCalls)) {
       skillUsage[skill] = (skillUsage[skill] || 0) + count
     }

package/lib/sync.ts

@@ -10,6 +10,7 @@ const IMAGES_DIR = path.resolve(process.cwd(), 'data', 'images')
 interface LogEntry {
   type?: string
   uuid?: string
+  version?: string
   message?: {
     role?: string
     content?: unknown[]
@@ -73,7 +74,8 @@ function parseSessionFile(
   let cacheCreationTokens = 0
   let cacheReadTokens = 0
   let costUSD = 0
-  let model = ''
+  let currentModel = '' // tracks model for cost calculation per message
+  const modelCounts: Record<string, number> = {} // count messages per model
   let startTime = ''
   let endTime = ''
   const toolCalls: Record<string, number> = {}
@@ -85,6 +87,7 @@ function parseSessionFile(
   const skillCalls: Record<string, number> = {}
   const permissionModes: Record<string, number> = {}
   let systemPromptEdits = 0
+  let cliVersion = ''
 
   for (const line of lines) {
     if (!line.trim()) continue
@@ -101,6 +104,10 @@ function parseSessionFile(
       messageTimestamps.push(entry.timestamp)
     }
 
+    if (entry.version && !cliVersion) {
+      cliVersion = entry.version
+    }
+
     const entryType = entry.type
     const msg = entry.message
 
@@ -145,7 +152,8 @@ function parseSessionFile(
       }
 
       if (msg.model && msg.model !== '<synthetic>') {
-        model = msg.model
+        currentModel = msg.model
+        modelCounts[msg.model] = (modelCounts[msg.model] || 0) + 1
       }
 
       if (msg.usage) {
@@ -154,8 +162,8 @@ function parseSessionFile(
         outputTokens += u.output_tokens || 0
         cacheCreationTokens += u.cache_creation_input_tokens || 0
         cacheReadTokens += u.cache_read_input_tokens || 0
-        if (model) {
-          costUSD += calculateCost(model, u, allPricing)
+        if (currentModel) {
+          costUSD += calculateCost(currentModel, u, allPricing)
         }
       }
     }
@@ -242,7 +250,8 @@ function parseSessionFile(
     cacheReadTokens,
     totalTokens: inputTokens + outputTokens + cacheCreationTokens + cacheReadTokens,
     costUSD,
-    model: model || 'unknown',
+    model: Object.entries(modelCounts).sort((a, b) => b[1] - a[1])[0]?.[0] || 'unknown',
+    modelCounts,
     toolCalls,
     toolCallsTotal: Object.values(toolCalls).reduce((a, b) => a + b, 0),
     messageTimestamps,
@@ -252,6 +261,7 @@ function parseSessionFile(
     skillCalls,
     permissionModes,
     systemPromptEdits,
+    cliVersion: cliVersion || 'unknown',
     images,
   }
 }
@@ -350,6 +360,8 @@ export async function syncLogs(): Promise<SyncResult> {
             userInterruptions: parsed.userInterruptions,
             permissionModesJson: JSON.stringify(parsed.permissionModes),
             systemPromptEdits: parsed.systemPromptEdits,
+            cliVersion: parsed.cliVersion,
+            modelCountsJson: JSON.stringify(parsed.modelCounts),
           },
         })
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentfit",
-  "version": "0.1.2",
+  "version": "0.1.5",
   "description": "Fitness tracker dashboard for AI coding agents (Claude Code, Codex). Visualize usage, cost, tokens, and productivity from local conversation logs.",
   "type": "module",
   "bin": {
@@ -55,6 +55,7 @@
     "lucide-react": "^1.7.0",
     "next": "16.1.7",
     "next-themes": "^0.4.6",
+    "openai": "^6.33.0",
     "prisma": "^7.6.0",
     "react": "^19.2.4",
     "react-dom": "^19.2.4",

package/prisma/migrations/20260404151230_add_session_analysis/migration.sql

@@ -0,0 +1,18 @@
+-- CreateTable
+CREATE TABLE "SessionAnalysis" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "sessionId" TEXT NOT NULL,
+    "model" TEXT NOT NULL,
+    "classifications" TEXT NOT NULL,
+    "totalMessages" INTEGER NOT NULL,
+    "inputTokens" INTEGER NOT NULL,
+    "outputTokens" INTEGER NOT NULL,
+    "costUSD" REAL NOT NULL,
+    "analyzedAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "SessionAnalysis_sessionId_key" ON "SessionAnalysis"("sessionId");
+
+-- CreateIndex
+CREATE INDEX "SessionAnalysis_sessionId_idx" ON "SessionAnalysis"("sessionId");

package/prisma/migrations/20260405230736_add_cli_version/migration.sql

@@ -0,0 +1,41 @@
+-- RedefineTables
+PRAGMA defer_foreign_keys=ON;
+PRAGMA foreign_keys=OFF;
+CREATE TABLE "new_Session" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "sessionId" TEXT NOT NULL,
+    "project" TEXT NOT NULL,
+    "projectPath" TEXT NOT NULL,
+    "startTime" DATETIME NOT NULL,
+    "endTime" DATETIME NOT NULL,
+    "durationMinutes" REAL NOT NULL,
+    "userMessages" INTEGER NOT NULL,
+    "assistantMessages" INTEGER NOT NULL,
+    "totalMessages" INTEGER NOT NULL,
+    "inputTokens" INTEGER NOT NULL,
+    "outputTokens" INTEGER NOT NULL,
+    "cacheCreationTokens" INTEGER NOT NULL,
+    "cacheReadTokens" INTEGER NOT NULL,
+    "totalTokens" INTEGER NOT NULL,
+    "costUSD" REAL NOT NULL,
+    "model" TEXT NOT NULL,
+    "toolCallsTotal" INTEGER NOT NULL,
+    "toolCallsJson" TEXT NOT NULL,
+    "skillCallsJson" TEXT NOT NULL DEFAULT '{}',
+    "messageTimestamps" TEXT NOT NULL DEFAULT '[]',
+    "apiErrors" INTEGER NOT NULL DEFAULT 0,
+    "rateLimitErrors" INTEGER NOT NULL DEFAULT 0,
+    "userInterruptions" INTEGER NOT NULL DEFAULT 0,
+    "permissionModesJson" TEXT NOT NULL DEFAULT '{}',
+    "systemPromptEdits" INTEGER NOT NULL DEFAULT 0,
+    "cliVersion" TEXT NOT NULL DEFAULT 'unknown',
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+INSERT INTO "new_Session" ("apiErrors", "assistantMessages", "cacheCreationTokens", "cacheReadTokens", "costUSD", "createdAt", "durationMinutes", "endTime", "id", "inputTokens", "messageTimestamps", "model", "outputTokens", "permissionModesJson", "project", "projectPath", "rateLimitErrors", "sessionId", "skillCallsJson", "startTime", "systemPromptEdits", "toolCallsJson", "toolCallsTotal", "totalMessages", "totalTokens", "userInterruptions", "userMessages") SELECT "apiErrors", "assistantMessages", "cacheCreationTokens", "cacheReadTokens", "costUSD", "createdAt", "durationMinutes", "endTime", "id", "inputTokens", "messageTimestamps", "model", "outputTokens", "permissionModesJson", "project", "projectPath", "rateLimitErrors", "sessionId", "skillCallsJson", "startTime", "systemPromptEdits", "toolCallsJson", "toolCallsTotal", "totalMessages", "totalTokens", "userInterruptions", "userMessages" FROM "Session";
+DROP TABLE "Session";
+ALTER TABLE "new_Session" RENAME TO "Session";
+CREATE UNIQUE INDEX "Session_sessionId_key" ON "Session"("sessionId");
+CREATE INDEX "Session_project_idx" ON "Session"("project");
+CREATE INDEX "Session_startTime_idx" ON "Session"("startTime");
+PRAGMA foreign_keys=ON;
+PRAGMA defer_foreign_keys=OFF;

package/prisma/migrations/20260406205546_add_model_counts/migration.sql

@@ -0,0 +1,42 @@
+-- RedefineTables
+PRAGMA defer_foreign_keys=ON;
+PRAGMA foreign_keys=OFF;
+CREATE TABLE "new_Session" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "sessionId" TEXT NOT NULL,
+    "project" TEXT NOT NULL,
+    "projectPath" TEXT NOT NULL,
+    "startTime" DATETIME NOT NULL,
+    "endTime" DATETIME NOT NULL,
+    "durationMinutes" REAL NOT NULL,
+    "userMessages" INTEGER NOT NULL,
+    "assistantMessages" INTEGER NOT NULL,
+    "totalMessages" INTEGER NOT NULL,
+    "inputTokens" INTEGER NOT NULL,
+    "outputTokens" INTEGER NOT NULL,
+    "cacheCreationTokens" INTEGER NOT NULL,
+    "cacheReadTokens" INTEGER NOT NULL,
+    "totalTokens" INTEGER NOT NULL,
+    "costUSD" REAL NOT NULL,
+    "model" TEXT NOT NULL,
+    "toolCallsTotal" INTEGER NOT NULL,
+    "toolCallsJson" TEXT NOT NULL,
+    "skillCallsJson" TEXT NOT NULL DEFAULT '{}',
+    "messageTimestamps" TEXT NOT NULL DEFAULT '[]',
+    "apiErrors" INTEGER NOT NULL DEFAULT 0,
+    "rateLimitErrors" INTEGER NOT NULL DEFAULT 0,
+    "userInterruptions" INTEGER NOT NULL DEFAULT 0,
+    "permissionModesJson" TEXT NOT NULL DEFAULT '{}',
+    "systemPromptEdits" INTEGER NOT NULL DEFAULT 0,
+    "cliVersion" TEXT NOT NULL DEFAULT 'unknown',
+    "modelCountsJson" TEXT NOT NULL DEFAULT '{}',
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+INSERT INTO "new_Session" ("apiErrors", "assistantMessages", "cacheCreationTokens", "cacheReadTokens", "cliVersion", "costUSD", "createdAt", "durationMinutes", "endTime", "id", "inputTokens", "messageTimestamps", "model", "outputTokens", "permissionModesJson", "project", "projectPath", "rateLimitErrors", "sessionId", "skillCallsJson", "startTime", "systemPromptEdits", "toolCallsJson", "toolCallsTotal", "totalMessages", "totalTokens", "userInterruptions", "userMessages") SELECT "apiErrors", "assistantMessages", "cacheCreationTokens", "cacheReadTokens", "cliVersion", "costUSD", "createdAt", "durationMinutes", "endTime", "id", "inputTokens", "messageTimestamps", "model", "outputTokens", "permissionModesJson", "project", "projectPath", "rateLimitErrors", "sessionId", "skillCallsJson", "startTime", "systemPromptEdits", "toolCallsJson", "toolCallsTotal", "totalMessages", "totalTokens", "userInterruptions", "userMessages" FROM "Session";
+DROP TABLE "Session";
+ALTER TABLE "new_Session" RENAME TO "Session";
+CREATE UNIQUE INDEX "Session_sessionId_key" ON "Session"("sessionId");
+CREATE INDEX "Session_project_idx" ON "Session"("project");
+CREATE INDEX "Session_startTime_idx" ON "Session"("startTime");
+PRAGMA foreign_keys=ON;
+PRAGMA defer_foreign_keys=OFF;