zozul-cli 0.3.8 → 0.4.0

package/src/storage/repo.ts

@@ -36,14 +36,14 @@ export class SessionRepo {
         ended_at      = COALESCE(@ended_at, ended_at),
         total_turns   = @total_turns,
         model         = COALESCE(@model, model),
-        -- Use MAX so OTEL values aren't clobbered by JSONL re-ingest,
-        -- but JSONL values fill in as a floor for sessions without OTEL data.
-        total_input_tokens          = MAX(total_input_tokens, @total_input_tokens),
-        total_output_tokens         = MAX(total_output_tokens, @total_output_tokens),
-        total_cache_read_tokens     = MAX(total_cache_read_tokens, @total_cache_read_tokens),
-        total_cache_creation_tokens = MAX(total_cache_creation_tokens, @total_cache_creation_tokens),
-        total_cost_usd              = MAX(total_cost_usd, @total_cost_usd),
-        total_duration_ms           = MAX(total_duration_ms, @total_duration_ms)
+        -- JSONL values act as initial estimates; recomputeSessionCostsFromOtel
+        -- overwrites with authoritative OTEL data when available.
+        total_input_tokens          = @total_input_tokens,
+        total_output_tokens         = @total_output_tokens,
+        total_cache_read_tokens     = @total_cache_read_tokens,
+        total_cache_creation_tokens = @total_cache_creation_tokens,
+        total_cost_usd              = @total_cost_usd,
+        total_duration_ms           = @total_duration_ms
     `).run({
       ...session,
       ended_at: session.ended_at ?? null,
@@ -180,15 +180,17 @@ export class SessionRepo {
     `).run(event);
   }
 
