feat: add agent mode time breakdown

- New mode_times table (session_id, mode, duration_secs)
- Sync reads $.mode and $.time.completed - $.time.created for duration
- db.rs: insert_mode_times() method for storing mode durations
- Tracks time spent in 'build', 'chat', 'read', etc. per session

Author: riyhs

src/db.rs

@@ -39,6 +39,13 @@ pub struct ToolUsage {
     pub call_count: i64,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ModeTime {
+    pub session_id: String,
+    pub mode: String,
+    pub duration_secs: i64,
+}
+
 #[derive(Debug, Clone, Default)]
 pub struct UsageSummary {
     pub total_tokens: i64,
@@ -207,6 +214,14 @@ impl Database {
                 call_count INTEGER NOT NULL DEFAULT 0,
                 PRIMARY KEY (session_id, tool_name)
             );
+
+            -- Agent mode time per session (built vs chat vs read vs etc)
+            CREATE TABLE IF NOT EXISTS mode_times (
+                session_id TEXT NOT NULL,
+                mode TEXT NOT NULL,
+                duration_secs INTEGER NOT NULL DEFAULT 0,
+                PRIMARY KEY (session_id, mode)
+            );
         ",
         )?;
 
@@ -337,6 +352,25 @@ impl Database {
         Ok(inserted)
     }
 
+    /// Insert or update mode time logs.
+    pub fn insert_mode_times(&self, modes: &[ModeTime]) -> Result<usize> {
+        let mut inserted = 0;
+        for m in modes {
+            self.conn.execute(
+                "INSERT OR REPLACE INTO mode_times
+                 (session_id, mode, duration_secs)
+                 VALUES (?1, ?2, ?3)",
+                params![
+                    m.session_id,
+                    m.mode,
+                    m.duration_secs,
+                ],
+            )?;
+            inserted += 1;
+        }
+        Ok(inserted)
+    }
+
     /// Get tool usage breakdown for sessions within the time range.
     pub fn tool_usage_by_session(&self, days: i64) -> Result<Vec<(String, i64)>> {
         let since = Self::since(days);

src/sync/opencode.rs

@@ -36,7 +36,7 @@ use std::collections::HashMap;
 
 use super::{normalise_provider, RecordBuilder};
 use crate::config::Config;
-use crate::db::{Database, SessionMeta, ToolUsage};
+use crate::db::{Database, ModeTime, SessionMeta, ToolUsage};
 
 pub fn sync(cfg: &Config, db: &Database) -> Result<usize> {
     let src_path = locate_db(cfg)?;
@@ -46,7 +46,7 @@ pub fn sync(cfg: &Config, db: &Database) -> Result<usize> {
     let last_sync = db.get_last_sync("opencode")?.unwrap_or_default();
 
     // ── Try the "standard" schema first ───────────────────────────────────────
-    let (records, metas, tool_usage) = match read_standard_schema(&src, &last_sync, cfg) {
+    let (records, metas, tool_usage, mode_times) = match read_standard_schema(&src, &last_sync, cfg) {
         Ok(r) => r,
         Err(e) => {
             // Fallback: try alternate column names seen in some builds
@@ -72,6 +72,9 @@ pub fn sync(cfg: &Config, db: &Database) -> Result<usize> {
     if !tool_usage.is_empty() {
         db.insert_tool_usage(&tool_usage)?;
     }
+    if !mode_times.is_empty() {
+        db.insert_mode_times(&mode_times)?;
+    }
     db.update_sync_state("opencode")?;
     Ok(inserted)
 }
@@ -113,7 +116,7 @@ fn read_standard_schema(
     conn: &Connection,
     since: &str,
     cfg: &Config,
-) -> Result<(Vec<crate::db::UsageRecord>, Vec<SessionMeta>, Vec<ToolUsage>)> {
+) -> Result<(Vec<crate::db::UsageRecord>, Vec<SessionMeta>, Vec<ToolUsage>, Vec<ModeTime>)> {
     let builder = RecordBuilder { source: "opencode" };
 
     // Convert RFC 3339 last_sync to Unix ms for integer comparison.
@@ -137,6 +140,8 @@ let mut stmt = conn.prepare(
              COALESCE(json_extract(m.data, '$.tokens.cacheRead'), 0) AS cache_read,
              COALESCE(json_extract(m.data, '$.tokens.cacheWrite'), 0) AS cache_write,
              COALESCE(json_extract(m.data, '$.tokens.total'), 0)    AS total_tokens,
+             COALESCE(json_extract(m.data, '$.mode'), 'unknown')    AS mode,
+             COALESCE(json_extract(m.data, '$.time.completed'), 0) - COALESCE(json_extract(m.data, '$.time.created'), 0) AS duration_ms,
              m.time_created,
              COALESCE(json_extract(m.data, '$.path.cwd'), s.directory) AS cwd,
              s.parent_id,
@@ -163,18 +168,21 @@ let mut stmt = conn.prepare(
             row.get::<_, i64>(6)?,            // cache_read_tokens
             row.get::<_, i64>(7)?,            // cache_write_tokens
             row.get::<_, i64>(8)?,            // total_tokens
-            row.get::<_, i64>(9)?,            // time_created (Unix ms)
-            row.get::<_, Option<String>>(10)?, // cwd
-            row.get::<_, Option<String>>(11)?, // parent_id
-            row.get::<_, i64>(12)?,           // additions
-            row.get::<_, i64>(13)?,           // deletions
-            row.get::<_, i64>(14)?,           // files_changed
+            row.get::<_, Option<String>>(9)?,  // mode
+            row.get::<_, i64>(10)?,           // duration_ms
+            row.get::<_, i64>(11)?,          // time_created (Unix ms)
+            row.get::<_, Option<String>>(12)?, // cwd
+            row.get::<_, Option<String>>(13)?, // parent_id
+            row.get::<_, i64>(14)?,          // additions
+            row.get::<_, i64>(15)?,          // deletions
+            row.get::<_, i64>(16)?,          // files_changed
         ))
     })?;
 
     let mut records = Vec::new();
     let mut session_metas: HashMap<String, SessionMeta> = HashMap::new();
     let mut tool_counts: HashMap<String, HashMap<String, i64>> = HashMap::new();
+    let mut mode_durations: HashMap<String, HashMap<String, i64>> = HashMap::new();
 
     // Also fetch tool calls from the part table
     let mut tool_stmt = conn.prepare(
@@ -210,6 +218,8 @@ let mut stmt = conn.prepare(
             cache_read,
             cache_write,
             total_tokens,
+            mode,
+            duration_ms,
             time_ms,
             cwd,
             parent_id,
@@ -218,6 +228,16 @@ let mut stmt = conn.prepare(
             files_changed,
         ) = row;
 
+        // Track mode time per session
+        let mode_str = mode.unwrap_or_else(|| "unknown".to_string());
+        if duration_ms > 0 {
+            let duration_sec = duration_ms / 1000;
+            mode_durations
+                .entry(session_id.clone())
+                .or_default()
+                .insert(mode_str.clone(), duration_sec);
+        }
+
         // Track session metadata (code diff summary) - accumulate per session
         let entry = session_metas.entry(session_id.clone()).or_insert(SessionMeta {
             session_id: session_id.clone(),
@@ -281,7 +301,19 @@ let mut stmt = conn.prepare(
         }
     }
 
-    Ok((records, metas, tool_usage))
+    // Convert mode_durations to ModeTime vec
+    let mut mode_times: Vec<ModeTime> = Vec::new();
+    for (session_id, modes) in mode_durations {
+        for (mode, duration) in modes {
+            mode_times.push(ModeTime {
+                session_id: session_id.clone(),
+                mode,
+                duration_secs: duration,
+            });
+        }
+    }
+
+    Ok((records, metas, tool_usage, mode_times))
 }
 
 // ── Flat-column fallback (older OpenCode builds) ──────────────────────────────
@@ -290,7 +322,7 @@ fn read_alternate_schema(
     conn: &Connection,
     since: &str,
     cfg: &Config,
-) -> Result<(Vec<crate::db::UsageRecord>, Vec<SessionMeta>, Vec<ToolUsage>)> {
+) -> Result<(Vec<crate::db::UsageRecord>, Vec<SessionMeta>, Vec<ToolUsage>, Vec<ModeTime>)> {
     let builder = RecordBuilder { source: "opencode" };
 
     // Older builds stored columns directly on the message table
@@ -353,7 +385,7 @@ fn read_alternate_schema(
         records.push(record);
     }
     // No session metadata or tool usage available in alternate schema
-    Ok((records, Vec::new(), Vec::new()))
+    Ok((records, Vec::new(), Vec::new(), Vec::new()))
 }
 
 fn infer_provider_from_model(model: &str) -> String {