chore(app): wire all new features into app shell, store, and IPC layer

Register all new Tauri commands, update app store with browser/diff/naming
state, merge toolbar buttons into tab bar, add draggable pane dividers
with responsive vertical/horizontal layout.

Author: Swofty-Developments

Cargo.lock

@@ -55,5 +55,23 @@ pub fn run_migrations(conn: &Connection) -> rusqlite::Result<()> {
         conn.execute_batch("ALTER TABLE threads ADD COLUMN color TEXT;")?;
     }
 
+    // Usage logs table
+    conn.execute_batch(
+        "
+        CREATE TABLE IF NOT EXISTS usage_logs (
+            id TEXT PRIMARY KEY NOT NULL,
+            thread_id TEXT NOT NULL,
+            session_id 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,
+            cost_usd REAL NOT NULL DEFAULT 0,
+            model TEXT,
+            created_at TEXT NOT NULL
+        );
+        ",
+    )?;
+
     Ok(())
 }

crates/persistence/src/migrations.rs

@@ -268,6 +268,90 @@ pub fn delete_setting(conn: &Connection, key: &str) -> anyhow::Result<()> {
     Ok(())
 }
 
+// ---------------------------------------------------------------------------
+// Usage Logs
+// ---------------------------------------------------------------------------
+
+pub fn insert_usage_log(
+    conn: &Connection,
+    id: &str,
+    thread_id: &str,
+    session_id: Option<&str>,
+    input_tokens: i64,
+    output_tokens: i64,
+    cache_read_tokens: i64,
+    cache_write_tokens: i64,
+    cost_usd: f64,
+    model: Option<&str>,
+    created_at: &str,
+) -> anyhow::Result<()> {
+    conn.execute(
+        "INSERT INTO usage_logs (id, thread_id, session_id, input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, cost_usd, model, created_at) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10)",
+        params![id, thread_id, session_id, input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, cost_usd, model, created_at],
+    )?;
+    Ok(())
+}
+
+pub fn get_usage_totals(conn: &Connection) -> anyhow::Result<(i64, i64, i64, i64, f64)> {
+    let mut stmt = conn.prepare(
+        "SELECT COALESCE(SUM(input_tokens),0), COALESCE(SUM(output_tokens),0), COALESCE(SUM(cache_read_tokens),0), COALESCE(SUM(cache_write_tokens),0), COALESCE(SUM(cost_usd),0.0) FROM usage_logs",
+    )?;
+    let result = stmt.query_row([], |row| {
+        Ok((
+            row.get::<_, i64>(0)?,
+            row.get::<_, i64>(1)?,
+            row.get::<_, i64>(2)?,
+            row.get::<_, i64>(3)?,
+            row.get::<_, f64>(4)?,
+        ))
+    })?;
+    Ok(result)
+}
+
+pub fn get_usage_by_thread(conn: &Connection) -> anyhow::Result<Vec<(String, f64, i64)>> {
+    let mut stmt = conn.prepare(
+        "SELECT u.thread_id, COALESCE(SUM(u.cost_usd),0.0), COALESCE(SUM(u.input_tokens + u.output_tokens),0) FROM usage_logs u GROUP BY u.thread_id ORDER BY SUM(u.cost_usd) DESC",
+    )?;
+    let rows = stmt.query_map([], |row| {
+        Ok((
+            row.get::<_, String>(0)?,
+            row.get::<_, f64>(1)?,
+            row.get::<_, i64>(2)?,
+        ))
+    })?;
+    rows.map(|r| r.map_err(Into::into)).collect()
+}
+
+pub fn get_usage_by_model(conn: &Connection) -> anyhow::Result<Vec<(String, f64, i64)>> {
+    let mut stmt = conn.prepare(
+        "SELECT COALESCE(model,'unknown'), COALESCE(SUM(cost_usd),0.0), COALESCE(SUM(input_tokens + output_tokens),0) FROM usage_logs GROUP BY model ORDER BY SUM(cost_usd) DESC",
+    )?;
+    let rows = stmt.query_map([], |row| {
+        Ok((
+            row.get::<_, String>(0)?,
+            row.get::<_, f64>(1)?,
+            row.get::<_, i64>(2)?,
+        ))
+    })?;
+    rows.map(|r| r.map_err(Into::into)).collect()
+}
+
+pub fn get_usage_for_thread(conn: &Connection, thread_id: &str) -> anyhow::Result<(i64, i64, i64, i64, f64)> {
+    let mut stmt = conn.prepare(
+        "SELECT COALESCE(SUM(input_tokens),0), COALESCE(SUM(output_tokens),0), COALESCE(SUM(cache_read_tokens),0), COALESCE(SUM(cache_write_tokens),0), COALESCE(SUM(cost_usd),0.0) FROM usage_logs WHERE thread_id = ?1",
+    )?;
+    let result = stmt.query_row(params![thread_id], |row| {
+        Ok((
+            row.get::<_, i64>(0)?,
+            row.get::<_, i64>(1)?,
+            row.get::<_, i64>(2)?,
+            row.get::<_, i64>(3)?,
+            row.get::<_, f64>(4)?,
+        ))
+    })?;
+    Ok(result)
+}
+
 // ---------------------------------------------------------------------------
 // Internal row types for mapping from SQLite text columns
 // ---------------------------------------------------------------------------

crates/persistence/src/queries.rs

@@ -45,6 +45,15 @@ pub enum AgentEvent {
     SessionReady,
     /// An error occurred in the session.
     SessionError { message: String },
+    /// Usage/cost report for a completed turn.
+    UsageReport {
+        input_tokens: u64,
+        output_tokens: u64,
+        cache_read_tokens: u64,
+        cache_write_tokens: u64,
+        cost_usd: f64,
+        model: String,
+    },
 }
 
 /// Metadata for an active session.

crates/session/src/types.rs

@@ -7,7 +7,7 @@ edition.workspace = true
 tauri-build = { version = "2", features = [] }
 
 [dependencies]
-tauri = { version = "2", features = [] }
+tauri = { version = "2", features = ["unstable"] }
 tauri-plugin-dialog = "2"
 tauri-plugin-shell = "2"
 codeforge-session = { path = "../session" }
@@ -21,3 +21,4 @@ uuid = { workspace = true }
 chrono = { workspace = true }
 anyhow = { workspace = true }
 rusqlite = "0.31"
+url = "2"