@praeviso/code-env-switch 0.1.3 → 0.1.5

package/bin/usage/index.js

@@ -8,7 +8,10 @@ exports.getClaudeSessionsPath = getClaudeSessionsPath;
 exports.formatTokenCount = formatTokenCount;
 exports.buildUsageTotals = buildUsageTotals;
 exports.readUsageTotalsIndex = readUsageTotalsIndex;
+exports.readUsageCostIndex = readUsageCostIndex;
+exports.readUsageSessionCost = readUsageSessionCost;
 exports.resolveUsageTotalsForProfile = resolveUsageTotalsForProfile;
+exports.resolveUsageCostForProfile = resolveUsageCostForProfile;
 exports.syncUsageFromStatuslineInput = syncUsageFromStatuslineInput;
 exports.logProfileUse = logProfileUse;
 exports.logSessionBinding = logSessionBinding;
@@ -23,6 +26,23 @@ const path = require("path");
 const os = require("os");
 const utils_1 = require("../shell/utils");
 const type_1 = require("../profile/type");
+const pricing_1 = require("./pricing");
+function resolveProfileForRecord(config, type, record) {
+    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 = (0, type_1.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) {
     if (configPath)
         return path.dirname(configPath);
@@ -72,42 +92,135 @@ function formatTokenCount(value) {
         return `${(value / 1000000).toFixed(2)}M`;
     return `${(value / 1000000000).toFixed(2)}B`;
 }
-function buildUsageTotals(records) {
-    const byKey = new Map();
-    const byName = new Map();
+function createUsageTotals() {
+    return {
+        today: 0,
+        total: 0,
+        todayInput: 0,
+        totalInput: 0,
+        todayOutput: 0,
+        totalOutput: 0,
+        todayCacheRead: 0,
+        totalCacheRead: 0,
+        todayCacheWrite: 0,
+        totalCacheWrite: 0,
+    };
+}
+function createUsageCostTotals() {
+    return { today: 0, total: 0, todayTokens: 0, totalTokens: 0 };
+}
+function toUsageNumber(value) {
+    const num = Number(value !== null && value !== void 0 ? value : 0);
+    return Number.isFinite(num) ? num : 0;
+}
+function getTodayWindow() {
     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, startMs, endMs) {
+    if (!ts)
+        return false;
+    const time = new Date(ts).getTime();
+    if (Number.isNaN(time))
+        return false;
+    return time >= startMs && time < endMs;
+}
+function buildUsageTotals(records) {
+    var _a;
+    const byKey = new Map();
+    const byName = new Map();
+    const { startMs, endMs } = getTodayWindow();
     const isToday = (ts) => {
-        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, key, amount, ts) => {
+    const addTotals = (map, key, amounts, ts) => {
         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((_a = record.totalTokens) !== null && _a !== void 0 ? _a : 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, config) {
+    const byKey = new Map();
+    const byName = new Map();
+    const { startMs, endMs } = getTodayWindow();
+    const addCost = (map, key, cost, tokens, ts) => {
+        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 = (0, pricing_1.resolvePricingForProfile)(config, profile || null, model);
+        if (!pricing)
+            continue;
+        const cost = (0, pricing_1.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);
         }
     }
     return { byKey, byName };
@@ -121,6 +234,12 @@ function normalizeUsageType(type) {
     const trimmed = String(type).trim();
     return trimmed ? trimmed : null;
 }
+function normalizeModelValue(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return trimmed ? trimmed : null;
+}
 function buildSessionKey(type, sessionId) {
     const normalized = normalizeUsageType(type || "");
     return normalized ? `${normalized}::${sessionId}` : sessionId;
@@ -153,6 +272,66 @@ function readUsageTotalsIndex(config, configPath, syncUsage) {
         return null;
     return buildUsageTotals(records);
 }
+function readUsageCostIndex(config, configPath, syncUsage) {
+    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;
+}
+function readUsageSessionCost(config, configPath, type, sessionId, syncUsage) {
+    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 = (0, pricing_1.resolvePricingForProfile)(config, profile, model);
+        if (!pricing)
+            continue;
+        const cost = (0, pricing_1.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;
+}
 function resolveUsageTotalsForProfile(totals, type, profileKey, profileName) {
     const keyLookup = buildUsageLookupKey(type, profileKey);
     const nameLookup = buildUsageLookupKey(type, profileName);
@@ -160,14 +339,24 @@ function resolveUsageTotalsForProfile(totals, type, profileKey, profileName) {
         (nameLookup && totals.byName.get(nameLookup)) ||
         null);
 }
-function syncUsageFromStatuslineInput(config, configPath, type, profileKey, profileName, sessionId, totals, cwd) {
-    var _a, _b, _c;
+function resolveUsageCostForProfile(costs, type, profileKey, profileName) {
+    const keyLookup = buildUsageLookupKey(type, profileKey);
+    const nameLookup = buildUsageLookupKey(type, profileName);
+    return ((keyLookup && costs.byKey.get(keyLookup)) ||
+        (nameLookup && costs.byName.get(nameLookup)) ||
+        null);
+}
+function syncUsageFromStatuslineInput(config, configPath, type, profileKey, profileName, sessionId, totals, cwd, model) {
+    var _a, _b, _c, _d, _e;
     if (!sessionId)
         return;
     if (!totals)
         return;
     if (!profileKey && !profileName)
         return;
+    const resolvedModel = normalizeModelValue(model);
+    if (!resolvedModel)
+        return;
     const normalizedType = (0, type_1.normalizeType)(type || "");
     if (!normalizedType)
         return;
@@ -176,7 +365,12 @@ function syncUsageFromStatuslineInput(config, configPath, type, profileKey, prof
         return;
     const inputTokens = (_a = toFiniteNumber(totals.inputTokens)) !== null && _a !== void 0 ? _a : 0;
     const outputTokens = (_b = toFiniteNumber(totals.outputTokens)) !== null && _b !== void 0 ? _b : 0;
-    const totalTokens = (_c = toFiniteNumber(totals.totalTokens)) !== null && _c !== void 0 ? _c : inputTokens + outputTokens;
+    const cacheReadTokens = (_c = toFiniteNumber(totals.cacheReadTokens)) !== null && _c !== void 0 ? _c : 0;
+    const cacheWriteTokens = (_d = toFiniteNumber(totals.cacheWriteTokens)) !== null && _d !== void 0 ? _d : 0;
+    const totalTokens = (_e = toFiniteNumber(totals.totalTokens)) !== null && _e !== void 0 ? _e : inputTokens +
+        outputTokens +
+        cacheReadTokens +
+        cacheWriteTokens;
     if (!Number.isFinite(totalTokens))
         return;
     const statePath = getUsageStatePath(usagePath, config);
@@ -189,15 +383,25 @@ function syncUsageFromStatuslineInput(config, configPath, type, profileKey, prof
         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 ||
+            deltaInput < 0 ||
+            deltaOutput < 0 ||
+            deltaCacheRead < 0 ||
+            deltaCacheWrite < 0) {
             deltaInput = inputTokens;
             deltaOutput = outputTokens;
+            deltaCacheRead = cacheReadTokens;
+            deltaCacheWrite = cacheWriteTokens;
             deltaTotal = totalTokens;
         }
         if (deltaTotal > 0) {
@@ -206,8 +410,12 @@ function syncUsageFromStatuslineInput(config, configPath, type, profileKey, prof
                 type: normalizedType,
                 profileKey: profileKey || null,
                 profileName: profileName || null,
+                model: resolvedModel,
+                sessionId,
                 inputTokens: deltaInput,
                 outputTokens: deltaOutput,
+                cacheReadTokens: deltaCacheRead,
+                cacheWriteTokens: deltaCacheWrite,
                 totalTokens: deltaTotal,
             };
             appendUsageRecord(usagePath, record);
@@ -217,10 +425,13 @@ function syncUsageFromStatuslineInput(config, configPath, type, profileKey, prof
             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;
         writeUsageState(statePath, state);
@@ -433,6 +644,64 @@ function updateMinMaxTs(current, ts) {
         current.end = ts;
     }
 }
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function coerceModelFromValue(value) {
+    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) {
+    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) {
+    const direct = pickModelFromObject(record);
+    if (direct)
+        return direct;
+    const message = isPlainObject(record.message)
+        ? record.message
+        : null;
+    if (message) {
+        const fromMessage = pickModelFromObject(message);
+        if (fromMessage)
+            return fromMessage;
+    }
+    const payload = isPlainObject(record.payload)
+        ? record.payload
+        : null;
+    if (payload) {
+        const fromPayload = pickModelFromObject(payload);
+        if (fromPayload)
+            return fromPayload;
+        const info = isPlainObject(payload.info)
+            ? payload.info
+            : null;
+        if (info) {
+            const fromInfo = pickModelFromObject(info);
+            if (fromInfo)
+                return fromInfo;
+        }
+    }
+    return null;
+}
 function parseCodexSessionFile(filePath) {
     const raw = fs.readFileSync(filePath, "utf8");
     const lines = raw.split(/\r?\n/);
@@ -446,6 +715,7 @@ function parseCodexSessionFile(filePath) {
     const tsRange = { start: null, end: null };
     let cwd = null;
     let sessionId = null;
+    let model = null;
     for (const line of lines) {
         const trimmed = line.trim();
         if (!trimmed)
@@ -454,6 +724,11 @@ function parseCodexSessionFile(filePath) {
             const parsed = JSON.parse(trimmed);
             if (!parsed || typeof parsed !== "object")
                 continue;
+            if (!model) {
+                const candidate = extractModelFromRecord(parsed);
+                if (candidate)
+                    model = candidate;
+            }
             if (parsed.timestamp)
                 updateMinMaxTs(tsRange, String(parsed.timestamp));
             if (!cwd && parsed.type === "session_meta") {
@@ -515,11 +790,14 @@ function parseCodexSessionFile(filePath) {
     return {
         inputTokens: maxInput,
         outputTokens: maxOutput,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
         totalTokens: maxTotal,
         startTs: tsRange.start,
         endTs: tsRange.end,
         cwd,
         sessionId,
+        model,
     };
 }
 function parseClaudeSessionFile(filePath) {
@@ -529,9 +807,12 @@ function parseClaudeSessionFile(filePath) {
     let totalTokens = 0;
     let inputTokens = 0;
     let outputTokens = 0;
+    let cacheReadTokens = 0;
+    let cacheWriteTokens = 0;
     const tsRange = { start: null, end: null };
     let cwd = null;
     let sessionId = null;
+    let model = null;
     for (const line of lines) {
         const trimmed = line.trim();
         if (!trimmed)
@@ -540,6 +821,11 @@ function parseClaudeSessionFile(filePath) {
             const parsed = JSON.parse(trimmed);
             if (!parsed || typeof parsed !== "object")
                 continue;
+            if (!model) {
+                const candidate = extractModelFromRecord(parsed);
+                if (candidate)
+                    model = candidate;
+            }
             if (parsed.timestamp)
                 updateMinMaxTs(tsRange, String(parsed.timestamp));
             if (!cwd && parsed.cwd)
@@ -559,6 +845,10 @@ function parseClaudeSessionFile(filePath) {
                 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) +
@@ -572,11 +862,14 @@ function parseClaudeSessionFile(filePath) {
     return {
         inputTokens,
         outputTokens,
+        cacheReadTokens,
+        cacheWriteTokens,
         totalTokens,
         startTs: tsRange.start,
         endTs: tsRange.end,
         cwd,
         sessionId,
+        model,
     };
 }
 const LOCK_STALE_MS = 10 * 60 * 1000;
@@ -670,7 +963,7 @@ function appendUsageRecord(usagePath, record) {
     fs.appendFileSync(usagePath, `${JSON.stringify(record)}\n`, "utf8");
 }
 function readUsageRecords(usagePath) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
     if (!usagePath || !fs.existsSync(usagePath))
         return [];
     const raw = fs.readFileSync(usagePath, "utf8");
@@ -686,16 +979,40 @@ function readUsageRecords(usagePath) {
                 continue;
             const input = Number((_a = parsed.inputTokens) !== null && _a !== void 0 ? _a : 0);
             const output = Number((_b = parsed.outputTokens) !== null && _b !== void 0 ? _b : 0);
-            const total = Number((_c = parsed.totalTokens) !== null && _c !== void 0 ? _c : input + output);
-            const type = (0, type_1.normalizeType)(parsed.type) || String((_d = parsed.type) !== null && _d !== void 0 ? _d : "unknown");
+            const cacheRead = Number((_e = (_d = (_c = parsed.cacheReadTokens) !== null && _c !== void 0 ? _c : parsed.cache_read_input_tokens) !== null && _d !== void 0 ? _d : parsed.cacheReadInputTokens) !== null && _e !== void 0 ? _e : 0);
+            const cacheWrite = Number((_j = (_h = (_g = (_f = parsed.cacheWriteTokens) !== null && _f !== void 0 ? _f : parsed.cache_creation_input_tokens) !== null && _g !== void 0 ? _g : parsed.cache_write_input_tokens) !== null && _h !== void 0 ? _h : parsed.cacheWriteInputTokens) !== null && _j !== void 0 ? _j : 0);
+            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((_k = parsed.totalTokens) !== null && _k !== void 0 ? _k : computedTotal);
+            const finalTotal = Number.isFinite(total)
+                ? Math.max(total, computedTotal)
+                : computedTotal;
+            const type = (0, type_1.normalizeType)(parsed.type) || String((_l = parsed.type) !== null && _l !== void 0 ? _l : "unknown");
+            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;
             records.push({
-                ts: String((_e = parsed.ts) !== null && _e !== void 0 ? _e : ""),
+                ts: String((_m = parsed.ts) !== null && _m !== void 0 ? _m : ""),
                 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,
             });
         }
         catch {
@@ -747,30 +1064,52 @@ function syncUsageFromSessions(config, configPath, usagePath) {
                 return;
             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;
                 }
             }
@@ -780,30 +1119,43 @@ function syncUsageFromSessions(config, configPath, usagePath) {
                     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] = {
@@ -812,10 +1164,13 @@ function syncUsageFromSessions(config, configPath, usagePath) {
                 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,
             };
         };
         for (const filePath of codexFiles)