@praeviso/code-env-switch 0.1.5 → 0.1.6

package/bin/usage/index.js

@@ -16,6 +16,7 @@ exports.syncUsageFromStatuslineInput = syncUsageFromStatuslineInput;
 exports.logProfileUse = logProfileUse;
 exports.logSessionBinding = logSessionBinding;
 exports.readSessionBindingIndex = readSessionBindingIndex;
+exports.clearUsageHistory = clearUsageHistory;
 exports.readUsageRecords = readUsageRecords;
 exports.syncUsageFromSessions = syncUsageFromSessions;
 /**
@@ -26,6 +27,7 @@ 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]) {
@@ -393,17 +395,32 @@ function syncUsageFromStatuslineInput(config, configPath, type, profileKey, prof
         let deltaCacheRead = cacheReadTokens - prevCacheRead;
         let deltaCacheWrite = cacheWriteTokens - prevCacheWrite;
         let deltaTotal = totalTokens - prevTotal;
-        if (deltaTotal < 0 ||
-            deltaInput < 0 ||
-            deltaOutput < 0 ||
-            deltaCacheRead < 0 ||
-            deltaCacheWrite < 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(),
@@ -434,6 +451,7 @@ function syncUsageFromStatuslineInput(config, configPath, type, profileKey, prof
             model: resolvedModel,
         };
         state.sessions = sessions;
+        updateUsageStateMetadata(state, usagePath);
         writeUsageState(statePath, state);
     }
     finally {
@@ -588,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: {} };
@@ -599,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))
@@ -708,10 +820,12 @@ function parseCodexSessionFile(filePath) {
     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;
@@ -759,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);
@@ -772,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 {
@@ -786,13 +907,18 @@ 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,
-        cacheReadTokens: 0,
+        cacheReadTokens,
         cacheWriteTokens: 0,
-        totalTokens: maxTotal,
+        totalTokens,
         startTs: tsRange.start,
         endTs: tsRange.end,
         cwd,
@@ -955,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)) {
@@ -969,6 +1177,7 @@ function readUsageRecords(usagePath) {
     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)
@@ -977,19 +1186,29 @@ 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 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 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((_k = parsed.totalTokens) !== null && _k !== void 0 ? _k : computedTotal);
+            const total = Number((_l = parsed.totalTokens) !== null && _l !== void 0 ? _l : 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) ||
@@ -1001,7 +1220,7 @@ function readUsageRecords(usagePath) {
                 parsed.sessionID ||
                 parsed.session ||
                 null;
-            records.push({
+            const record = {
                 ts: String((_m = parsed.ts) !== null && _m !== void 0 ? _m : ""),
                 type,
                 profileKey: parsed.profileKey ? String(parsed.profileKey) : null,
@@ -1013,7 +1232,12 @@ function readUsageRecords(usagePath) {
                 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
@@ -1022,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);
@@ -1032,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) => {
@@ -1179,6 +1420,7 @@ function syncUsageFromSessions(config, configPath, usagePath) {
             processFile(filePath, "claude");
         state.files = files;
         state.sessions = sessions;
+        updateUsageStateMetadata(state, usagePath);
         writeUsageState(statePath, state);
     }
     finally {

package/package.json

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

package/src/cli/args.ts

@@ -5,6 +5,7 @@ import type {
     ParsedArgs,
     InitArgs,
     AddArgs,
+    UsageResetArgs,
     ProfileType,
     StatuslineArgs,
 } from "../types";
@@ -156,6 +157,19 @@ export function parseAddArgs(args: string[]): AddArgs {
     return result;
 }
 
+export function parseUsageResetArgs(args: string[]): UsageResetArgs {
+    const result: UsageResetArgs = { yes: false };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "-y" || arg === "--yes") {
+            result.yes = true;
+            continue;
+        }
+        throw new Error(`Unknown usage-reset argument: ${arg}`);
+    }
+    return result;
+}
+
 function parseNumberFlag(value: string | null | undefined, flag: string): number {
     if (value === null || value === undefined || value === "") {
         throw new Error(`Missing value for ${flag}.`);

package/src/cli/help.ts

@@ -27,6 +27,7 @@ Usage:
   codenv launch <codex|claude> [--] [args...]
   codenv init
   codenv statusline [options]
+  codenv usage-reset [--yes]
 
 Options:
   -c, --config <path>   Path to config JSON
@@ -57,6 +58,9 @@ Statusline options:
   --usage-output <n>          Set output token usage
   --sync-usage                Sync usage from sessions before reading
 
+Usage reset options:
+  -y, --yes                   Skip confirmation prompt
+
 Examples:
   codenv init
   codenv use codex primary
@@ -67,6 +71,7 @@ Examples:
   codenv remove --all
   codenv launch codex -- --help
   codenv statusline --format json
+  codenv usage-reset --yes
   CODE_ENV_CONFIG=~/.config/code-env/config.json codenv use claude default
   codenv add --type codex primary OPENAI_BASE_URL=https://api.example.com/v1 OPENAI_API_KEY=YOUR_API_KEY
   codenv add

package/src/cli/index.ts

@@ -1,5 +1,11 @@
 /**
  * CLI module exports
  */
