@praeviso/code-env-switch 0.1.4 → 0.1.6

package/src/usage/index.ts

@@ -4,23 +4,37 @@
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
-import type { Config, ProfileType } from "../types";
+import type { Config, Profile, ProfileType } from "../types";
 import { resolvePath } from "../shell/utils";
 import { normalizeType, inferProfileType, getProfileDisplayName } from "../profile/type";
+import { getStatuslineDebugPath } from "../statusline/debug";
+import { calculateUsageCost, resolvePricingForProfile } from "./pricing";
 
 interface UsageRecord {
     ts: string;
     type: string;
     profileKey: string | null;
     profileName: string | null;
+    model: string | null;
+    sessionId?: string | null;
     inputTokens: number;
     outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
     totalTokens: number;
 }
 
 interface UsageTotals {
     today: number;
     total: number;
+    todayInput: number;
+    totalInput: number;
+    todayOutput: number;
+    totalOutput: number;
+    todayCacheRead: number;
+    totalCacheRead: number;
+    todayCacheWrite: number;
+    totalCacheWrite: number;
 }
 
 interface UsageTotalsIndex {
@@ -28,32 +42,63 @@ interface UsageTotalsIndex {
     byName: Map<string, UsageTotals>;
 }
 
+interface UsageCostTotals {
+    today: number;
+    total: number;
+    todayTokens: number;
+    totalTokens: number;
+}
+
+interface UsageCostIndex {
+    byKey: Map<string, UsageCostTotals>;
+    byName: Map<string, UsageCostTotals>;
+}
+
+export interface UsageCleanupFailure {
+    path: string;
+    error: string;
+}
+
+export interface UsageCleanupResult {
+    removed: string[];
+    missing: string[];
+    failed: UsageCleanupFailure[];
+}
+
 interface UsageStateEntry {
     mtimeMs: number;
     size: number;
     type: ProfileType;
     inputTokens: number;
     outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
     totalTokens: number;
     startTs: string | null;
     endTs: string | null;
     cwd: string | null;
+    model?: string | null;
 }
 
 interface UsageSessionEntry {
     type: ProfileType;
     inputTokens: number;
     outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
     totalTokens: number;
     startTs: string | null;
     endTs: string | null;
     cwd: string | null;
+    model?: string | null;
 }
 
 interface UsageStateFile {
     version: number;
     files: Record<string, UsageStateEntry>;
     sessions?: Record<string, UsageSessionEntry>;
+    usageMtimeMs?: number;
+    usageSize?: number;
 }
 
 interface ProfileLogEntry {
@@ -82,19 +127,46 @@ interface ProfileResolveResult {
 interface SessionStats {
     inputTokens: number;
     outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
     totalTokens: number;
     startTs: string | null;
     endTs: string | null;
     cwd: string | null;
     sessionId: string | null;
+    model: string | null;
 }
 
 interface UsageTotalsInput {
     inputTokens: number | null;
     outputTokens: number | null;
+    cacheReadTokens: number | null;
+    cacheWriteTokens: number | null;
     totalTokens: number | null;
 }
 
+function resolveProfileForRecord(
+    config: Config,
+    type: string | null,
+    record: UsageRecord
+): Profile | null {
+    if (record.profileKey && config.profiles && config.profiles[record.profileKey]) {
+        return config.profiles[record.profileKey];
+    }
+    if (record.profileName && config.profiles) {
+        const matches = Object.entries(config.profiles).find(([key, entry]) => {
+            const displayName = getProfileDisplayName(key, entry, type || undefined);
+            return (
+                displayName === record.profileName ||
+                entry.name === record.profileName ||
+                key === record.profileName
+            );
+        });
+        if (matches) return matches[1];
+    }
+    return null;
+}
+
 function resolveDefaultConfigDir(configPath: string | null): string {
     if (configPath) return path.dirname(configPath);
     return path.join(os.homedir(), ".config", "code-env");
@@ -141,40 +213,175 @@ export function formatTokenCount(value: number | null | undefined): string {
     return `${(value / 1_000_000_000).toFixed(2)}B`;
 }
 
-export function buildUsageTotals(records: UsageRecord[]): UsageTotalsIndex {
-    const byKey = new Map<string, UsageTotals>();
-    const byName = new Map<string, UsageTotals>();
+function createUsageTotals(): UsageTotals {
+    return {
+        today: 0,
+        total: 0,
+        todayInput: 0,
+        totalInput: 0,
+        todayOutput: 0,
+        totalOutput: 0,
+        todayCacheRead: 0,
+        totalCacheRead: 0,
+        todayCacheWrite: 0,
+        totalCacheWrite: 0,
+    };
+}
+
+function createUsageCostTotals(): UsageCostTotals {
+    return { today: 0, total: 0, todayTokens: 0, totalTokens: 0 };
+}
+
+function toUsageNumber(value: number | null | undefined): number {
+    const num = Number(value ?? 0);
+    return Number.isFinite(num) ? num : 0;
+}
+
+function getTodayWindow(): { startMs: number; endMs: number } {
     const todayStart = new Date();
     todayStart.setHours(0, 0, 0, 0);
-    const todayStartMs = todayStart.getTime();
+    const startMs = todayStart.getTime();
     const tomorrowStart = new Date(todayStart);
     tomorrowStart.setDate(todayStart.getDate() + 1);
-    const tomorrowStartMs = tomorrowStart.getTime();
+    return { startMs, endMs: tomorrowStart.getTime() };
+}
+
+function isTimestampInWindow(
+    ts: string,
+    startMs: number,
+    endMs: number
+): boolean {
+    if (!ts) return false;
+    const time = new Date(ts).getTime();
+    if (Number.isNaN(time)) return false;
+    return time >= startMs && time < endMs;
+}
+
+export function buildUsageTotals(records: UsageRecord[]): UsageTotalsIndex {
+    const byKey = new Map<string, UsageTotals>();
+    const byName = new Map<string, UsageTotals>();
+    const { startMs, endMs } = getTodayWindow();
 
     const isToday = (ts: string) => {
-        if (!ts) return false;
-        const time = new Date(ts).getTime();
-        if (Number.isNaN(time)) return false;
-        return time >= todayStartMs && time < tomorrowStartMs;
+        return isTimestampInWindow(ts, startMs, endMs);
     };
 
-    const addTotals = (map: Map<string, UsageTotals>, key: string, amount: number, ts: string) => {
+    const addTotals = (
+        map: Map<string, UsageTotals>,
+        key: string,
+        amounts: {
+            total: number;
+            input: number;
+            output: number;
+            cacheRead: number;
+            cacheWrite: number;
+        },
+        ts: string
+    ) => {
         if (!key) return;
-        const current = map.get(key) || { today: 0, total: 0 };
-        current.total += amount;
-        if (isToday(ts)) current.today += amount;
+        const current = map.get(key) || createUsageTotals();
+        current.total += amounts.total;
+        current.totalInput += amounts.input;
+        current.totalOutput += amounts.output;
+        current.totalCacheRead += amounts.cacheRead;
+        current.totalCacheWrite += amounts.cacheWrite;
+        if (isToday(ts)) {
+            current.today += amounts.total;
+            current.todayInput += amounts.input;
+            current.todayOutput += amounts.output;
+            current.todayCacheRead += amounts.cacheRead;
+            current.todayCacheWrite += amounts.cacheWrite;
+        }
         map.set(key, current);
     };
 
     for (const record of records) {
         const type = normalizeUsageType(record.type) || "";
-        const total = Number(record.totalTokens || 0);
+        const input = toUsageNumber(record.inputTokens);
+        const output = toUsageNumber(record.outputTokens);
+        const cacheRead = toUsageNumber(record.cacheReadTokens);
+        const cacheWrite = toUsageNumber(record.cacheWriteTokens);
+        const computedTotal = input + output + cacheRead + cacheWrite;
+        const rawTotal = Number(record.totalTokens ?? computedTotal);
+        const total = Number.isFinite(rawTotal)
+            ? Math.max(rawTotal, computedTotal)
+            : computedTotal;
         if (!Number.isFinite(total)) continue;
         if (record.profileKey) {
-            addTotals(byKey, `${type}||${record.profileKey}`, total, record.ts);
+            addTotals(
+                byKey,
+                `${type}||${record.profileKey}`,
+                { total, input, output, cacheRead, cacheWrite },
+                record.ts
+            );
         }
         if (record.profileName) {
-            addTotals(byName, `${type}||${record.profileName}`, total, record.ts);
+            addTotals(
+                byName,
+                `${type}||${record.profileName}`,
+                { total, input, output, cacheRead, cacheWrite },
+                record.ts
+            );
+        }
+    }
+
+    return { byKey, byName };
+}
+
+function buildUsageCostIndex(records: UsageRecord[], config: Config): UsageCostIndex {
+    const byKey = new Map<string, UsageCostTotals>();
+    const byName = new Map<string, UsageCostTotals>();
+    const { startMs, endMs } = getTodayWindow();
+
+    const addCost = (
+        map: Map<string, UsageCostTotals>,
+        key: string,
+        cost: number,
+        tokens: number,
+        ts: string
+    ) => {
+        if (!key) return;
+        const current = map.get(key) || createUsageCostTotals();
+        current.total += cost;
+        current.totalTokens += tokens;
+        if (isTimestampInWindow(ts, startMs, endMs)) {
+            current.today += cost;
+            current.todayTokens += tokens;
+        }
+        map.set(key, current);
+    };
+
+    for (const record of records) {
+        const model = normalizeModelValue(record.model);
+        if (!model) continue;
+        const type = normalizeUsageType(record.type) || "";
+        const profile =
+            record.profileKey && config.profiles ? config.profiles[record.profileKey] : null;
+        const pricing = resolvePricingForProfile(config, profile || null, model);
+        if (!pricing) continue;
+        const cost = calculateUsageCost(
+            {
+                totalTokens: record.totalTokens,
+                inputTokens: record.inputTokens,
+                outputTokens: record.outputTokens,
+                cacheReadTokens: record.cacheReadTokens,
+                cacheWriteTokens: record.cacheWriteTokens,
+            },
+            pricing
+        );
+        if (cost === null || !Number.isFinite(cost)) continue;
+        const billedTokens =
+            toUsageNumber(record.inputTokens) +
+            toUsageNumber(record.outputTokens) +
+            toUsageNumber(record.cacheReadTokens) +
+            toUsageNumber(record.cacheWriteTokens);
+        const billedTotal =
+            billedTokens > 0 ? billedTokens : toUsageNumber(record.totalTokens);
+        if (record.profileKey) {
+            addCost(byKey, `${type}||${record.profileKey}`, cost, billedTotal, record.ts);
+        }
+        if (record.profileName) {
+            addCost(byName, `${type}||${record.profileName}`, cost, billedTotal, record.ts);
         }
     }
 
@@ -189,6 +396,12 @@ function normalizeUsageType(type: string | null | undefined): string | null {
     return trimmed ? trimmed : null;
 }
 
+function normalizeModelValue(value: unknown): string | null {
+    if (typeof value !== "string") return null;
+    const trimmed = value.trim();
+    return trimmed ? trimmed : null;
+}
+
 function buildSessionKey(type: ProfileType | null, sessionId: string): string {
     const normalized = normalizeUsageType(type || "");
     return normalized ? `${normalized}::${sessionId}` : sessionId;
@@ -226,6 +439,72 @@ export function readUsageTotalsIndex(
     return buildUsageTotals(records);
 }
 
+export function readUsageCostIndex(
+    config: Config,
+    configPath: string | null,
+    syncUsage: boolean
+): UsageCostIndex | null {
+    const usagePath = getUsagePath(config, configPath);
+    if (!usagePath) return null;
+    if (syncUsage) {
+        syncUsageFromSessions(config, configPath, usagePath);
+    }
+    const records = readUsageRecords(usagePath);
+    if (records.length === 0) return null;
+    const costs = buildUsageCostIndex(records, config);
+    if (costs.byKey.size === 0 && costs.byName.size === 0) return null;
+    return costs;
+}
+
+export function readUsageSessionCost(
+    config: Config,
+    configPath: string | null,
+    type: string | null,
+    sessionId: string | null,
+    syncUsage: boolean
+): number | null {
+    if (!sessionId) return null;
+    const usagePath = getUsagePath(config, configPath);
+    if (!usagePath) return null;
+    if (syncUsage) {
+        syncUsageFromSessions(config, configPath, usagePath);
+    }
+    const records = readUsageRecords(usagePath);
+    if (records.length === 0) return null;
+    const normalizedType = normalizeUsageType(type);
+    let total = 0;
+    let hasCost = false;
+    for (const record of records) {
+        if (!record.sessionId) continue;
+        if (record.sessionId !== sessionId) continue;
+        if (
+            normalizedType &&
+            normalizeUsageType(record.type) !== normalizedType
+        ) {
+            continue;
+        }
+        const model = normalizeModelValue(record.model);
+        if (!model) continue;
+        const profile = resolveProfileForRecord(config, normalizedType, record);
+        const pricing = resolvePricingForProfile(config, profile, model);
+        if (!pricing) continue;
+        const cost = calculateUsageCost(
+            {
+                totalTokens: record.totalTokens,
+                inputTokens: record.inputTokens,
+                outputTokens: record.outputTokens,
+                cacheReadTokens: record.cacheReadTokens,
+                cacheWriteTokens: record.cacheWriteTokens,
+            },
+            pricing
+        );
+        if (cost === null || !Number.isFinite(cost)) continue;
+        total += cost;
+        hasCost = true;
+    }
+    return hasCost ? total : null;
+}
+
 export function resolveUsageTotalsForProfile(
     totals: UsageTotalsIndex,
     type: string | null,
@@ -241,6 +520,21 @@ export function resolveUsageTotalsForProfile(
     );
 }
 
+export function resolveUsageCostForProfile(
+    costs: UsageCostIndex,
+    type: string | null,
+    profileKey: string | null,
+    profileName: string | null
+): UsageCostTotals | null {
+    const keyLookup = buildUsageLookupKey(type, profileKey);
+    const nameLookup = buildUsageLookupKey(type, profileName);
+    return (
+        (keyLookup && costs.byKey.get(keyLookup)) ||
+        (nameLookup && costs.byName.get(nameLookup)) ||
+        null
+    );
+}
+
 export function syncUsageFromStatuslineInput(
     config: Config,
     configPath: string | null,
@@ -249,19 +543,28 @@ export function syncUsageFromStatuslineInput(
     profileName: string | null,
     sessionId: string | null,
     totals: UsageTotalsInput | null,
-    cwd: string | null
+    cwd: string | null,
+    model: string | null
 ): void {
     if (!sessionId) return;
     if (!totals) return;
     if (!profileKey && !profileName) return;
+    const resolvedModel = normalizeModelValue(model);
+    if (!resolvedModel) return;
     const normalizedType = normalizeType(type || "");
     if (!normalizedType) return;
     const usagePath = getUsagePath(config, configPath);
     if (!usagePath) return;
     const inputTokens = toFiniteNumber(totals.inputTokens) ?? 0;
     const outputTokens = toFiniteNumber(totals.outputTokens) ?? 0;
+    const cacheReadTokens = toFiniteNumber(totals.cacheReadTokens) ?? 0;
+    const cacheWriteTokens = toFiniteNumber(totals.cacheWriteTokens) ?? 0;
     const totalTokens =
-        toFiniteNumber(totals.totalTokens) ?? inputTokens + outputTokens;
+        toFiniteNumber(totals.totalTokens) ??
+        inputTokens +
+            outputTokens +
+            cacheReadTokens +
+            cacheWriteTokens;
     if (!Number.isFinite(totalTokens)) return;
 
     const statePath = getUsageStatePath(usagePath, config);
@@ -273,17 +576,37 @@ export function syncUsageFromStatuslineInput(
         const sessions = state.sessions || {};
         const key = buildSessionKey(normalizedType, sessionId);
         const prev = sessions[key];
-        const prevInput = prev ? prev.inputTokens : 0;
-        const prevOutput = prev ? prev.outputTokens : 0;
-        const prevTotal = prev ? prev.totalTokens : 0;
+        const prevInput = prev ? toUsageNumber(prev.inputTokens) : 0;
+        const prevOutput = prev ? toUsageNumber(prev.outputTokens) : 0;
+        const prevCacheRead = prev ? toUsageNumber(prev.cacheReadTokens) : 0;
+        const prevCacheWrite = prev ? toUsageNumber(prev.cacheWriteTokens) : 0;
+        const prevTotal = prev ? toUsageNumber(prev.totalTokens) : 0;
 
         let deltaInput = inputTokens - prevInput;
         let deltaOutput = outputTokens - prevOutput;
+        let deltaCacheRead = cacheReadTokens - prevCacheRead;
+        let deltaCacheWrite = cacheWriteTokens - prevCacheWrite;
         let deltaTotal = totalTokens - prevTotal;
-        if (deltaTotal < 0 || deltaInput < 0 || deltaOutput < 0) {
+        if (deltaTotal < 0) {
+            // Session reset: treat current totals as fresh usage.
             deltaInput = inputTokens;
             deltaOutput = outputTokens;
+            deltaCacheRead = cacheReadTokens;
+            deltaCacheWrite = cacheWriteTokens;
             deltaTotal = totalTokens;
+        } else {
+            // Clamp negatives caused by reclassification (e.g. cache splits).
+            if (deltaInput < 0) deltaInput = 0;
+            if (deltaOutput < 0) deltaOutput = 0;
+            if (deltaCacheRead < 0) deltaCacheRead = 0;
+            if (deltaCacheWrite < 0) deltaCacheWrite = 0;
+            const breakdownTotal =
+                deltaInput + deltaOutput + deltaCacheRead + deltaCacheWrite;
+            if (deltaTotal === 0 && breakdownTotal === 0) {
+                deltaTotal = 0;
+            } else if (breakdownTotal > deltaTotal) {
+                deltaTotal = breakdownTotal;
+            }
         }
 
         if (deltaTotal > 0) {
@@ -292,8 +615,12 @@ export function syncUsageFromStatuslineInput(
                 type: normalizedType,
                 profileKey: profileKey || null,
                 profileName: profileName || null,
+                model: resolvedModel,
+                sessionId,
                 inputTokens: deltaInput,
                 outputTokens: deltaOutput,
+                cacheReadTokens: deltaCacheRead,
+                cacheWriteTokens: deltaCacheWrite,
                 totalTokens: deltaTotal,
             };
             appendUsageRecord(usagePath, record);
@@ -304,12 +631,16 @@ export function syncUsageFromStatuslineInput(
             type: normalizedType,
             inputTokens,
             outputTokens,
+            cacheReadTokens,
+            cacheWriteTokens,
             totalTokens,
             startTs: prev ? prev.startTs : now,
             endTs: now,
             cwd: cwd || (prev ? prev.cwd : null),
+            model: resolvedModel,
         };
         state.sessions = sessions;
+        updateUsageStateMetadata(state, usagePath);
         writeUsageState(statePath, state);
     } finally {
         releaseLock(lockPath, lockFd);
@@ -540,7 +871,15 @@ function readUsageState(statePath: string): UsageStateFile {
             parsed.files && typeof parsed.files === "object" ? parsed.files : {};
         const sessions =
             parsed.sessions && typeof parsed.sessions === "object" ? parsed.sessions : {};
-        return { version: 1, files, sessions };
+        const usageMtimeMs = Number(parsed.usageMtimeMs);
+        const usageSize = Number(parsed.usageSize);
+        return {
+            version: 1,
+            files,
+            sessions,
+            usageMtimeMs: Number.isFinite(usageMtimeMs) ? usageMtimeMs : undefined,
+            usageSize: Number.isFinite(usageSize) ? usageSize : undefined,
+        };
     } catch {
         return { version: 1, files: {}, sessions: {} };
     }
@@ -551,7 +890,91 @@ function writeUsageState(statePath: string, state: UsageStateFile) {
     if (!fs.existsSync(dir)) {
         fs.mkdirSync(dir, { recursive: true });
     }
-    fs.writeFileSync(statePath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+    const payload = `${JSON.stringify(state, null, 2)}\n`;
+    const tmpPath = `${statePath}.tmp`;
+    try {
+        fs.writeFileSync(tmpPath, payload, "utf8");
+        fs.renameSync(tmpPath, statePath);
+    } catch {
+        try {
+            if (fs.existsSync(tmpPath)) fs.unlinkSync(tmpPath);
+        } catch {
+            // ignore cleanup failures
+        }
+        fs.writeFileSync(statePath, payload, "utf8");
+    }
+}
+
+function addSiblingBackupPaths(targets: Set<string>, filePath: string | null) {
+    if (!filePath) return;
+    const dir = path.dirname(filePath);
+    let entries: fs.Dirent[] = [];
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+        return;
+    }
+    const base = path.basename(filePath);
+    for (const entry of entries) {
+        if (!entry.isFile()) continue;
+        if (entry.name === base) continue;
+        if (entry.name.startsWith(`${base}.`)) {
+            targets.add(path.join(dir, entry.name));
+        }
+    }
+}
+
+export function clearUsageHistory(
+    config: Config,
+    configPath: string | null
+): UsageCleanupResult {
+    const targets = new Set<string>();
+    const usagePath = getUsagePath(config, configPath);
+    if (usagePath) {
+        targets.add(usagePath);
+        addSiblingBackupPaths(targets, usagePath);
+    }
+    const statePath = usagePath ? getUsageStatePath(usagePath, config) : null;
+    if (statePath) {
+        targets.add(statePath);
+        targets.add(`${statePath}.lock`);
+        addSiblingBackupPaths(targets, statePath);
+    }
+    const profileLogPath = getProfileLogPath(config, configPath);
+    if (profileLogPath) {
+        targets.add(profileLogPath);
+        addSiblingBackupPaths(targets, profileLogPath);
+    }
+    const debugPath = getStatuslineDebugPath(configPath);
+    if (debugPath) {
+        targets.add(debugPath);
+        addSiblingBackupPaths(targets, debugPath);
+    }
+
+    const removed: string[] = [];
+    const missing: string[] = [];
+    const failed: UsageCleanupFailure[] = [];
+
+    for (const target of targets) {
+        if (!target) continue;
+        if (!fs.existsSync(target)) {
+            missing.push(target);
+            continue;
+        }
+        try {
+            const stat = fs.statSync(target);
+            if (!stat.isFile()) continue;
+            fs.unlinkSync(target);
+            removed.push(target);
+        } catch (err) {
+            failed.push({
+                path: target,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+
+    return { removed, missing, failed };
 }
 
 function collectSessionFiles(root: string | null): string[] {
@@ -595,19 +1018,82 @@ function updateMinMaxTs(
     }
 }
 
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function coerceModelFromValue(value: unknown): string | null {
+    if (typeof value === "string") return normalizeModelValue(value);
+    if (!isPlainObject(value)) return null;
+    return (
+        normalizeModelValue(value.displayName) ||
+        normalizeModelValue(value.display_name) ||
+        normalizeModelValue(value.name) ||
+        normalizeModelValue(value.id) ||
+        normalizeModelValue(value.model) ||
+        normalizeModelValue(value.model_name) ||
+        normalizeModelValue(value.model_id) ||
+        normalizeModelValue(value.modelId) ||
+        null
+    );
+}
+
+function pickModelFromObject(record: Record<string, unknown>): string | null {
+    return (
+        coerceModelFromValue(record.model) ||
+        normalizeModelValue(record.model_name) ||
+        normalizeModelValue(record.modelName) ||
+        normalizeModelValue(record.model_id) ||
+        normalizeModelValue(record.modelId) ||
+        normalizeModelValue(record.model_display_name) ||
+        normalizeModelValue(record.modelDisplayName) ||
+        null
+    );
+}
+
+function extractModelFromRecord(record: Record<string, unknown>): string | null {
+    const direct = pickModelFromObject(record);
+    if (direct) return direct;
+    const message = isPlainObject(record.message)
+        ? (record.message as Record<string, unknown>)
+        : null;
+    if (message) {
+        const fromMessage = pickModelFromObject(message);
+        if (fromMessage) return fromMessage;
+    }
+    const payload = isPlainObject(record.payload)
+        ? (record.payload as Record<string, unknown>)
+        : null;
+    if (payload) {
+        const fromPayload = pickModelFromObject(payload);
+        if (fromPayload) return fromPayload;
+        const info = isPlainObject(payload.info)
+            ? (payload.info as Record<string, unknown>)
+            : null;
+        if (info) {
+            const fromInfo = pickModelFromObject(info);
+            if (fromInfo) return fromInfo;
+        }
+    }
+    return null;
+}
+
 function parseCodexSessionFile(filePath: string): SessionStats {
     const raw = fs.readFileSync(filePath, "utf8");
     const lines = raw.split(/\r?\n/);
     let maxTotal = 0;
     let maxInput = 0;
     let maxOutput = 0;
+    let maxCachedInput = 0;
     let hasTotal = false;
     let sumLast = 0;
     let sumLastInput = 0;
     let sumLastOutput = 0;
+    let sumLastCachedInput = 0;
     const tsRange = { start: null as string | null, end: null as string | null };
     let cwd: string | null = null;
     let sessionId: string | null = null;
+    let model: string | null = null;
 
     for (const line of lines) {
         const trimmed = line.trim();
@@ -615,6 +1101,10 @@ function parseCodexSessionFile(filePath: string): SessionStats {
         try {
             const parsed = JSON.parse(trimmed);
             if (!parsed || typeof parsed !== "object") continue;
+            if (!model) {
+                const candidate = extractModelFromRecord(parsed as Record<string, unknown>);
+                if (candidate) model = candidate;
+            }
             if (parsed.timestamp) updateMinMaxTs(tsRange, String(parsed.timestamp));
             if (!cwd && parsed.type === "session_meta") {
                 const payload = parsed.payload || {};
@@ -639,19 +1129,25 @@ function parseCodexSessionFile(filePath: string): SessionStats {
                 if (totalTokens > maxTotal) maxTotal = totalTokens;
                 const totalInput = Number(totalUsage.input_tokens);
                 const totalOutput = Number(totalUsage.output_tokens);
+                const totalCached = Number(totalUsage.cached_input_tokens);
                 if (Number.isFinite(totalInput) && totalInput > maxInput) {
                     maxInput = totalInput;
                 }
                 if (Number.isFinite(totalOutput) && totalOutput > maxOutput) {
                     maxOutput = totalOutput;
                 }
+                if (Number.isFinite(totalCached) && totalCached > maxCachedInput) {
+                    maxCachedInput = totalCached;
+                }
             } else {
                 const lastTokens = Number(lastUsage.total_tokens);
                 if (Number.isFinite(lastTokens)) sumLast += lastTokens;
                 const lastInput = Number(lastUsage.input_tokens);
                 const lastOutput = Number(lastUsage.output_tokens);
+                const lastCached = Number(lastUsage.cached_input_tokens);
                 if (Number.isFinite(lastInput)) sumLastInput += lastInput;
                 if (Number.isFinite(lastOutput)) sumLastOutput += lastOutput;
+                if (Number.isFinite(lastCached)) sumLastCachedInput += lastCached;
             }
         } catch {
             // ignore invalid lines
@@ -662,16 +1158,26 @@ function parseCodexSessionFile(filePath: string): SessionStats {
         maxTotal = sumLast;
         maxInput = sumLastInput;
         maxOutput = sumLastOutput;
+        maxCachedInput = sumLastCachedInput;
     }
 
+    const cacheReadTokens = Math.max(0, maxCachedInput);
+    const inputTokens =
+        cacheReadTokens > 0 ? Math.max(0, maxInput - cacheReadTokens) : maxInput;
+    const computedTotal = inputTokens + maxOutput + cacheReadTokens;
+    const totalTokens = Math.max(maxTotal, computedTotal);
+
     return {
-        inputTokens: maxInput,
+        inputTokens,
         outputTokens: maxOutput,
-        totalTokens: maxTotal,
+        cacheReadTokens,
+        cacheWriteTokens: 0,
+        totalTokens,
         startTs: tsRange.start,
         endTs: tsRange.end,
         cwd,
         sessionId,
+        model,
     };
 }
 
@@ -681,9 +1187,12 @@ function parseClaudeSessionFile(filePath: string): SessionStats {
     let totalTokens = 0;
     let inputTokens = 0;
     let outputTokens = 0;
+    let cacheReadTokens = 0;
+    let cacheWriteTokens = 0;
     const tsRange = { start: null as string | null, end: null as string | null };
     let cwd: string | null = null;
     let sessionId: string | null = null;
+    let model: string | null = null;
 
     for (const line of lines) {
         const trimmed = line.trim();
@@ -691,6 +1200,10 @@ function parseClaudeSessionFile(filePath: string): SessionStats {
         try {
             const parsed = JSON.parse(trimmed);
             if (!parsed || typeof parsed !== "object") continue;
+            if (!model) {
+                const candidate = extractModelFromRecord(parsed as Record<string, unknown>);
+                if (candidate) model = candidate;
+            }
             if (parsed.timestamp) updateMinMaxTs(tsRange, String(parsed.timestamp));
             if (!cwd && parsed.cwd) cwd = String(parsed.cwd);
             if (!sessionId && parsed.sessionId) {
@@ -705,6 +1218,8 @@ function parseClaudeSessionFile(filePath: string): SessionStats {
             const cacheRead = Number(usage.cache_read_input_tokens ?? 0);
             if (Number.isFinite(input)) inputTokens += input;
             if (Number.isFinite(output)) outputTokens += output;
+            if (Number.isFinite(cacheCreate)) cacheWriteTokens += cacheCreate;
+            if (Number.isFinite(cacheRead)) cacheReadTokens += cacheRead;
             totalTokens +=
                 (Number.isFinite(input) ? input : 0) +
                 (Number.isFinite(output) ? output : 0) +
@@ -718,11 +1233,14 @@ function parseClaudeSessionFile(filePath: string): SessionStats {
     return {
         inputTokens,
         outputTokens,
+        cacheReadTokens,
+        cacheWriteTokens,
         totalTokens,
         startTs: tsRange.start,
         endTs: tsRange.end,
         cwd,
         sessionId,
+        model,
     };
 }
 
@@ -806,6 +1324,91 @@ function releaseLock(lockPath: string, fd: number | null) {
     }
 }
 
+function readUsageFileStat(usagePath: string): fs.Stats | null {
+    if (!usagePath || !fs.existsSync(usagePath)) return null;
+    try {
+        return fs.statSync(usagePath);
+    } catch {
+        return null;
+    }
+}
+
+function buildUsageRecordKey(record: UsageRecord): string {
+    return JSON.stringify([
+        record.ts,
+        record.type,
+        record.profileKey ?? null,
+        record.profileName ?? null,
+        record.model ?? null,
+        record.sessionId ?? null,
+        toUsageNumber(record.inputTokens),
+        toUsageNumber(record.outputTokens),
+        toUsageNumber(record.cacheReadTokens),
+        toUsageNumber(record.cacheWriteTokens),
+        toUsageNumber(record.totalTokens),
+    ]);
+}
+
+function buildUsageSessionsFromRecords(
+    records: UsageRecord[]
+): Record<string, UsageSessionEntry> {
+    const sessions: Record<string, UsageSessionEntry> = {};
+    const seen = new Set<string>();
+    for (const record of records) {
+        if (!record.sessionId) continue;
+        const normalizedType = normalizeUsageType(record.type);
+        if (!normalizedType) continue;
+        const recordKey = buildUsageRecordKey(record);
+        if (seen.has(recordKey)) continue;
+        seen.add(recordKey);
+
+        const sessionKey = buildSessionKey(
+            normalizedType as ProfileType,
+            record.sessionId
+        );
+        let entry = sessions[sessionKey];
+        if (!entry) {
+            entry = {
+                type: normalizedType as ProfileType,
+                inputTokens: 0,
+                outputTokens: 0,
+                cacheReadTokens: 0,
+                cacheWriteTokens: 0,
+                totalTokens: 0,
+                startTs: null,
+                endTs: null,
+                cwd: null,
+                model: record.model || null,
+            };
+            sessions[sessionKey] = entry;
+        }
+        entry.inputTokens += toUsageNumber(record.inputTokens);
+        entry.outputTokens += toUsageNumber(record.outputTokens);
+        entry.cacheReadTokens += toUsageNumber(record.cacheReadTokens);
+        entry.cacheWriteTokens += toUsageNumber(record.cacheWriteTokens);
+        entry.totalTokens += toUsageNumber(record.totalTokens);
+        if (!entry.model && record.model) entry.model = record.model;
+        if (record.ts) {
+            const range = { start: entry.startTs, end: entry.endTs };
+            updateMinMaxTs(range, record.ts);
+            entry.startTs = range.start;
+            entry.endTs = range.end;
+        }
+    }
+    return sessions;
+}
+
+function updateUsageStateMetadata(state: UsageStateFile, usagePath: string) {
+    const stat = readUsageFileStat(usagePath);
+    if (!stat || !stat.isFile()) {
+        state.usageMtimeMs = undefined;
+        state.usageSize = undefined;
+        return;
+    }
+    state.usageMtimeMs = stat.mtimeMs;
+    state.usageSize = stat.size;
+}
+
 function appendUsageRecord(usagePath: string, record: UsageRecord) {
     const dir = path.dirname(usagePath);
     if (!fs.existsSync(dir)) {
@@ -819,25 +1422,82 @@ export function readUsageRecords(usagePath: string): UsageRecord[] {
     const raw = fs.readFileSync(usagePath, "utf8");
     const lines = raw.split(/\r?\n/);
     const records: UsageRecord[] = [];
+    const seen = new Set<string>();
     for (const line of lines) {
         const trimmed = line.trim();
         if (!trimmed) continue;
         try {
             const parsed = JSON.parse(trimmed);
             if (!parsed || typeof parsed !== "object") continue;
-            const input = Number(parsed.inputTokens ?? 0);
-            const output = Number(parsed.outputTokens ?? 0);
-            const total = Number(parsed.totalTokens ?? input + output);
             const type = normalizeType(parsed.type) || String(parsed.type ?? "unknown");
-            records.push({
+            let input = Number(parsed.inputTokens ?? 0);
+            const output = Number(parsed.outputTokens ?? 0);
+            const cacheRead = Number(
+                parsed.cacheReadTokens ??
+                    parsed.cache_read_input_tokens ??
+                    parsed.cacheReadInputTokens ??
+                    0
+            );
+            const cacheWrite = Number(
+                parsed.cacheWriteTokens ??
+                    parsed.cache_creation_input_tokens ??
+                    parsed.cache_write_input_tokens ??
+                    parsed.cacheWriteInputTokens ??
+                    0
+            );
+            if (
+                type === "codex" &&
+                Number.isFinite(cacheRead) &&
+                cacheRead > 0 &&
+                Number.isFinite(input) &&
+                Number.isFinite(output)
+            ) {
+                const rawTotal = Number(parsed.totalTokens);
+                if (Number.isFinite(rawTotal) && rawTotal <= input + output) {
+                    input = Math.max(0, input - cacheRead);
+                }
+            }
+            const computedTotal =
+                (Number.isFinite(input) ? input : 0) +
+                (Number.isFinite(output) ? output : 0) +
+                (Number.isFinite(cacheRead) ? cacheRead : 0) +
+                (Number.isFinite(cacheWrite) ? cacheWrite : 0);
+            const total = Number(
+                parsed.totalTokens ?? computedTotal
+            );
+            const finalTotal = Number.isFinite(total)
+                ? Math.max(total, computedTotal)
+                : computedTotal;
+            const model =
+                normalizeModelValue(parsed.model) ||
+                normalizeModelValue(parsed.model_name) ||
+                normalizeModelValue(parsed.modelName) ||
+                normalizeModelValue(parsed.model_id) ||
+                normalizeModelValue(parsed.modelId) ||
+                null;
+            const sessionId =
+                parsed.sessionId ||
+                parsed.session_id ||
+                parsed.sessionID ||
+                parsed.session ||
+                null;
+            const record: UsageRecord = {
                 ts: String(parsed.ts ?? ""),
                 type,
                 profileKey: parsed.profileKey ? String(parsed.profileKey) : null,
                 profileName: parsed.profileName ? String(parsed.profileName) : null,
+                model,
+                sessionId: sessionId ? String(sessionId) : null,
                 inputTokens: Number.isFinite(input) ? input : 0,
                 outputTokens: Number.isFinite(output) ? output : 0,
-                totalTokens: Number.isFinite(total) ? total : 0,
-            });
+                cacheReadTokens: Number.isFinite(cacheRead) ? cacheRead : 0,
+                cacheWriteTokens: Number.isFinite(cacheWrite) ? cacheWrite : 0,
+                totalTokens: Number.isFinite(finalTotal) ? finalTotal : 0,
+            };
+            const key = buildUsageRecordKey(record);
+            if (seen.has(key)) continue;
+            seen.add(key);
+            records.push(record);
         } catch {
             // ignore invalid lines
         }
@@ -860,7 +1520,25 @@ export function syncUsageFromSessions(
 
         const state = readUsageState(statePath);
         const files = state.files || {};
-        const sessions = state.sessions || {};
+        let sessions = state.sessions || {};
+        const usageStat = readUsageFileStat(usagePath);
+        const hasUsageData = !!usageStat && usageStat.isFile() && usageStat.size > 0;
+        const sessionsEmpty = Object.keys(sessions).length === 0;
+        const hasUsageMeta =
+            Number.isFinite(state.usageMtimeMs ?? Number.NaN) &&
+            Number.isFinite(state.usageSize ?? Number.NaN);
+        const usageOutOfSync =
+            hasUsageData &&
+            (!hasUsageMeta ||
+                state.usageMtimeMs !== usageStat.mtimeMs ||
+                state.usageSize !== usageStat.size);
+        if (hasUsageData && (sessionsEmpty || usageOutOfSync)) {
+            const records = readUsageRecords(usagePath);
+            if (records.length > 0) {
+                sessions = buildUsageSessionsFromRecords(records);
+            }
+        }
+        state.sessions = sessions;
         const codexFiles = collectSessionFiles(getCodexSessionsPath(config));
         const claudeFiles = collectSessionFiles(getClaudeSessionsPath(config));
 
@@ -896,29 +1574,54 @@ export function syncUsageFromSessions(
             const sessionKey =
                 stats.sessionId ? buildSessionKey(type, stats.sessionId) : null;
             const sessionPrev = sessionKey ? sessions[sessionKey] : null;
-            const prevInput = prev ? prev.inputTokens : 0;
-            const prevOutput = prev ? prev.outputTokens : 0;
-            const prevTotal = prev ? prev.totalTokens : 0;
+            const resolvedModel =
+                (sessionPrev && sessionPrev.model) ||
+                stats.model ||
+                (prev && prev.model) ||
+                null;
+            const prevInput = prev ? toUsageNumber(prev.inputTokens) : 0;
+            const prevOutput = prev ? toUsageNumber(prev.outputTokens) : 0;
+            const prevCacheRead = prev ? toUsageNumber(prev.cacheReadTokens) : 0;
+            const prevCacheWrite = prev ? toUsageNumber(prev.cacheWriteTokens) : 0;
+            const prevTotal = prev ? toUsageNumber(prev.totalTokens) : 0;
             const prevInputMax = sessionPrev
-                ? Math.max(prevInput, sessionPrev.inputTokens)
+                ? Math.max(prevInput, toUsageNumber(sessionPrev.inputTokens))
                 : prevInput;
             const prevOutputMax = sessionPrev
-                ? Math.max(prevOutput, sessionPrev.outputTokens)
+                ? Math.max(prevOutput, toUsageNumber(sessionPrev.outputTokens))
                 : prevOutput;
+            const prevCacheReadMax = sessionPrev
+                ? Math.max(prevCacheRead, toUsageNumber(sessionPrev.cacheReadTokens))
+                : prevCacheRead;
+            const prevCacheWriteMax = sessionPrev
+                ? Math.max(prevCacheWrite, toUsageNumber(sessionPrev.cacheWriteTokens))
+                : prevCacheWrite;
             const prevTotalMax = sessionPrev
-                ? Math.max(prevTotal, sessionPrev.totalTokens)
+                ? Math.max(prevTotal, toUsageNumber(sessionPrev.totalTokens))
                 : prevTotal;
             let deltaInput = stats.inputTokens - prevInputMax;
             let deltaOutput = stats.outputTokens - prevOutputMax;
+            let deltaCacheRead = stats.cacheReadTokens - prevCacheReadMax;
+            let deltaCacheWrite = stats.cacheWriteTokens - prevCacheWriteMax;
             let deltaTotal = stats.totalTokens - prevTotalMax;
-            if (deltaTotal < 0 || deltaInput < 0 || deltaOutput < 0) {
+            if (
+                deltaTotal < 0 ||
+                deltaInput < 0 ||
+                deltaOutput < 0 ||
+                deltaCacheRead < 0 ||
+                deltaCacheWrite < 0
+            ) {
                 if (sessionPrev) {
                     deltaInput = 0;
                     deltaOutput = 0;
+                    deltaCacheRead = 0;
+                    deltaCacheWrite = 0;
                     deltaTotal = 0;
                 } else {
                     deltaInput = stats.inputTokens;
                     deltaOutput = stats.outputTokens;
+                    deltaCacheRead = stats.cacheReadTokens;
+                    deltaCacheWrite = stats.cacheWriteTokens;
                     deltaTotal = stats.totalTokens;
                 }
             }
@@ -928,30 +1631,58 @@ export function syncUsageFromSessions(
                     type,
                     profileKey: resolved.match.profileKey,
                     profileName: resolved.match.profileName,
+                    model: resolvedModel,
+                    sessionId: stats.sessionId,
                     inputTokens: deltaInput,
                     outputTokens: deltaOutput,
+                    cacheReadTokens: deltaCacheRead,
+                    cacheWriteTokens: deltaCacheWrite,
                     totalTokens: deltaTotal,
                 };
                 appendUsageRecord(usagePath, record);
             }
             if (sessionKey) {
                 const nextInput = sessionPrev
-                    ? Math.max(sessionPrev.inputTokens, stats.inputTokens)
+                    ? Math.max(
+                          toUsageNumber(sessionPrev.inputTokens),
+                          stats.inputTokens
+                      )
                     : stats.inputTokens;
                 const nextOutput = sessionPrev
-                    ? Math.max(sessionPrev.outputTokens, stats.outputTokens)
+                    ? Math.max(
+                          toUsageNumber(sessionPrev.outputTokens),
+                          stats.outputTokens
+                      )
                     : stats.outputTokens;
+                const nextCacheRead = sessionPrev
+                    ? Math.max(
+                          toUsageNumber(sessionPrev.cacheReadTokens),
+                          stats.cacheReadTokens
+                      )
+                    : stats.cacheReadTokens;
+                const nextCacheWrite = sessionPrev
+                    ? Math.max(
+                          toUsageNumber(sessionPrev.cacheWriteTokens),
+                          stats.cacheWriteTokens
+                      )
+                    : stats.cacheWriteTokens;
                 const nextTotal = sessionPrev
-                    ? Math.max(sessionPrev.totalTokens, stats.totalTokens)
+                    ? Math.max(
+                          toUsageNumber(sessionPrev.totalTokens),
+                          stats.totalTokens
+                      )
                     : stats.totalTokens;
                 sessions[sessionKey] = {
                     type,
                     inputTokens: nextInput,
                     outputTokens: nextOutput,
+                    cacheReadTokens: nextCacheRead,
+                    cacheWriteTokens: nextCacheWrite,
                     totalTokens: nextTotal,
                     startTs: sessionPrev ? sessionPrev.startTs : stats.startTs,
                     endTs: stats.endTs || (sessionPrev ? sessionPrev.endTs : null),
                     cwd: stats.cwd || (sessionPrev ? sessionPrev.cwd : null),
+                    model: resolvedModel,
                 };
             }
             files[filePath] = {
@@ -960,10 +1691,13 @@ export function syncUsageFromSessions(
                 type,
                 inputTokens: stats.inputTokens,
                 outputTokens: stats.outputTokens,
+                cacheReadTokens: stats.cacheReadTokens,
+                cacheWriteTokens: stats.cacheWriteTokens,
                 totalTokens: stats.totalTokens,
                 startTs: stats.startTs,
                 endTs: stats.endTs,
                 cwd: stats.cwd,
+                model: resolvedModel,
             };
         };
 
@@ -972,6 +1706,7 @@ export function syncUsageFromSessions(
 
         state.files = files;
         state.sessions = sessions;
+        updateUsageStateMetadata(state, usagePath);
         writeUsageState(statePath, state);
     } finally {
         releaseLock(lockPath, lockFd);