@praeviso/code-env-switch 0.1.4 → 0.1.6

package/bin/usage/index.js

@@ -8,11 +8,15 @@ 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;
 exports.readSessionBindingIndex = readSessionBindingIndex;
+exports.clearUsageHistory = clearUsageHistory;
 exports.readUsageRecords = readUsageRecords;
 exports.syncUsageFromSessions = syncUsageFromSessions;
 /**
@@ -23,6 +27,24 @@ const path = require("path");
 const os = require("os");
 const utils_1 = require("../shell/utils");
 const type_1 = require("../profile/type");
+const debug_1 = require("../statusline/debug");
+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 +94,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 +236,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 +274,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 +341,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 +367,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,25 +385,54 @@ 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) {
+            // 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) {
             const record = {
                 ts: new Date().toISOString(),
                 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,12 +442,16 @@ 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;
+        updateUsageStateMetadata(state, usagePath);
         writeUsageState(statePath, state);
     }
     finally {
@@ -377,7 +606,15 @@ function readUsageState(statePath) {
         }
         const files = 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: {} };
@@ -388,7 +625,93 @@ function writeUsageState(statePath, state) {
     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, filePath) {
+    if (!filePath)
+        return;
+    const dir = path.dirname(filePath);
+    let entries = [];
+    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));
+        }
+    }
+}
+function clearUsageHistory(config, configPath) {
+    const targets = new Set();
+    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 = (0, debug_1.getStatuslineDebugPath)(configPath);
+    if (debugPath) {
+        targets.add(debugPath);
+        addSiblingBackupPaths(targets, debugPath);
+    }
+    const removed = [];
+    const missing = [];
+    const failed = [];
+    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) {
     if (!root || !fs.existsSync(root))
@@ -433,19 +756,80 @@ 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/);
     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, end: null };
     let cwd = null;
     let sessionId = null;
+    let model = null;
     for (const line of lines) {
         const trimmed = line.trim();
         if (!trimmed)
@@ -454,6 +838,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") {
@@ -484,12 +873,16 @@ function parseCodexSessionFile(filePath) {
                     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);
@@ -497,10 +890,13 @@ function parseCodexSessionFile(filePath) {
                     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 {
@@ -511,15 +907,23 @@ function parseCodexSessionFile(filePath) {
         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,
     };
 }
 function parseClaudeSessionFile(filePath) {
@@ -529,9 +933,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 +947,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 +971,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 +988,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;
@@ -662,6 +1081,88 @@ function releaseLock(lockPath, fd) {
         // ignore
     }
 }
+function readUsageFileStat(usagePath) {
+    if (!usagePath || !fs.existsSync(usagePath))
+        return null;
+    try {
+        return fs.statSync(usagePath);
+    }
+    catch {
+        return null;
+    }
+}
+function buildUsageRecordKey(record) {
+    var _a, _b, _c, _d;
+    return JSON.stringify([
+        record.ts,
+        record.type,
+        (_a = record.profileKey) !== null && _a !== void 0 ? _a : null,
+        (_b = record.profileName) !== null && _b !== void 0 ? _b : null,
+        (_c = record.model) !== null && _c !== void 0 ? _c : null,
+        (_d = record.sessionId) !== null && _d !== void 0 ? _d : null,
+        toUsageNumber(record.inputTokens),
+        toUsageNumber(record.outputTokens),
+        toUsageNumber(record.cacheReadTokens),
+        toUsageNumber(record.cacheWriteTokens),
+        toUsageNumber(record.totalTokens),
+    ]);
+}
+function buildUsageSessionsFromRecords(records) {
+    const sessions = {};
+    const seen = new Set();
+    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, record.sessionId);
+        let entry = sessions[sessionKey];
+        if (!entry) {
+            entry = {
+                type: normalizedType,
+                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, usagePath) {
+    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, record) {
     const dir = path.dirname(usagePath);
     if (!fs.existsSync(dir)) {
@@ -670,12 +1171,13 @@ 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");
     const lines = raw.split(/\r?\n/);
     const records = [];
+    const seen = new Set();
     for (const line of lines) {
         const trimmed = line.trim();
         if (!trimmed)
@@ -684,19 +1186,58 @@ function readUsageRecords(usagePath) {
             const parsed = JSON.parse(trimmed);
             if (!parsed || typeof parsed !== "object")
                 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");
-            records.push({
-                ts: String((_e = parsed.ts) !== null && _e !== void 0 ? _e : ""),
+            const type = (0, type_1.normalizeType)(parsed.type) || String((_a = parsed.type) !== null && _a !== void 0 ? _a : "unknown");
+            let input = Number((_b = parsed.inputTokens) !== null && _b !== void 0 ? _b : 0);
+            const output = Number((_c = parsed.outputTokens) !== null && _c !== void 0 ? _c : 0);
+            const cacheRead = Number((_f = (_e = (_d = parsed.cacheReadTokens) !== null && _d !== void 0 ? _d : parsed.cache_read_input_tokens) !== null && _e !== void 0 ? _e : parsed.cacheReadInputTokens) !== null && _f !== void 0 ? _f : 0);
+            const cacheWrite = Number((_k = (_j = (_h = (_g = parsed.cacheWriteTokens) !== null && _g !== void 0 ? _g : parsed.cache_creation_input_tokens) !== null && _h !== void 0 ? _h : parsed.cache_write_input_tokens) !== null && _j !== void 0 ? _j : parsed.cacheWriteInputTokens) !== null && _k !== void 0 ? _k : 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((_l = parsed.totalTokens) !== null && _l !== void 0 ? _l : 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 = {
+                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,
+            };
+            const key = buildUsageRecordKey(record);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            records.push(record);
         }
         catch {
             // ignore invalid lines
@@ -705,6 +1246,7 @@ function readUsageRecords(usagePath) {
     return records;
 }
 function syncUsageFromSessions(config, configPath, usagePath) {
+    var _a, _b;
     const statePath = getUsageStatePath(usagePath, config);
     const lockPath = `${statePath}.lock`;
     const lockFd = acquireLock(lockPath);
@@ -715,7 +1257,23 @@ function syncUsageFromSessions(config, configPath, usagePath) {
         const logEntries = readProfileLogEntries([profileLogPath]);
         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((_a = state.usageMtimeMs) !== null && _a !== void 0 ? _a : Number.NaN) &&
+            Number.isFinite((_b = state.usageSize) !== null && _b !== void 0 ? _b : 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));
         const processFile = (filePath, type) => {
@@ -747,30 +1305,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 +1360,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 +1405,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)
@@ -824,6 +1420,7 @@ function syncUsageFromSessions(config, configPath, usagePath) {
             processFile(filePath, "claude");
         state.files = files;
         state.sessions = sessions;
+        updateUsageStateMetadata(state, usagePath);
         writeUsageState(statePath, state);
     }
     finally {