zozul-cli 0.3.7 → 0.4.0

package/src/storage/repo.ts

@@ -22,29 +22,33 @@ export class SessionRepo {
 
   upsertSession(session: Omit<SessionRow, "ended_at"> & { ended_at?: string | null }): void {
     this.db.prepare(`
-      INSERT INTO sessions (id, project_path, started_at, ended_at, total_input_tokens,
-        total_output_tokens, total_cache_read_tokens, total_cache_creation_tokens,
+      INSERT INTO sessions (id, project_path, parent_session_id, agent_type, started_at, ended_at,
+        total_input_tokens, total_output_tokens, total_cache_read_tokens, total_cache_creation_tokens,
         total_cost_usd, total_turns, total_duration_ms, model)
-      VALUES (@id, @project_path, @started_at, @ended_at, @total_input_tokens,
-        @total_output_tokens, @total_cache_read_tokens, @total_cache_creation_tokens,
+      VALUES (@id, @project_path, @parent_session_id, @agent_type, @started_at, @ended_at,
+        @total_input_tokens, @total_output_tokens, @total_cache_read_tokens, @total_cache_creation_tokens,
         @total_cost_usd, @total_turns, @total_duration_ms, @model)
       ON CONFLICT(id) DO UPDATE SET
         started_at    = MIN(started_at, @started_at),
         project_path  = COALESCE(@project_path, project_path),
+        parent_session_id = COALESCE(@parent_session_id, parent_session_id),
+        agent_type    = COALESCE(@agent_type, agent_type),
         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,
+      parent_session_id: session.parent_session_id ?? null,
+      agent_type: session.agent_type ?? null,
     });
   }
 
@@ -176,28 +180,39 @@ 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 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 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 {
     if (from && to) {
-      const row = this.db.prepare(`SELECT COUNT(*) as n FROM sessions WHERE started_at >= ? AND started_at <= ?`).get(from, to) as { n: number };
+      const row = this.db.prepare(`SELECT COUNT(*) as n FROM sessions WHERE parent_session_id IS NULL AND started_at >= ? AND started_at <= ?`).get(from, to) as { n: number };
       return row.n;
     }
-    const row = this.db.prepare(`SELECT COUNT(*) as n FROM sessions`).get() as { n: number };
+    const row = this.db.prepare(`SELECT COUNT(*) as n FROM sessions WHERE parent_session_id IS NULL`).get() as { n: number };
     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[] {
+    return this.db.prepare(`
+      SELECT * FROM sessions WHERE parent_session_id = ? ORDER BY started_at ASC
+    `).all(parentSessionId) as SessionRow[];
   }
 
   getSessionTurns(sessionId: string): TurnRow[] {
@@ -221,7 +236,7 @@ export class SessionRepo {
   getAggregateStats(from?: string, to?: string) {
     if (from && to) {
       return this.db.prepare(`
-        WITH fs AS (SELECT * FROM sessions WHERE started_at >= ? AND started_at <= ?),
+        WITH fs AS (SELECT * FROM sessions WHERE parent_session_id IS NULL AND started_at >= ? AND started_at <= ?),
              fh AS (SELECT * FROM hook_events WHERE timestamp >= ? AND timestamp <= ?)
         SELECT
           (SELECT COUNT(*)                       FROM fs) as total_sessions,
@@ -237,13 +252,13 @@ export class SessionRepo {
     }
     return this.db.prepare(`
       SELECT
-        (SELECT COUNT(*) FROM sessions) as total_sessions,
-        (SELECT SUM(total_input_tokens)          FROM sessions) as total_input_tokens,
-        (SELECT SUM(total_output_tokens)         FROM sessions) as total_output_tokens,
-        (SELECT SUM(total_cache_read_tokens)     FROM sessions) as total_cache_read_tokens,
-        (SELECT SUM(total_cost_usd)              FROM sessions) as total_cost_usd,
-        (SELECT SUM(total_turns)                 FROM sessions) as total_turns,
-        (SELECT SUM(total_duration_ms)           FROM sessions) as total_duration_ms,
+        (SELECT COUNT(*) FROM sessions WHERE parent_session_id IS NULL) as total_sessions,
+        (SELECT SUM(total_input_tokens)          FROM sessions WHERE parent_session_id IS NULL) as total_input_tokens,
+        (SELECT SUM(total_output_tokens)         FROM sessions WHERE parent_session_id IS NULL) as total_output_tokens,
+        (SELECT SUM(total_cache_read_tokens)     FROM sessions WHERE parent_session_id IS NULL) as total_cache_read_tokens,
+        (SELECT SUM(total_cost_usd)              FROM sessions WHERE parent_session_id IS NULL) as total_cost_usd,
+        (SELECT SUM(total_turns)                 FROM sessions WHERE parent_session_id IS NULL) as total_turns,
+        (SELECT SUM(total_duration_ms)           FROM sessions WHERE parent_session_id IS NULL) as total_duration_ms,
         (SELECT COUNT(*) FROM hook_events WHERE event_name = 'UserPromptSubmit') as total_user_prompts,
         (SELECT COUNT(*) FROM hook_events WHERE event_name = 'Stop') as total_interruptions
     `).get();
@@ -260,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);
   }
@@ -274,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) => {
@@ -478,6 +493,7 @@ export class SessionRepo {
 
     // Only show real user turns (each row = one interaction block)
     conditions.push("t.is_real_user = 1");
+    conditions.push("t.session_id IN (SELECT id FROM sessions WHERE parent_session_id IS NULL)");
 
     const where = conditions.length > 0 ? "WHERE " + conditions.join(" AND ") : "";
     params.push(limit, offset);
@@ -601,8 +617,8 @@ 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 }[] {
-    const timeFilter = from && to ? "\n    WHERE t.timestamp >= ? AND t.timestamp <= ?" : "";
+  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] : [];
 
     return this.db.prepare(`
@@ -617,17 +633,19 @@ 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
-      JOIN sessions s ON s.id = t.session_id${timeFilter}
+      JOIN sessions s ON s.id = t.session_id
+      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((
@@ -637,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;

package/src/sync/sync.test.ts

@@ -104,6 +104,8 @@ describe("zozul sync e2e", () => {
     repo.upsertSession({
       id: "sess-001",
       project_path: "/projects/test",
+      parent_session_id: null,
+      agent_type: null,
       started_at: "2026-03-28T10:00:00Z",
       total_input_tokens: 100,
       total_output_tokens: 50,
@@ -249,6 +251,8 @@ describe("zozul sync e2e", () => {
     repo.upsertSession({
       id: "sess-002",
       project_path: null,
+      parent_session_id: null,
+      agent_type: null,
       started_at: "2026-03-28T11:00:00Z",
       total_input_tokens: 10,
       total_output_tokens: 10,
@@ -296,6 +300,8 @@ describe("zozul sync e2e", () => {
     repo.upsertSession({
       id: "sess-A",
       project_path: null,
+      parent_session_id: null,
+      agent_type: null,
       started_at: "2026-03-28T12:00:00Z",
       total_input_tokens: 10,
       total_output_tokens: 10,
@@ -330,6 +336,8 @@ describe("zozul sync e2e", () => {
     repo.upsertSession({
       id: "sess-B",
       project_path: "/new",
+      parent_session_id: null,
+      agent_type: null,
       started_at: "2026-03-28T13:00:00Z",
       total_input_tokens: 20,
       total_output_tokens: 20,
@@ -369,6 +377,8 @@ describe("zozul sync e2e", () => {
     repo.upsertSession({
       id: "sess-dry",
       project_path: null,
+      parent_session_id: null,
+      agent_type: null,
       started_at: "2026-03-28T14:00:00Z",
       total_input_tokens: 5,
       total_output_tokens: 5,
@@ -411,6 +421,8 @@ describe("zozul sync e2e", () => {
     repo.upsertSession({
       id: "sess-err",
       project_path: null,
+      parent_session_id: null,
+      agent_type: null,
       started_at: "2026-03-28T15:00:00Z",
       total_input_tokens: 10,
       total_output_tokens: 10,

package/src/sync/transform.ts

@@ -7,6 +7,8 @@ import type {
 export type ApiSession = {
   id: string;
   project_path: string | null;
+  parent_session_id: string | null;
+  agent_type: string | null;
   started_at: string;
   ended_at: string | null;
   total_input_tokens: number;
@@ -103,6 +105,8 @@ export function transformSession(row: SessionRow): ApiSession {
   return {
     id: row.id,
     project_path: row.project_path,
+    parent_session_id: row.parent_session_id,
+    agent_type: row.agent_type,
     started_at: row.started_at,
     ended_at: row.ended_at,
     total_input_tokens: row.total_input_tokens,