-export { parseArgs, parseInitArgs, parseAddArgs, parseStatuslineArgs } from "./args";
+export {
+    parseArgs,
+    parseInitArgs,
+    parseAddArgs,
+    parseUsageResetArgs,
+    parseStatuslineArgs,
+} from "./args";
 export { printHelp } from "./help";

package/src/commands/index.ts

@@ -8,3 +8,4 @@ export { printShow } from "./show";
 export { printUnset } from "./unset";
 export { runLaunch } from "./launch";
 export { printStatusline } from "./statusline";
+export { runUsageReset } from "./usage";

package/src/commands/usage.ts

@@ -0,0 +1,53 @@
+/**
+ * Usage history reset command
+ */
+import type { Config, UsageResetArgs } from "../types";
+import { clearUsageHistory } from "../usage";
+import { askConfirm, createReadline } from "../ui";
+
+export async function runUsageReset(
+    config: Config,
+    configPath: string | null,
+    args: UsageResetArgs
+): Promise<void> {
+    if (!args.yes) {
+        const rl = createReadline();
+        try {
+            const confirmed = await askConfirm(
+                rl,
+                "Clear all usage history files? This cannot be undone. (y/N): "
+            );
+            if (!confirmed) return;
+        } finally {
+            rl.close();
+        }
+    }
+
+    const result = clearUsageHistory(config, configPath);
+    const removed = result.removed.sort();
+    const missing = result.missing.sort();
+    const failed = result.failed.sort((a, b) => a.path.localeCompare(b.path));
+
+    if (removed.length === 0 && failed.length === 0) {
+        console.log("No usage files found.");
+        return;
+    }
+
+    if (removed.length > 0) {
+        console.log(`Removed ${removed.length} file(s):`);
+        for (const filePath of removed) {
+            console.log(`- ${filePath}`);
+        }
+    }
+
+    if (missing.length > 0) {
+        console.log(`Skipped ${missing.length} missing file(s).`);
+    }
+
+    if (failed.length > 0) {
+        for (const failure of failed) {
+            console.error(`Failed to remove ${failure.path}: ${failure.error}`);
+        }
+        process.exitCode = 1;
+    }
+}

package/src/index.ts

@@ -10,6 +10,7 @@ import {
     parseArgs,
     parseInitArgs,
     parseAddArgs,
+    parseUsageResetArgs,
     parseStatuslineArgs,
     printHelp,
 } from "./cli";
@@ -33,6 +34,7 @@ import {
     printUnset,
     runLaunch,
     printStatusline,
+    runUsageReset,
 } from "./commands";
 import { logProfileUse } from "./usage";
 import { createReadline, askConfirm, runInteractiveAdd, runInteractiveUse } from "./ui";
@@ -152,6 +154,15 @@ async function main() {
             return;
         }
 
+        if (cmd === "usage-reset" || cmd === "reset-usage") {
+            const resetArgs = parseUsageResetArgs(args.slice(1));
+            const configPath =
+                process.env.CODE_ENV_CONFIG_PATH || findConfigPath(parsed.configPath);
+            const config = readConfigIfExists(configPath);
+            await runUsageReset(config, configPath, resetArgs);
+            return;
+        }
+
         const configPath = findConfigPath(parsed.configPath);
         const config = readConfig(configPath!);
 

package/src/statusline/debug.ts

@@ -16,7 +16,7 @@ function resolveDefaultConfigDir(configPath: string | null): string {
     return path.join(os.homedir(), ".config", "code-env");
 }
 
-function getStatuslineDebugPath(configPath: string | null): string {
+export function getStatuslineDebugPath(configPath: string | null): string {
     const envPath = resolvePath(process.env.CODE_ENV_STATUSLINE_DEBUG_PATH);
     if (envPath) return envPath;
     return path.join(resolveDefaultConfigDir(configPath), "statusline-debug.jsonl");