@praeviso/code-env-switch 0.1.2 → 0.1.3

package/bin/statusline/index.js

@@ -139,32 +139,169 @@ function getInputProfile(input) {
     return input.profile;
 }
 function getInputUsage(input) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
     if (!input)
         return null;
     if (isRecord(input.usage)) {
         return input.usage;
     }
     const tokenUsage = input.token_usage;
-    if (tokenUsage === null || tokenUsage === undefined)
+    if (tokenUsage !== null && tokenUsage !== undefined) {
+        if (typeof tokenUsage === "number") {
+            return {
+                todayTokens: null,
+                totalTokens: coerceNumber(tokenUsage),
+                inputTokens: null,
+                outputTokens: null,
+            };
+        }
+        if (isRecord(tokenUsage)) {
+            const record = tokenUsage;
+            const todayTokens = (_a = firstNumber(record.todayTokens, record.today, record.today_tokens, record.daily, record.daily_tokens)) !== null && _a !== void 0 ? _a : null;
+            const totalTokens = (_b = firstNumber(record.totalTokens, record.total, record.total_tokens)) !== null && _b !== void 0 ? _b : null;
+            const inputTokens = (_c = firstNumber(record.inputTokens, record.input, record.input_tokens)) !== null && _c !== void 0 ? _c : null;
+            const outputTokens = (_d = firstNumber(record.outputTokens, record.output, record.output_tokens)) !== null && _d !== void 0 ? _d : null;
+            const cacheRead = (_e = firstNumber(record.cache_read_input_tokens, record.cacheReadInputTokens, record.cache_read, record.cacheRead)) !== null && _e !== void 0 ? _e : null;
+            const cacheWrite = (_f = firstNumber(record.cache_creation_input_tokens, record.cacheCreationInputTokens, record.cache_write_input_tokens, record.cacheWriteInputTokens, record.cache_write, record.cacheWrite)) !== null && _f !== void 0 ? _f : null;
+            if (todayTokens === null &&
+                totalTokens === null &&
+                inputTokens === null &&
+                outputTokens === null &&
+                cacheRead === null &&
+                cacheWrite === null) {
+                return null;
+            }
+            const hasCacheTokens = cacheRead !== null || cacheWrite !== null;
+            const computedTotal = hasCacheTokens
+                ? (inputTokens || 0) +
+                    (outputTokens || 0) +
+                    (cacheRead || 0) +
+                    (cacheWrite || 0)
+                : null;
+            const resolvedTodayTokens = hasCacheTokens
+                ? (_g = todayTokens !== null && todayTokens !== void 0 ? todayTokens : totalTokens) !== null && _g !== void 0 ? _g : computedTotal
+                : todayTokens;
+            return {
+                todayTokens: resolvedTodayTokens,
+                totalTokens: totalTokens !== null && totalTokens !== void 0 ? totalTokens : null,
+                inputTokens,
+                outputTokens,
+            };
+        }
+    }
+    const contextWindow = isRecord(input.context_window)
+        ? input.context_window
+        : isRecord(input.contextWindow)
+            ? input.contextWindow
+            : null;
+    if (!contextWindow)
         return null;