-  listSessions(limit = 50, offset = 0, from?: string, to?: string): SessionRow[] {
+  listSessions(limit = 50, offset = 0, from?: string, to?: string): (SessionRow & { user_turns: number })[] {
     if (from && to) {
       return this.db.prepare(`
-        SELECT * FROM sessions WHERE parent_session_id IS NULL AND started_at >= ? AND started_at <= ? ORDER BY started_at DESC LIMIT ? OFFSET ?
-      `).all(from, to, limit, offset) as SessionRow[];
+        SELECT s.*, (SELECT COUNT(*) FROM turns t WHERE t.session_id = s.id AND t.is_real_user = 1) as user_turns
+        FROM sessions s WHERE s.parent_session_id IS NULL AND s.started_at >= ? AND s.started_at <= ? ORDER BY s.started_at DESC LIMIT ? OFFSET ?
+      `).all(from, to, limit, offset) as (SessionRow & { user_turns: number })[];
     }
     return this.db.prepare(`
-      SELECT * FROM sessions WHERE parent_session_id IS NULL ORDER BY started_at DESC LIMIT ? OFFSET ?
-    `).all(limit, offset) as SessionRow[];
+      SELECT s.*, (SELECT COUNT(*) FROM turns t WHERE t.session_id = s.id AND t.is_real_user = 1) as user_turns
+      FROM sessions s WHERE s.parent_session_id IS NULL ORDER BY s.started_at DESC LIMIT ? OFFSET ?
+    `).all(limit, offset) as (SessionRow & { user_turns: number })[];
   }
 
   countSessions(from?: string, to?: string): number {
@@ -200,8 +202,11 @@ export class SessionRepo {
     return row.n;
   }
 
-  getSession(id: string): SessionRow | undefined {
-    return this.db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as SessionRow | undefined;
+  getSession(id: string): (SessionRow & { user_turns: number }) | undefined {
+    return this.db.prepare(`
+      SELECT s.*, (SELECT COUNT(*) FROM turns t WHERE t.session_id = s.id AND t.is_real_user = 1) as user_turns
+      FROM sessions s WHERE s.id = ?
+    `).get(id) as (SessionRow & { user_turns: number }) | undefined;
   }
 
   getSubSessions(parentSessionId: string): SessionRow[] {
@@ -270,7 +275,7 @@ export class SessionRepo {
     timestamp: string;
   }): void {
     this.db.prepare(`
-      INSERT INTO otel_metrics (name, value, attributes, session_id, model, timestamp)
+      INSERT OR IGNORE INTO otel_metrics (name, value, attributes, session_id, model, timestamp)
       VALUES (@name, @value, @attributes, @session_id, @model, @timestamp)
     `).run(metric);
   }
@@ -284,7 +289,7 @@ export class SessionRepo {
     timestamp: string;
   }[]): void {
     const stmt = this.db.prepare(`
-      INSERT INTO otel_metrics (name, value, attributes, session_id, model, timestamp)
+      INSERT OR IGNORE INTO otel_metrics (name, value, attributes, session_id, model, timestamp)
       VALUES (@name, @value, @attributes, @session_id, @model, @timestamp)
     `);
     const tx = this.db.transaction((rows: typeof metrics) => {
@@ -612,7 +617,7 @@ export class SessionRepo {
    * Fixes drift caused by late-start catch-up batches or duplicate processing.
    * Safe to call repeatedly — always produces correct values from append-only source data.
    */
-  getTaskGroups(from?: string, to?: string): { tags: string; turn_count: number; human_interventions: number; total_duration_ms: number; total_cost_usd: number; last_seen: string }[] {
+  getTaskGroups(from?: string, to?: string): { tags: string; turn_count: number; human_interventions: number; total_duration_ms: number; total_cost_usd: number; total_tokens: number; last_seen: string }[] {
     const timeFilter = from && to ? " AND t.timestamp >= ? AND t.timestamp <= ?" : "";
     const params: unknown[] = from && to ? [from, to] : [];
 
@@ -628,6 +633,7 @@ export class SessionRepo {
         SUM(CASE WHEN t.is_real_user = 1 THEN 1 ELSE 0 END) as human_interventions,
         COALESCE(SUM(t.duration_ms), 0) as total_duration_ms,
         COALESCE(SUM(${PROPORTIONAL_COST_SQL}), 0) as total_cost_usd,
+        COALESCE(SUM(t.input_tokens), 0) + COALESCE(SUM(t.output_tokens), 0) + COALESCE(SUM(t.cache_read_tokens), 0) as total_tokens,
         MAX(t.timestamp) as last_seen
       FROM turns t
       LEFT JOIN turn_tag_sets tts ON tts.turn_id = t.id
@@ -635,11 +641,11 @@ export class SessionRepo {
       WHERE s.parent_session_id IS NULL${timeFilter}
       GROUP BY COALESCE(tts.tag_set, 'Untagged')
       ORDER BY last_seen DESC
-    `).all(...params) as { tags: string; turn_count: number; human_interventions: number; total_duration_ms: number; total_cost_usd: number; last_seen: string }[];
+    `).all(...params) as { tags: string; turn_count: number; human_interventions: number; total_duration_ms: number; total_cost_usd: number; total_tokens: number; last_seen: string }[];
   }
 
   recomputeSessionCostsFromOtel(): number {
-    // Recompute from raw OTEL for sessions that have metrics
+    // Step 1: Recompute from raw OTEL for sessions that have metrics (authoritative)
     const updated = this.db.prepare(`
       UPDATE sessions SET
         total_cost_usd = COALESCE((
@@ -649,31 +655,37 @@ export class SessionRepo {
         total_input_tokens = COALESCE((
           SELECT SUM(value) FROM otel_metrics
           WHERE name = 'claude_code.token.usage' AND json_extract(attributes, '$.type') = 'input' AND session_id = sessions.id
-        ), total_input_tokens),
+        ), 0),
         total_output_tokens = COALESCE((
           SELECT SUM(value) FROM otel_metrics
           WHERE name = 'claude_code.token.usage' AND json_extract(attributes, '$.type') = 'output' AND session_id = sessions.id
-        ), total_output_tokens),
+        ), 0),
         total_cache_read_tokens = COALESCE((
           SELECT SUM(value) FROM otel_metrics
           WHERE name = 'claude_code.token.usage' AND json_extract(attributes, '$.type') = 'cacheRead' AND session_id = sessions.id
-        ), total_cache_read_tokens),
+        ), 0),
         total_cache_creation_tokens = COALESCE((
           SELECT SUM(value) FROM otel_metrics
           WHERE name = 'claude_code.token.usage' AND json_extract(attributes, '$.type') = 'cacheCreation' AND session_id = sessions.id
-        ), total_cache_creation_tokens),
-        total_duration_ms = COALESCE((
-          SELECT SUM(value) * 1000 FROM otel_metrics
-          WHERE name = 'claude_code.active_time.total' AND session_id = sessions.id
-        ), total_duration_ms)
+        ), 0)
       WHERE id IN (SELECT DISTINCT session_id FROM otel_metrics WHERE session_id IS NOT NULL)
     `).run();
 
-    // Zero out cost/duration for sessions with no OTEL backing (unverifiable)
+    // Step 2: Recompute duration from turns for all sessions
     this.db.prepare(`
-      UPDATE sessions SET total_cost_usd = 0, total_duration_ms = 0
-      WHERE (total_cost_usd > 0 OR total_duration_ms > 0)
-        AND id NOT IN (SELECT DISTINCT session_id FROM otel_metrics WHERE session_id IS NOT NULL)
+      UPDATE sessions SET
+        total_duration_ms = COALESCE((
+          SELECT SUM(duration_ms) FROM turns WHERE session_id = sessions.id
+        ), 0)
+    `).run();
+
+    // Step 3: Fallback for sessions without OTEL — use SUM(turns.cost_usd)
+    this.db.prepare(`
+      UPDATE sessions SET
+        total_cost_usd = COALESCE((
+          SELECT SUM(cost_usd) FROM turns WHERE session_id = sessions.id
+        ), 0)
+      WHERE id NOT IN (SELECT DISTINCT session_id FROM otel_metrics WHERE session_id IS NOT NULL)
     `).run();
 
     return updated.changes;