Function refresh_cost_cache

src/monitor.rs:383–422

Refresh cost data from the global DB. Best-effort, non-blocking. Uses a tokio runtime because `GlobalDb` is async.

(cache: &mut CostCache)

/// Refresh cost data from the global DB. Best-effort, non-blocking.
/// Uses a tokio runtime because `GlobalDb` is async.
fn refresh_cost_cache(cache: &mut CostCache) {
    let future = async {
        let Some(gdb) = crate::global_db::GlobalDb::open().await else {
            return;
        };

        // Ingest any new data first
        crate::accounting::parser::ingest(&gdb).await;

        let now_epoch = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap_or_default()
            .as_secs();
        let today_start = now_epoch - (now_epoch % 86400);
        let week_start = now_epoch.saturating_sub(7 * 86400);

        cache.today_cost = gdb.total_cost_since(today_start).await.unwrap_or(0.0);
        cache.week_cost = gdb.total_cost_since(week_start).await.unwrap_or(0.0);

        let week_consumed = gdb.total_tokens_since(week_start).await.unwrap_or(0);
        cache.tokens_saved = gdb.global_tokens_saved().await.unwrap_or(0);

        cache.efficiency_pct = if cache.tokens_saved + week_consumed > 0 {
            (cache.tokens_saved as f64 / (cache.tokens_saved + week_consumed) as f64) * 100.0
        } else {
            0.0
        };

        let models = gdb.cost_by_model_since(today_start).await;
        if let Some((model, cost, _)) = models.first() {
            cache.top_model.clone_from(model);
            cache.top_model_cost = *cost;
        }
    };
    // monitor::run() is always invoked from inside #[tokio::main]'s
    // multi-threaded runtime, so creating a new runtime would panic.
    // Use block_in_place + the existing handle on every platform.
    tokio::task::block_in_place(|| tokio::runtime::Handle::current().block_on(future));
    cache.last_refresh = std::time::Instant::now();
}

fn monitor_loop(
    reader: &mut MmapReader,