-    if (typeof tokenUsage === "number") {
+    const totalInputTokens = (_h = firstNumber(contextWindow.total_input_tokens, contextWindow.totalInputTokens)) !== null && _h !== void 0 ? _h : null;
+    const totalOutputTokens = (_j = firstNumber(contextWindow.total_output_tokens, contextWindow.totalOutputTokens)) !== null && _j !== void 0 ? _j : null;
+    if (totalInputTokens !== null || totalOutputTokens !== null) {
         return {
             todayTokens: null,
-            totalTokens: coerceNumber(tokenUsage),
-            inputTokens: null,
-            outputTokens: null,
+            totalTokens: null,
+            inputTokens: totalInputTokens,
+            outputTokens: totalOutputTokens,
         };
     }
-    if (isRecord(tokenUsage)) {
-        const record = tokenUsage;
+    const currentUsage = isRecord(contextWindow.current_usage)
+        ? contextWindow.current_usage
+        : isRecord(contextWindow.currentUsage)
+            ? contextWindow.currentUsage
+            : null;
+    if (!currentUsage)
+        return null;
+    const inputTokens = (_k = firstNumber(currentUsage.input_tokens, currentUsage.inputTokens)) !== null && _k !== void 0 ? _k : null;
+    const outputTokens = (_l = firstNumber(currentUsage.output_tokens, currentUsage.outputTokens)) !== null && _l !== void 0 ? _l : null;
+    const cacheRead = (_m = firstNumber(currentUsage.cache_read_input_tokens, currentUsage.cacheReadInputTokens)) !== null && _m !== void 0 ? _m : null;
+    const cacheWrite = (_o = firstNumber(currentUsage.cache_creation_input_tokens, currentUsage.cacheCreationInputTokens)) !== null && _o !== void 0 ? _o : null;
+    if (inputTokens === null &&
+        outputTokens === null &&
+        cacheRead === null &&
+        cacheWrite === null) {
+        return null;
+    }
+    const totalTokens = (inputTokens || 0) +
+        (outputTokens || 0) +
+        (cacheRead || 0) +
+        (cacheWrite || 0);
+    return {
+        todayTokens: totalTokens,
+        totalTokens: null,
+        inputTokens,
+        outputTokens,
+    };
+}
+function getSessionId(input) {
+    if (!input)
+        return null;
+    return firstNonEmpty(input.session_id, input.sessionId);
+}
+function parseUsageTotalsRecord(record) {
+    var _a, _b, _c, _d, _e;
+    const inputTokens = (_a = firstNumber(record.inputTokens, record.input, record.input_tokens)) !== null && _a !== void 0 ? _a : null;
+    const outputTokens = (_b = firstNumber(record.outputTokens, record.output, record.output_tokens)) !== null && _b !== void 0 ? _b : null;
+    const totalTokens = (_c = firstNumber(record.totalTokens, record.total, record.total_tokens)) !== null && _c !== void 0 ? _c : null;
+    const cacheRead = (_d = firstNumber(record.cache_read_input_tokens, record.cacheReadInputTokens, record.cache_read, record.cacheRead)) !== null && _d !== void 0 ? _d : null;
+    const cacheWrite = (_e = firstNumber(record.cache_creation_input_tokens, record.cacheCreationInputTokens, record.cache_write_input_tokens, record.cacheWriteInputTokens, record.cache_write, record.cacheWrite)) !== null && _e !== void 0 ? _e : null;
+    let computedTotal = null;
+    if (inputTokens !== null ||
+        outputTokens !== null ||
+        cacheRead !== null ||
+        cacheWrite !== null) {
+        computedTotal =
+            (inputTokens || 0) +
+                (outputTokens || 0) +
+                (cacheRead || 0) +
+                (cacheWrite || 0);
+    }
+    const resolvedTotal = totalTokens !== null && totalTokens !== void 0 ? totalTokens : computedTotal;
+    if (inputTokens === null &&
+        outputTokens === null &&
+        resolvedTotal === null) {
+        return null;
+    }
+    return {
+        inputTokens,
+        outputTokens,
+        totalTokens: resolvedTotal,
+    };
+}
+function getUsageTotalsFromInput(input) {
+    var _a, _b;
+    if (!input)
+        return null;
+    const contextWindow = isRecord(input.context_window)
+        ? input.context_window
+        : isRecord(input.contextWindow)
+            ? input.contextWindow
+            : null;
+    if (contextWindow) {
+        const totalInputTokens = (_a = firstNumber(contextWindow.total_input_tokens, contextWindow.totalInputTokens)) !== null && _a !== void 0 ? _a : null;
+        const totalOutputTokens = (_b = firstNumber(contextWindow.total_output_tokens, contextWindow.totalOutputTokens)) !== null && _b !== void 0 ? _b : null;
+        if (totalInputTokens !== null || totalOutputTokens !== null) {
+            return {
+                inputTokens: totalInputTokens,
+                outputTokens: totalOutputTokens,
+                totalTokens: (totalInputTokens || 0) + (totalOutputTokens || 0),
+            };
+        }
+    }
+    if (typeof input.token_usage === "number") {
         return {
-            todayTokens: (_a = firstNumber(record.todayTokens, record.today, record.today_tokens, record.daily, record.daily_tokens)) !== null && _a !== void 0 ? _a : null,
-            totalTokens: (_b = firstNumber(record.totalTokens, record.total, record.total_tokens)) !== null && _b !== void 0 ? _b : null,
-            inputTokens: (_c = firstNumber(record.inputTokens, record.input, record.input_tokens)) !== null && _c !== void 0 ? _c : null,
-            outputTokens: (_d = firstNumber(record.outputTokens, record.output, record.output_tokens)) !== null && _d !== void 0 ? _d : null,
+            inputTokens: null,
+            outputTokens: null,
+            totalTokens: coerceNumber(input.token_usage),
         };
     }
+    if (isRecord(input.token_usage)) {
+        return parseUsageTotalsRecord(input.token_usage);
+    }
+    if (isRecord(input.usage)) {
+        return parseUsageTotalsRecord(input.usage);
+    }
     return null;
 }
 function getContextUsedTokens(input) {
@@ -172,6 +309,21 @@ function getContextUsedTokens(input) {
         return null;
     return coerceNumber(input.context_window_used_tokens);
 }
+function normalizeInputUsage(inputUsage) {
+    if (!inputUsage)
+        return null;
+    const usage = {
+        todayTokens: coerceNumber(inputUsage.todayTokens),
+        totalTokens: coerceNumber(inputUsage.totalTokens),
+        inputTokens: coerceNumber(inputUsage.inputTokens),
+        outputTokens: coerceNumber(inputUsage.outputTokens),
+    };
+    const hasUsage = usage.todayTokens !== null ||
+        usage.totalTokens !== null ||
+        usage.inputTokens !== null ||
+        usage.outputTokens !== null;
+    return hasUsage ? usage : null;
+}
 function getContextLeftPercent(input, type) {
     if (!input)
         return null;
@@ -383,7 +535,7 @@ function buildStatuslineResult(args, config, configPath) {
     }
     let type = normalizeTypeValue(typeCandidate);
     const envProfile = resolveEnvProfile(type);
-    let profileKey = firstNonEmpty(args.profileKey, envProfile.key, inputProfile ? inputProfile.key : null);
+    const profileKey = firstNonEmpty(args.profileKey, envProfile.key, inputProfile ? inputProfile.key : null);
     let profileName = firstNonEmpty(args.profileName, envProfile.name, inputProfile ? inputProfile.name : null);
     if (profileKey && !profileName && config.profiles && config.profiles[profileKey]) {
         const profile = config.profiles[profileKey];
@@ -401,6 +553,12 @@ function buildStatuslineResult(args, config, configPath) {
             type = inferred;
     }
     const cwd = firstNonEmpty(args.cwd, process.env.CODE_ENV_CWD, getWorkspaceDir(stdinInput), stdinInput ? stdinInput.cwd : null, process.cwd());
+    const sessionId = getSessionId(stdinInput);
+    const stdinUsageTotals = getUsageTotalsFromInput(stdinInput);
+    if (args.syncUsage && sessionId && stdinUsageTotals) {
+        const usageType = (0, type_1.normalizeType)(type || "");
+        (0, usage_1.syncUsageFromStatuslineInput)(config, configPath, usageType, profileKey, profileName, sessionId, stdinUsageTotals, cwd);
+    }
     const model = firstNonEmpty(args.model, process.env.CODE_ENV_MODEL, getModelFromInput(stdinInput));
     const modelProvider = firstNonEmpty(process.env.CODE_ENV_MODEL_PROVIDER, getModelProviderFromInput(stdinInput));
     const usage = {
@@ -413,7 +571,11 @@ function buildStatuslineResult(args, config, configPath) {
         usage.totalTokens !== null ||
         usage.inputTokens !== null ||
         usage.outputTokens !== null;
+    const stdinUsage = normalizeInputUsage(getInputUsage(stdinInput));
     let finalUsage = hasExplicitUsage ? usage : null;
+    if (!finalUsage) {
+        finalUsage = stdinUsage;
+    }
     if (!finalUsage) {
         finalUsage = resolveUsageFromRecords(config, configPath, type, profileKey, profileName, args.syncUsage);
     }

package/bin/usage/index.js

@@ -9,6 +9,7 @@ exports.formatTokenCount = formatTokenCount;
 exports.buildUsageTotals = buildUsageTotals;
 exports.readUsageTotalsIndex = readUsageTotalsIndex;
 exports.resolveUsageTotalsForProfile = resolveUsageTotalsForProfile;
+exports.syncUsageFromStatuslineInput = syncUsageFromStatuslineInput;
 exports.logProfileUse = logProfileUse;
 exports.logSessionBinding = logSessionBinding;
 exports.readSessionBindingIndex = readSessionBindingIndex;
@@ -120,6 +121,18 @@ function normalizeUsageType(type) {
     const trimmed = String(type).trim();
     return trimmed ? trimmed : null;
 }
+function buildSessionKey(type, sessionId) {
+    const normalized = normalizeUsageType(type || "");
+    return normalized ? `${normalized}::${sessionId}` : sessionId;
+}
+function toFiniteNumber(value) {
+    if (value === null || value === undefined)
+        return null;
+    const num = Number(value);
+    if (!Number.isFinite(num))
+        return null;
+    return num;
+}
 function buildUsageLookupKey(type, profileId) {
     if (!profileId)
         return null;
@@ -147,6 +160,75 @@ 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;
+    if (!sessionId)
+        return;
+    if (!totals)
+        return;
+    if (!profileKey && !profileName)
+        return;
+    const normalizedType = (0, type_1.normalizeType)(type || "");
+    if (!normalizedType)
+        return;
+    const usagePath = getUsagePath(config, configPath);
+    if (!usagePath)
+        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;
+    if (!Number.isFinite(totalTokens))
+        return;
+    const statePath = getUsageStatePath(usagePath, config);
+    const lockPath = `${statePath}.lock`;
+    const lockFd = acquireLock(lockPath);
+    if (lockFd === null)
+        return;
+    try {
+        const state = readUsageState(statePath);
+        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;
+        let deltaInput = inputTokens - prevInput;
+        let deltaOutput = outputTokens - prevOutput;
+        let deltaTotal = totalTokens - prevTotal;
+        if (deltaTotal < 0 || deltaInput < 0 || deltaOutput < 0) {
+            deltaInput = inputTokens;
+            deltaOutput = outputTokens;
+            deltaTotal = totalTokens;
+        }
+        if (deltaTotal > 0) {
+            const record = {
+                ts: new Date().toISOString(),
+                type: normalizedType,
+                profileKey: profileKey || null,
+                profileName: profileName || null,
+                inputTokens: deltaInput,
+                outputTokens: deltaOutput,
+                totalTokens: deltaTotal,
+            };
+            appendUsageRecord(usagePath, record);
+        }
+        const now = new Date().toISOString();
+        sessions[key] = {
+            type: normalizedType,
+            inputTokens,
+            outputTokens,
+            totalTokens,
+            startTs: prev ? prev.startTs : now,
+            endTs: now,
+            cwd: cwd || (prev ? prev.cwd : null),
+        };
+        state.sessions = sessions;
+        writeUsageState(statePath, state);
+    }
+    finally {
+        releaseLock(lockPath, lockFd);
+    }
+}
 function logProfileUse(config, configPath, profileKey, requestedType, terminalTag, cwd) {
     const profile = config.profiles && config.profiles[profileKey];
     if (!profile)
@@ -285,19 +367,20 @@ function resolveProfileForSession(config, logEntries, type, sessionFile, session
 }
 function readUsageState(statePath) {
     if (!statePath || !fs.existsSync(statePath)) {
-        return { version: 1, files: {} };
+        return { version: 1, files: {}, sessions: {} };
     }
     try {
         const raw = fs.readFileSync(statePath, "utf8");
         const parsed = JSON.parse(raw);
         if (!parsed || typeof parsed !== "object") {
-            return { version: 1, files: {} };
+            return { version: 1, files: {}, sessions: {} };
         }
         const files = parsed.files && typeof parsed.files === "object" ? parsed.files : {};
-        return { version: 1, files };
+        const sessions = parsed.sessions && typeof parsed.sessions === "object" ? parsed.sessions : {};
+        return { version: 1, files, sessions };
     }
     catch {
-        return { version: 1, files: {} };
+        return { version: 1, files: {}, sessions: {} };
     }
 }
 function writeUsageState(statePath, state) {
@@ -632,6 +715,7 @@ function syncUsageFromSessions(config, configPath, usagePath) {
         const logEntries = readProfileLogEntries([profileLogPath]);
         const state = readUsageState(statePath);
         const files = state.files || {};
+        const sessions = state.sessions || {};
         const codexFiles = collectSessionFiles(getCodexSessionsPath(config));
         const claudeFiles = collectSessionFiles(getClaudeSessionsPath(config));
         const processFile = (filePath, type) => {
@@ -661,16 +745,34 @@ function syncUsageFromSessions(config, configPath, usagePath) {
             const resolved = resolveProfileForSession(config, logEntries, type, filePath, stats.sessionId);
             if (!resolved.match)
                 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;
-            let deltaInput = stats.inputTokens - prevInput;
-            let deltaOutput = stats.outputTokens - prevOutput;
-            let deltaTotal = stats.totalTokens - prevTotal;
+            const prevInputMax = sessionPrev
+                ? Math.max(prevInput, sessionPrev.inputTokens)
+                : prevInput;
+            const prevOutputMax = sessionPrev
+                ? Math.max(prevOutput, sessionPrev.outputTokens)
+                : prevOutput;
+            const prevTotalMax = sessionPrev
+                ? Math.max(prevTotal, sessionPrev.totalTokens)
+                : prevTotal;
+            let deltaInput = stats.inputTokens - prevInputMax;
+            let deltaOutput = stats.outputTokens - prevOutputMax;
+            let deltaTotal = stats.totalTokens - prevTotalMax;
             if (deltaTotal < 0 || deltaInput < 0 || deltaOutput < 0) {
-                deltaInput = stats.inputTokens;
-                deltaOutput = stats.outputTokens;
-                deltaTotal = stats.totalTokens;
+                if (sessionPrev) {
+                    deltaInput = 0;
+                    deltaOutput = 0;
+                    deltaTotal = 0;
+                }
+                else {
+                    deltaInput = stats.inputTokens;
+                    deltaOutput = stats.outputTokens;
+                    deltaTotal = stats.totalTokens;
+                }
             }
             if (deltaTotal > 0) {
                 const record = {
@@ -684,6 +786,26 @@ function syncUsageFromSessions(config, configPath, usagePath) {
                 };
                 appendUsageRecord(usagePath, record);
             }
+            if (sessionKey) {
+                const nextInput = sessionPrev
+                    ? Math.max(sessionPrev.inputTokens, stats.inputTokens)
+                    : stats.inputTokens;
+                const nextOutput = sessionPrev
+                    ? Math.max(sessionPrev.outputTokens, stats.outputTokens)
+                    : stats.outputTokens;
+                const nextTotal = sessionPrev
+                    ? Math.max(sessionPrev.totalTokens, stats.totalTokens)
+                    : stats.totalTokens;
+                sessions[sessionKey] = {
+                    type,
+                    inputTokens: nextInput,
+                    outputTokens: nextOutput,
+                    totalTokens: nextTotal,
+                    startTs: sessionPrev ? sessionPrev.startTs : stats.startTs,
+                    endTs: stats.endTs || (sessionPrev ? sessionPrev.endTs : null),
+                    cwd: stats.cwd || (sessionPrev ? sessionPrev.cwd : null),
+                };
+            }
             files[filePath] = {
                 mtimeMs: stat.mtimeMs,
                 size: stat.size,
@@ -701,6 +823,7 @@ function syncUsageFromSessions(config, configPath, usagePath) {
         for (const filePath of claudeFiles)
             processFile(filePath, "claude");
         state.files = files;
+        state.sessions = sessions;
         writeUsageState(statePath, state);
     }
     finally {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@praeviso/code-env-switch",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Switch between Claude Code and Codex environment variables from a single CLI",
   "bin": {
     "codenv": "bin/index.js"

package/src/statusline/index.ts

@@ -11,6 +11,7 @@ import {
     formatTokenCount,
     readUsageTotalsIndex,
     resolveUsageTotalsForProfile,
+    syncUsageFromStatuslineInput,
 } from "../usage";
 
 interface StatuslineInputProfile {
@@ -26,6 +27,28 @@ interface StatuslineInputUsage {
     outputTokens?: number;
 }
 
+interface StatuslineInputContextWindowUsage {
+    input_tokens?: number;
+    output_tokens?: number;
+    cache_creation_input_tokens?: number;
+    cache_read_input_tokens?: number;
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheCreationInputTokens?: number;
+    cacheReadInputTokens?: number;
+}
+
+interface StatuslineInputContextWindow {
+    current_usage?: StatuslineInputContextWindowUsage | null;
+    total_input_tokens?: number;
+    total_output_tokens?: number;
+    context_window_size?: number;
+    currentUsage?: StatuslineInputContextWindowUsage | null;
+    totalInputTokens?: number;
+    totalOutputTokens?: number;
+    contextWindowSize?: number;
+}
+
 interface StatuslineInputModel {
     id?: string;
     displayName?: string;
@@ -45,6 +68,8 @@ interface StatuslineInput {
     review_mode?: boolean;
     context_window_percent?: number;
     context_window_used_tokens?: number;
+    context_window?: StatuslineInputContextWindow | Record<string, unknown> | null;
+    contextWindow?: StatuslineInputContextWindow | Record<string, unknown> | null;
     workspace?: {
         current_dir?: string;
         project_dir?: string;
@@ -53,6 +78,7 @@ interface StatuslineInput {
     version?: string;
     output_style?: { name?: string };
     session_id?: string;
+    sessionId?: string;
     transcript_path?: string;
     hook_event_name?: string;
 }
@@ -64,6 +90,12 @@ interface StatuslineUsage {
     outputTokens: number | null;
 }
 
+interface StatuslineUsageTotals {
+    inputTokens: number | null;
+    outputTokens: number | null;
+    totalTokens: number | null;
+}
+
 interface GitStatus {
     branch: string | null;
     ahead: number;
@@ -218,46 +250,269 @@ function getInputUsage(input: StatuslineInput | null): StatuslineInputUsage | nu
         return input.usage as StatuslineInputUsage;
     }
     const tokenUsage = input.token_usage;
-    if (tokenUsage === null || tokenUsage === undefined) return null;
-    if (typeof tokenUsage === "number") {
-        return {
-            todayTokens: null,
-            totalTokens: coerceNumber(tokenUsage),
-            inputTokens: null,
-            outputTokens: null,
-        };
-    }
-    if (isRecord(tokenUsage)) {
-        const record = tokenUsage as Record<string, unknown>;
-        return {
-            todayTokens:
+    if (tokenUsage !== null && tokenUsage !== undefined) {
+        if (typeof tokenUsage === "number") {
+            return {
+                todayTokens: null,
+                totalTokens: coerceNumber(tokenUsage),
+                inputTokens: null,
+                outputTokens: null,
+            };
+        }
+        if (isRecord(tokenUsage)) {
+            const record = tokenUsage as Record<string, unknown>;
+            const todayTokens =
                 firstNumber(
                     record.todayTokens,
                     record.today,
                     record.today_tokens,
                     record.daily,
                     record.daily_tokens
-                ) ?? null,
-            totalTokens:
+                ) ?? null;
+            const totalTokens =
                 firstNumber(
                     record.totalTokens,
                     record.total,
                     record.total_tokens
-                ) ?? null,
-            inputTokens:
+                ) ?? null;
+            const inputTokens =
                 firstNumber(
                     record.inputTokens,
                     record.input,
                     record.input_tokens
-                ) ?? null,
-            outputTokens:
+                ) ?? null;
+            const outputTokens =
                 firstNumber(
                     record.outputTokens,
                     record.output,
                     record.output_tokens
-                ) ?? null,
+                ) ?? null;
+            const cacheRead =
+                firstNumber(
+                    record.cache_read_input_tokens,
+                    record.cacheReadInputTokens,
+                    record.cache_read,
+                    record.cacheRead
+                ) ?? null;
+            const cacheWrite =
+                firstNumber(
+                    record.cache_creation_input_tokens,
+                    record.cacheCreationInputTokens,
+                    record.cache_write_input_tokens,
+                    record.cacheWriteInputTokens,
+                    record.cache_write,
+                    record.cacheWrite
+                ) ?? null;
+            if (
+                todayTokens === null &&
+                totalTokens === null &&
+                inputTokens === null &&
+                outputTokens === null &&
+                cacheRead === null &&
+                cacheWrite === null
+            ) {
+                return null;
+            }
+            const hasCacheTokens = cacheRead !== null || cacheWrite !== null;
+            const computedTotal = hasCacheTokens
+                ? (inputTokens || 0) +
+                  (outputTokens || 0) +
+                  (cacheRead || 0) +
+                  (cacheWrite || 0)
+                : null;
+            const resolvedTodayTokens = hasCacheTokens
+                ? todayTokens ?? totalTokens ?? computedTotal
+                : todayTokens;
+            return {
+                todayTokens: resolvedTodayTokens,
+                totalTokens: totalTokens ?? null,
+                inputTokens,
+                outputTokens,
+            };
+        }
+    }
+    const contextWindow = isRecord(input.context_window)
+        ? (input.context_window as Record<string, unknown>)
+        : isRecord(input.contextWindow)
+        ? (input.contextWindow as Record<string, unknown>)
+        : null;
+    if (!contextWindow) return null;
+    const totalInputTokens =
+        firstNumber(
+            contextWindow.total_input_tokens,
+            contextWindow.totalInputTokens
+        ) ?? null;
+    const totalOutputTokens =
+        firstNumber(
+            contextWindow.total_output_tokens,
+            contextWindow.totalOutputTokens
+        ) ?? null;
+    if (totalInputTokens !== null || totalOutputTokens !== null) {
+        return {
+            todayTokens: null,
+            totalTokens: null,
+            inputTokens: totalInputTokens,
+            outputTokens: totalOutputTokens,
         };
     }
+    const currentUsage = isRecord(contextWindow.current_usage)
+        ? (contextWindow.current_usage as Record<string, unknown>)
+        : isRecord(contextWindow.currentUsage)
+        ? (contextWindow.currentUsage as Record<string, unknown>)
+        : null;
+    if (!currentUsage) return null;
+    const inputTokens =
+        firstNumber(
+            currentUsage.input_tokens,
+            currentUsage.inputTokens
+        ) ?? null;
+    const outputTokens =
+        firstNumber(
+            currentUsage.output_tokens,
+            currentUsage.outputTokens
+        ) ?? null;
+    const cacheRead =
+        firstNumber(
+            currentUsage.cache_read_input_tokens,
+            currentUsage.cacheReadInputTokens
+        ) ?? null;
+    const cacheWrite =
+        firstNumber(
+            currentUsage.cache_creation_input_tokens,
+            currentUsage.cacheCreationInputTokens
+        ) ?? null;
+    if (
+        inputTokens === null &&
+        outputTokens === null &&
+        cacheRead === null &&
+        cacheWrite === null
+    ) {
+        return null;
+    }
+    const totalTokens =
+        (inputTokens || 0) +
+        (outputTokens || 0) +
+        (cacheRead || 0) +
+        (cacheWrite || 0);
+    return {
+        todayTokens: totalTokens,
+        totalTokens: null,
+        inputTokens,
+        outputTokens,
+    };
+}
+
+function getSessionId(input: StatuslineInput | null): string | null {
+    if (!input) return null;
+    return firstNonEmpty(input.session_id, input.sessionId);
+}
+
+function parseUsageTotalsRecord(
+    record: Record<string, unknown>
+): StatuslineUsageTotals | null {
+    const inputTokens =
+        firstNumber(
+            record.inputTokens,
+            record.input,
+            record.input_tokens
+        ) ?? null;
+    const outputTokens =
+        firstNumber(
+            record.outputTokens,
+            record.output,
+            record.output_tokens
+        ) ?? null;
+    const totalTokens =
+        firstNumber(
+            record.totalTokens,
+            record.total,
+            record.total_tokens
+        ) ?? null;
+    const cacheRead =
+        firstNumber(
+            record.cache_read_input_tokens,
+            record.cacheReadInputTokens,
+            record.cache_read,
+            record.cacheRead
+        ) ?? null;
+    const cacheWrite =
+        firstNumber(
+            record.cache_creation_input_tokens,
+            record.cacheCreationInputTokens,
+            record.cache_write_input_tokens,
+            record.cacheWriteInputTokens,
+            record.cache_write,
+            record.cacheWrite
+        ) ?? null;
+    let computedTotal: number | null = null;
+    if (
+        inputTokens !== null ||
+        outputTokens !== null ||
+        cacheRead !== null ||
+        cacheWrite !== null
+    ) {
+        computedTotal =
+            (inputTokens || 0) +
+            (outputTokens || 0) +
+            (cacheRead || 0) +
+            (cacheWrite || 0);
+    }
+    const resolvedTotal = totalTokens ?? computedTotal;
+    if (
+        inputTokens === null &&
+        outputTokens === null &&
+        resolvedTotal === null
+    ) {
+        return null;
+    }
+    return {
+        inputTokens,
+        outputTokens,
+        totalTokens: resolvedTotal,
+    };
+}
+
+function getUsageTotalsFromInput(
+    input: StatuslineInput | null
+): StatuslineUsageTotals | null {
+    if (!input) return null;
+    const contextWindow = isRecord(input.context_window)
+        ? (input.context_window as Record<string, unknown>)
+        : isRecord(input.contextWindow)
+        ? (input.contextWindow as Record<string, unknown>)
+        : null;
+    if (contextWindow) {
+        const totalInputTokens =
+            firstNumber(
+                contextWindow.total_input_tokens,
+                contextWindow.totalInputTokens
+            ) ?? null;
+        const totalOutputTokens =
+            firstNumber(
+                contextWindow.total_output_tokens,
+                contextWindow.totalOutputTokens
+            ) ?? null;
+        if (totalInputTokens !== null || totalOutputTokens !== null) {
+            return {
+                inputTokens: totalInputTokens,
+                outputTokens: totalOutputTokens,
+                totalTokens: (totalInputTokens || 0) + (totalOutputTokens || 0),
+            };
+        }
+    }
+    if (typeof input.token_usage === "number") {
+        return {
+            inputTokens: null,
+            outputTokens: null,
+            totalTokens: coerceNumber(input.token_usage),
+        };
+    }
+    if (isRecord(input.token_usage)) {
+        return parseUsageTotalsRecord(input.token_usage as Record<string, unknown>);
+    }
+    if (isRecord(input.usage)) {
+        return parseUsageTotalsRecord(input.usage as Record<string, unknown>);
+    }
     return null;
 }
 
@@ -266,6 +521,24 @@ function getContextUsedTokens(input: StatuslineInput | null): number | null {
     return coerceNumber(input.context_window_used_tokens);
 }
 
+function normalizeInputUsage(
+    inputUsage: StatuslineInputUsage | null
+): StatuslineUsage | null {
+    if (!inputUsage) return null;
+    const usage: StatuslineUsage = {
+        todayTokens: coerceNumber(inputUsage.todayTokens),
+        totalTokens: coerceNumber(inputUsage.totalTokens),
+        inputTokens: coerceNumber(inputUsage.inputTokens),
+        outputTokens: coerceNumber(inputUsage.outputTokens),
+    };
+    const hasUsage =
+        usage.todayTokens !== null ||
+        usage.totalTokens !== null ||
+        usage.inputTokens !== null ||
+        usage.outputTokens !== null;
+    return hasUsage ? usage : null;
+}
+
 function getContextLeftPercent(
     input: StatuslineInput | null,
     type: string | null
@@ -496,7 +769,7 @@ export function buildStatuslineResult(
     let type = normalizeTypeValue(typeCandidate);
     const envProfile = resolveEnvProfile(type);
 
-    let profileKey = firstNonEmpty(
+    const profileKey = firstNonEmpty(
         args.profileKey,
         envProfile.key,
         inputProfile ? inputProfile.key : null
@@ -530,6 +803,22 @@ export function buildStatuslineResult(
         process.cwd()
     )!;
 
+    const sessionId = getSessionId(stdinInput);
+    const stdinUsageTotals = getUsageTotalsFromInput(stdinInput);
+    if (args.syncUsage && sessionId && stdinUsageTotals) {
+        const usageType = normalizeType(type || "");
+        syncUsageFromStatuslineInput(
+            config,
+            configPath,
+            usageType,
+            profileKey,
+            profileName,
+            sessionId,
+            stdinUsageTotals,
+            cwd
+        );
+    }
+
     const model = firstNonEmpty(
         args.model,
         process.env.CODE_ENV_MODEL,
@@ -565,7 +854,12 @@ export function buildStatuslineResult(
         usage.inputTokens !== null ||
         usage.outputTokens !== null;
 
+    const stdinUsage = normalizeInputUsage(getInputUsage(stdinInput));
+
     let finalUsage: StatuslineUsage | null = hasExplicitUsage ? usage : null;
+    if (!finalUsage) {
+        finalUsage = stdinUsage;
+    }
     if (!finalUsage) {
         finalUsage = resolveUsageFromRecords(
             config,

package/src/usage/index.ts

@@ -40,9 +40,20 @@ interface UsageStateEntry {
     cwd: string | null;
 }
 
+interface UsageSessionEntry {
+    type: ProfileType;
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    startTs: string | null;
+    endTs: string | null;
+    cwd: string | null;
+}
+
 interface UsageStateFile {
     version: number;
     files: Record<string, UsageStateEntry>;
+    sessions?: Record<string, UsageSessionEntry>;
 }
 
 interface ProfileLogEntry {
@@ -78,6 +89,12 @@ interface SessionStats {
     sessionId: string | null;
 }
 
+interface UsageTotalsInput {
+    inputTokens: number | null;
+    outputTokens: number | null;
+    totalTokens: number | null;
+}
+
 function resolveDefaultConfigDir(configPath: string | null): string {
     if (configPath) return path.dirname(configPath);
     return path.join(os.homedir(), ".config", "code-env");
@@ -172,6 +189,18 @@ function normalizeUsageType(type: string | null | undefined): string | null {
     return trimmed ? trimmed : null;
 }
 
+function buildSessionKey(type: ProfileType | null, sessionId: string): string {
+    const normalized = normalizeUsageType(type || "");
+    return normalized ? `${normalized}::${sessionId}` : sessionId;
+}
+
+function toFiniteNumber(value: number | null | undefined): number | null {
+    if (value === null || value === undefined) return null;
+    const num = Number(value);
+    if (!Number.isFinite(num)) return null;
+    return num;
+}
+
 function buildUsageLookupKey(
     type: string | null | undefined,
     profileId: string | null | undefined
@@ -212,6 +241,81 @@ export function resolveUsageTotalsForProfile(
     );
 }
 
+export function syncUsageFromStatuslineInput(
+    config: Config,
+    configPath: string | null,
+    type: ProfileType | null,
+    profileKey: string | null,
+    profileName: string | null,
+    sessionId: string | null,
+    totals: UsageTotalsInput | null,
+    cwd: string | null
+): void {
+    if (!sessionId) return;
+    if (!totals) return;
+    if (!profileKey && !profileName) 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 totalTokens =
+        toFiniteNumber(totals.totalTokens) ?? inputTokens + outputTokens;
+    if (!Number.isFinite(totalTokens)) return;
+
+    const statePath = getUsageStatePath(usagePath, config);
+    const lockPath = `${statePath}.lock`;
+    const lockFd = acquireLock(lockPath);
+    if (lockFd === null) return;
+    try {
+        const state = readUsageState(statePath);
+        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;
+
+        let deltaInput = inputTokens - prevInput;
+        let deltaOutput = outputTokens - prevOutput;
+        let deltaTotal = totalTokens - prevTotal;
+        if (deltaTotal < 0 || deltaInput < 0 || deltaOutput < 0) {
+            deltaInput = inputTokens;
+            deltaOutput = outputTokens;
+            deltaTotal = totalTokens;
+        }
+
+        if (deltaTotal > 0) {
+            const record: UsageRecord = {
+                ts: new Date().toISOString(),
+                type: normalizedType,
+                profileKey: profileKey || null,
+                profileName: profileName || null,
+                inputTokens: deltaInput,
+                outputTokens: deltaOutput,
+                totalTokens: deltaTotal,
+            };
+            appendUsageRecord(usagePath, record);
+        }
+
+        const now = new Date().toISOString();
+        sessions[key] = {
+            type: normalizedType,
+            inputTokens,
+            outputTokens,
+            totalTokens,
+            startTs: prev ? prev.startTs : now,
+            endTs: now,
+            cwd: cwd || (prev ? prev.cwd : null),
+        };
+        state.sessions = sessions;
+        writeUsageState(statePath, state);
+    } finally {
+        releaseLock(lockPath, lockFd);
+    }
+}
+
 export function logProfileUse(
     config: Config,
     configPath: string | null,
@@ -424,19 +528,21 @@ function resolveProfileForSession(
 
 function readUsageState(statePath: string): UsageStateFile {
     if (!statePath || !fs.existsSync(statePath)) {
-        return { version: 1, files: {} };
+        return { version: 1, files: {}, sessions: {} };
     }
     try {
         const raw = fs.readFileSync(statePath, "utf8");
         const parsed = JSON.parse(raw);
         if (!parsed || typeof parsed !== "object") {
-            return { version: 1, files: {} };
+            return { version: 1, files: {}, sessions: {} };
         }
         const files =
             parsed.files && typeof parsed.files === "object" ? parsed.files : {};
-        return { version: 1, files };
+        const sessions =
+            parsed.sessions && typeof parsed.sessions === "object" ? parsed.sessions : {};
+        return { version: 1, files, sessions };
     } catch {
-        return { version: 1, files: {} };
+        return { version: 1, files: {}, sessions: {} };
     }
 }
 
@@ -754,6 +860,7 @@ export function syncUsageFromSessions(
 
         const state = readUsageState(statePath);
         const files = state.files || {};
+        const sessions = state.sessions || {};
         const codexFiles = collectSessionFiles(getCodexSessionsPath(config));
         const claudeFiles = collectSessionFiles(getClaudeSessionsPath(config));
 
@@ -786,16 +893,34 @@ export function syncUsageFromSessions(
                 stats.sessionId
             );
             if (!resolved.match) 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;
-            let deltaInput = stats.inputTokens - prevInput;
-            let deltaOutput = stats.outputTokens - prevOutput;
-            let deltaTotal = stats.totalTokens - prevTotal;
+            const prevInputMax = sessionPrev
+                ? Math.max(prevInput, sessionPrev.inputTokens)
+                : prevInput;
+            const prevOutputMax = sessionPrev
+                ? Math.max(prevOutput, sessionPrev.outputTokens)
+                : prevOutput;
+            const prevTotalMax = sessionPrev
+                ? Math.max(prevTotal, sessionPrev.totalTokens)
+                : prevTotal;
+            let deltaInput = stats.inputTokens - prevInputMax;
+            let deltaOutput = stats.outputTokens - prevOutputMax;
+            let deltaTotal = stats.totalTokens - prevTotalMax;
             if (deltaTotal < 0 || deltaInput < 0 || deltaOutput < 0) {
-                deltaInput = stats.inputTokens;
-                deltaOutput = stats.outputTokens;
-                deltaTotal = stats.totalTokens;
+                if (sessionPrev) {
+                    deltaInput = 0;
+                    deltaOutput = 0;
+                    deltaTotal = 0;
+                } else {
+                    deltaInput = stats.inputTokens;
+                    deltaOutput = stats.outputTokens;
+                    deltaTotal = stats.totalTokens;
+                }
             }
             if (deltaTotal > 0) {
                 const record: UsageRecord = {
@@ -809,6 +934,26 @@ export function syncUsageFromSessions(
                 };
                 appendUsageRecord(usagePath, record);
             }
+            if (sessionKey) {
+                const nextInput = sessionPrev
+                    ? Math.max(sessionPrev.inputTokens, stats.inputTokens)
+                    : stats.inputTokens;
+                const nextOutput = sessionPrev
+                    ? Math.max(sessionPrev.outputTokens, stats.outputTokens)
+                    : stats.outputTokens;
+                const nextTotal = sessionPrev
+                    ? Math.max(sessionPrev.totalTokens, stats.totalTokens)
+                    : stats.totalTokens;
+                sessions[sessionKey] = {
+                    type,
+                    inputTokens: nextInput,
+                    outputTokens: nextOutput,
+                    totalTokens: nextTotal,
+                    startTs: sessionPrev ? sessionPrev.startTs : stats.startTs,
+                    endTs: stats.endTs || (sessionPrev ? sessionPrev.endTs : null),
+                    cwd: stats.cwd || (sessionPrev ? sessionPrev.cwd : null),
+                };
+            }
             files[filePath] = {
                 mtimeMs: stat.mtimeMs,
                 size: stat.size,
@@ -826,6 +971,7 @@ export function syncUsageFromSessions(
         for (const filePath of claudeFiles) processFile(filePath, "claude");
 
         state.files = files;
+        state.sessions = sessions;
         writeUsageState(statePath, state);
     } finally {
         releaseLock(lockPath, lockFd);