ccstatusline 2.1.6 → 2.1.8

package/dist/ccstatusline.js

@@ -32056,8 +32056,8 @@ var require_utils = __commonJS((exports) => {
     }
     return output;
   };
-  exports.basename = (path5, { windows } = {}) => {
-    const segs = path5.split(windows ? /[\\/]/ : "/");
+  exports.basename = (path6, { windows } = {}) => {
+    const segs = path6.split(windows ? /[\\/]/ : "/");
     const last = segs[segs.length - 1];
     if (last === "") {
       return segs[segs.length - 2];
@@ -32408,7 +32408,7 @@ var require_parse = __commonJS((exports, module) => {
   var syntaxError = (type, char) => {
     return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
   };
-  var parse5 = (input, options) => {
+  var parse6 = (input, options) => {
     if (typeof input !== "string") {
       throw new TypeError("Expected a string");
     }
@@ -32557,7 +32557,7 @@ var require_parse = __commonJS((exports, module) => {
           output = token.close = `)$))${extglobStar}`;
         }
         if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
-          const expression = parse5(rest, { ...options, fastpaths: false }).output;
+          const expression = parse6(rest, { ...options, fastpaths: false }).output;
           output = token.close = `)${expression})${extglobStar})`;
         }
         if (token.prev.type === "bos") {
@@ -33083,7 +33083,7 @@ var require_parse = __commonJS((exports, module) => {
     }
     return state;
   };
-  parse5.fastpaths = (input, options) => {
+  parse6.fastpaths = (input, options) => {
     const opts = { ...options };
     const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
     const len = input.length;
@@ -33151,13 +33151,13 @@ var require_parse = __commonJS((exports, module) => {
     }
     return source;
   };
-  module.exports = parse5;
+  module.exports = parse6;
 });
 
 // node_modules/picomatch/lib/picomatch.js
 var require_picomatch = __commonJS((exports, module) => {
   var scan = require_scan();
-  var parse5 = require_parse();
+  var parse6 = require_parse();
   var utils = require_utils();
   var constants2 = require_constants3();
   var isObject2 = (val) => val && typeof val === "object" && !Array.isArray(val);
@@ -33247,7 +33247,7 @@ var require_picomatch = __commonJS((exports, module) => {
   picomatch.parse = (pattern, options) => {
     if (Array.isArray(pattern))
       return pattern.map((p) => picomatch.parse(p, options));
-    return parse5(pattern, { ...options, fastpaths: false });
+    return parse6(pattern, { ...options, fastpaths: false });
   };
   picomatch.scan = (input, options) => scan(input, options);
   picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => {
@@ -33273,10 +33273,10 @@ var require_picomatch = __commonJS((exports, module) => {
     }
     let parsed = { negated: false, fastpaths: true };
     if (options.fastpaths !== false && (input[0] === "." || input[0] === "*")) {
-      parsed.output = parse5.fastpaths(input, options);
+      parsed.output = parse6.fastpaths(input, options);
     }
     if (!parsed.output) {
-      parsed = parse5(input, options);
+      parsed = parse6(input, options);
     }
     return picomatch.compileRe(parsed, options, returnOutput, returnState);
   };
@@ -39277,108 +39277,15 @@ var import_react46 = __toESM(require_react(), 1);
 
 // src/utils/claude-settings.ts
 import { execSync } from "child_process";
-import * as fs2 from "fs";
-import * as os2 from "os";
-import * as path from "path";
-var readFile = fs2.promises.readFile;
-var writeFile = fs2.promises.writeFile;
-var mkdir = fs2.promises.mkdir;
-var CCSTATUSLINE_COMMANDS = {
-  NPM: "npx -y ccstatusline@latest",
-  BUNX: "bunx -y ccstatusline@latest",
-  SELF_MANAGED: "ccstatusline"
-};
-function getClaudeConfigDir() {
-  const envConfigDir = process.env.CLAUDE_CONFIG_DIR;
-  if (envConfigDir) {
-    try {
-      const resolvedPath = path.resolve(envConfigDir);
-      if (fs2.existsSync(resolvedPath)) {
-        const stats = fs2.statSync(resolvedPath);
-        if (stats.isDirectory()) {
-          return resolvedPath;
-        }
-      } else {
-        return resolvedPath;
-      }
-    } catch {}
-  }
-  return path.join(os2.homedir(), ".claude");
-}
-function getClaudeSettingsPath() {
-  return path.join(getClaudeConfigDir(), "settings.json");
-}
-async function loadClaudeSettings() {
-  try {
-    const settingsPath = getClaudeSettingsPath();
-    if (!fs2.existsSync(settingsPath)) {
-      return {};
-    }
-    const content = await readFile(settingsPath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return {};
-  }
-}
-async function saveClaudeSettings(settings) {
-  const settingsPath = getClaudeSettingsPath();
-  const dir = path.dirname(settingsPath);
-  await mkdir(dir, { recursive: true });
-  await writeFile(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
-}
-async function isInstalled() {
-  const settings = await loadClaudeSettings();
-  const validCommands = [
-    CCSTATUSLINE_COMMANDS.NPM,
-    CCSTATUSLINE_COMMANDS.BUNX,
-    CCSTATUSLINE_COMMANDS.SELF_MANAGED
-  ];
-  return validCommands.includes(settings.statusLine?.command ?? "") && (settings.statusLine?.padding === 0 || settings.statusLine?.padding === undefined);
-}
-function isBunxAvailable() {
-  try {
-    const command = process.platform === "win32" ? "where bunx" : "which bunx";
-    execSync(command, { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function installStatusLine(useBunx = false) {
-  const settings = await loadClaudeSettings();
-  settings.statusLine = {
-    type: "command",
-    command: useBunx ? CCSTATUSLINE_COMMANDS.BUNX : CCSTATUSLINE_COMMANDS.NPM,
-    padding: 0
-  };
-  await saveClaudeSettings(settings);
-}
-async function uninstallStatusLine() {
-  const settings = await loadClaudeSettings();
-  if (settings.statusLine) {
-    delete settings.statusLine;
-    await saveClaudeSettings(settings);
-  }
-}
-async function getExistingStatusLine() {
-  const settings = await loadClaudeSettings();
-  return settings.statusLine?.command ?? null;
-}
-
-// src/utils/clone-settings.ts
-function cloneSettings(settings) {
-  const cloneFn = globalThis.structuredClone;
-  if (typeof cloneFn === "function") {
-    return cloneFn(settings);
-  }
-  return JSON.parse(JSON.stringify(settings));
-}
-
-// src/utils/config.ts
 import * as fs3 from "fs";
 import * as os3 from "os";
 import * as path2 from "path";
 
+// src/utils/config.ts
+import * as fs2 from "fs";
+import * as os2 from "os";
+import * as path from "path";
+
 // node_modules/zod/v4/classic/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -40060,15 +39967,15 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path2) {
-  if (!path2)
+function getElementAtPath(obj, path) {
+  if (!path)
     return obj;
-  return path2.reduce((acc, key) => acc?.[key], obj);
+  return path.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
-  const promises2 = keys.map((key) => promisesObj[key]);
-  return Promise.all(promises2).then((results) => {
+  const promises = keys.map((key) => promisesObj[key]);
+  return Promise.all(promises).then((results) => {
     const resolvedObj = {};
     for (let i = 0;i < keys.length; i++) {
       resolvedObj[keys[i]] = results[i];
@@ -40398,11 +40305,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path2, issues) {
+function prefixIssues(path, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path2);
+    iss.path.unshift(path);
     return iss;
   });
 }
@@ -40533,7 +40440,7 @@ function treeifyError(error, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error2, path2 = []) => {
+  const processError = (error2, path = []) => {
     var _a, _b;
     for (const issue2 of error2.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -40543,7 +40450,7 @@ function treeifyError(error, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path2, ...issue2.path];
+        const fullpath = [...path, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -40575,8 +40482,8 @@ function treeifyError(error, _mapper) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path2 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path2) {
+  const path = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -50999,6 +50906,84 @@ function generateGuid() {
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+var V1_FIELD_RULES = [
+  {
+    key: "flexMode",
+    isValid: (value) => typeof value === "string"
+  },
+  {
+    key: "compactThreshold",
+    isValid: (value) => typeof value === "number"
+  },
+  {
+    key: "colorLevel",
+    isValid: (value) => typeof value === "number"
+  },
+  {
+    key: "defaultSeparator",
+    isValid: (value) => typeof value === "string"
+  },
+  {
+    key: "defaultPadding",
+    isValid: (value) => typeof value === "string"
+  },
+  {
+    key: "inheritSeparatorColors",
+    isValid: (value) => typeof value === "boolean"
+  },
+  {
+    key: "overrideBackgroundColor",
+    isValid: (value) => typeof value === "string"
+  },
+  {
+    key: "overrideForegroundColor",
+    isValid: (value) => typeof value === "string"
+  },
+  {
+    key: "globalBold",
+    isValid: (value) => typeof value === "boolean"
+  }
+];
+function toWidgetLine(line, stripSeparators) {
+  const lineToProcess = stripSeparators ? line.filter((item) => {
+    if (isRecord(item)) {
+      return item.type !== "separator";
+    }
+    return true;
+  }) : line;
+  const typedLine = [];
+  for (const item of lineToProcess) {
+    if (isRecord(item) && typeof item.type === "string") {
+      typedLine.push({
+        ...item,
+        id: generateGuid(),
+        type: item.type
+      });
+    }
+  }
+  return typedLine;
+}
+function migrateV1Lines(data) {
+  if (!Array.isArray(data.lines)) {
+    return;
+  }
+  const stripSeparators = Boolean(data.defaultSeparator);
+  const processedLines = [];
+  for (const line of data.lines) {
+    if (Array.isArray(line)) {
+      processedLines.push(toWidgetLine(line, stripSeparators));
+    }
+  }
+  return processedLines;
+}
+function copyV1Fields(data, target) {
+  for (const rule of V1_FIELD_RULES) {
+    const value = data[rule.key];
+    if (rule.isValid(value)) {
+      target[rule.key] = value;
+    }
+  }
+}
 var migrations = [
   {
     fromVersion: 1,
@@ -51006,52 +50991,11 @@ var migrations = [
     description: "Migrate from v1 to v2",
     migrate: (data) => {
       const migrated = {};
-      if (data.lines && Array.isArray(data.lines)) {
-        const processedLines = [];
-        for (const line of data.lines) {
-          if (Array.isArray(line)) {
-            let processedLine = line;
-            if (data.defaultSeparator) {
-              processedLine = line.filter((item) => {
-                if (isRecord(item)) {
-                  return item.type !== "separator";
-                }
-                return true;
-              });
-            }
-            const typedLine = [];
-            for (const item of processedLine) {
-              if (isRecord(item) && typeof item.type === "string") {
-                typedLine.push({
-                  ...item,
-                  id: generateGuid(),
-                  type: item.type
-                });
-              }
-            }
-            processedLines.push(typedLine);
-          }
-        }
+      const processedLines = migrateV1Lines(data);
+      if (processedLines) {
         migrated.lines = processedLines;
       }
-      if (typeof data.flexMode === "string")
-        migrated.flexMode = data.flexMode;
-      if (typeof data.compactThreshold === "number")
-        migrated.compactThreshold = data.compactThreshold;
-      if (typeof data.colorLevel === "number")
-        migrated.colorLevel = data.colorLevel;
-      if (typeof data.defaultSeparator === "string")
-        migrated.defaultSeparator = data.defaultSeparator;
-      if (typeof data.defaultPadding === "string")
-        migrated.defaultPadding = data.defaultPadding;
-      if (typeof data.inheritSeparatorColors === "boolean")
-        migrated.inheritSeparatorColors = data.inheritSeparatorColors;
-      if (typeof data.overrideBackgroundColor === "string")
-        migrated.overrideBackgroundColor = data.overrideBackgroundColor;
-      if (typeof data.overrideForegroundColor === "string")
-        migrated.overrideForegroundColor = data.overrideForegroundColor;
-      if (typeof data.globalBold === "boolean")
-        migrated.globalBold = data.globalBold;
+      copyV1Fields(data, migrated);
       migrated.version = 2;
       migrated.updatemessage = {
         message: "ccstatusline updated to v2.0.0, launch tui to use new settings",
@@ -51101,85 +51045,224 @@ function needsMigration(data, targetVersion) {
 }
 
 // src/utils/config.ts
-var readFile2 = fs3.promises.readFile;
-var writeFile2 = fs3.promises.writeFile;
-var mkdir2 = fs3.promises.mkdir;
-var CONFIG_DIR = path2.join(os3.homedir(), ".config", "ccstatusline");
-var SETTINGS_PATH = path2.join(CONFIG_DIR, "settings.json");
-var SETTINGS_BACKUP_PATH = path2.join(CONFIG_DIR, "settings.bak");
-async function backupBadSettings() {
+var readFile = fs2.promises.readFile;
+var writeFile = fs2.promises.writeFile;
+var mkdir = fs2.promises.mkdir;
+var DEFAULT_SETTINGS_PATH = path.join(os2.homedir(), ".config", "ccstatusline", "settings.json");
+var settingsPath = DEFAULT_SETTINGS_PATH;
+function initConfigPath(filePath) {
+  settingsPath = filePath ? path.resolve(filePath) : DEFAULT_SETTINGS_PATH;
+}
+function getConfigPath() {
+  return settingsPath;
+}
+function isCustomConfigPath() {
+  return settingsPath !== DEFAULT_SETTINGS_PATH;
+}
+function getSettingsPaths() {
+  const configDir = path.dirname(settingsPath);
+  const parsedPath = path.parse(settingsPath);
+  const backupBaseName = parsedPath.ext ? `${parsedPath.name}.bak` : `${parsedPath.base}.bak`;
+  return {
+    configDir,
+    settingsPath,
+    settingsBackupPath: path.join(configDir, backupBaseName)
+  };
+}
+async function writeSettingsJson(settings, paths) {
+  await mkdir(paths.configDir, { recursive: true });
+  await writeFile(paths.settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+}
+async function backupBadSettings(paths) {
   try {
-    if (fs3.existsSync(SETTINGS_PATH)) {
-      const content = await readFile2(SETTINGS_PATH, "utf-8");
-      await writeFile2(SETTINGS_BACKUP_PATH, content, "utf-8");
-      console.error(`Bad settings backed up to ${SETTINGS_BACKUP_PATH}`);
+    if (fs2.existsSync(paths.settingsPath)) {
+      const content = await readFile(paths.settingsPath, "utf-8");
+      await writeFile(paths.settingsBackupPath, content, "utf-8");
+      console.error(`Bad settings backed up to ${paths.settingsBackupPath}`);
     }
   } catch (error43) {
     console.error("Failed to backup bad settings:", error43);
   }
 }
-async function writeDefaultSettings() {
+async function writeDefaultSettings(paths) {
   const defaults = SettingsSchema.parse({});
   const settingsWithVersion = {
     ...defaults,
     version: CURRENT_VERSION
   };
   try {
-    await mkdir2(CONFIG_DIR, { recursive: true });
-    await writeFile2(SETTINGS_PATH, JSON.stringify(settingsWithVersion, null, 2), "utf-8");
-    console.error(`Default settings written to ${SETTINGS_PATH}`);
+    await writeSettingsJson(settingsWithVersion, paths);
+    console.error(`Default settings written to ${paths.settingsPath}`);
   } catch (error43) {
     console.error("Failed to write default settings:", error43);
   }
   return defaults;
 }
+async function recoverWithDefaults(paths) {
+  await backupBadSettings(paths);
+  return await writeDefaultSettings(paths);
+}
 async function loadSettings() {
+  const paths = getSettingsPaths();
   try {
-    if (!fs3.existsSync(SETTINGS_PATH))
-      return await writeDefaultSettings();
-    const content = await readFile2(SETTINGS_PATH, "utf-8");
+    if (!fs2.existsSync(paths.settingsPath))
+      return await writeDefaultSettings(paths);
+    const content = await readFile(paths.settingsPath, "utf-8");
     let rawData;
     try {
       rawData = JSON.parse(content);
     } catch {
       console.error("Failed to parse settings.json, backing up and using defaults");
-      await backupBadSettings();
-      return await writeDefaultSettings();
+      return await recoverWithDefaults(paths);
     }
     const hasVersion = typeof rawData === "object" && rawData !== null && "version" in rawData;
     if (!hasVersion) {
       const v1Result = SettingsSchema_v1.safeParse(rawData);
       if (!v1Result.success) {
         console.error("Invalid v1 settings format:", v1Result.error);
-        await backupBadSettings();
-        return await writeDefaultSettings();
+        return await recoverWithDefaults(paths);
       }
       rawData = migrateConfig(rawData, CURRENT_VERSION);
-      await writeFile2(SETTINGS_PATH, JSON.stringify(rawData, null, 2), "utf-8");
+      await writeSettingsJson(rawData, paths);
     } else if (needsMigration(rawData, CURRENT_VERSION)) {
       rawData = migrateConfig(rawData, CURRENT_VERSION);
-      await writeFile2(SETTINGS_PATH, JSON.stringify(rawData, null, 2), "utf-8");
+      await writeSettingsJson(rawData, paths);
     }
     const result = SettingsSchema.safeParse(rawData);
     if (!result.success) {
       console.error("Failed to parse settings:", result.error);
-      await backupBadSettings();
-      return await writeDefaultSettings();
+      return await recoverWithDefaults(paths);
     }
     return result.data;
   } catch (error43) {
     console.error("Error loading settings:", error43);
-    await backupBadSettings();
-    return await writeDefaultSettings();
+    return await recoverWithDefaults(paths);
   }
 }
 async function saveSettings(settings) {
-  await mkdir2(CONFIG_DIR, { recursive: true });
+  const paths = getSettingsPaths();
   const settingsWithVersion = {
     ...settings,
     version: CURRENT_VERSION
   };
-  await writeFile2(SETTINGS_PATH, JSON.stringify(settingsWithVersion, null, 2), "utf-8");
+  await writeSettingsJson(settingsWithVersion, paths);
+}
+
+// src/utils/claude-settings.ts
+var readFile2 = fs3.promises.readFile;
+var writeFile2 = fs3.promises.writeFile;
+var mkdir2 = fs3.promises.mkdir;
+var CCSTATUSLINE_COMMANDS = {
+  NPM: "npx -y ccstatusline@latest",
+  BUNX: "bunx -y ccstatusline@latest",
+  SELF_MANAGED: "ccstatusline"
+};
+function isKnownCommand(command) {
+  const prefixes = [CCSTATUSLINE_COMMANDS.NPM, CCSTATUSLINE_COMMANDS.BUNX, CCSTATUSLINE_COMMANDS.SELF_MANAGED];
+  return prefixes.some((prefix) => command === prefix || command.startsWith(`${prefix} --config `));
+}
+function needsQuoting(filePath) {
+  if (process.platform === "win32") {
+    return /[\s&()<>|^"]/.test(filePath);
+  }
+  return /[\s()[\];&#|'"\\$`]/.test(filePath);
+}
+function quotePathIfNeeded(filePath) {
+  if (!needsQuoting(filePath)) {
+    return filePath;
+  }
+  if (process.platform === "win32") {
+    return `"${filePath.replace(/"/g, '""')}"`;
+  }
+  return `'${filePath.replace(/'/g, "'\\''")}'`;
+}
+function getClaudeConfigDir() {
+  const envConfigDir = process.env.CLAUDE_CONFIG_DIR;
+  if (envConfigDir) {
+    try {
+      const resolvedPath = path2.resolve(envConfigDir);
+      if (fs3.existsSync(resolvedPath)) {
+        const stats = fs3.statSync(resolvedPath);
+        if (stats.isDirectory()) {
+          return resolvedPath;
+        }
+      } else {
+        return resolvedPath;
+      }
+    } catch {}
+  }
+  return path2.join(os3.homedir(), ".claude");
+}
+function getClaudeSettingsPath() {
+  return path2.join(getClaudeConfigDir(), "settings.json");
+}
+async function loadClaudeSettings() {
+  try {
+    const settingsPath2 = getClaudeSettingsPath();
+    if (!fs3.existsSync(settingsPath2)) {
+      return {};
+    }
+    const content = await readFile2(settingsPath2, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+async function saveClaudeSettings(settings) {
+  const settingsPath2 = getClaudeSettingsPath();
+  const dir = path2.dirname(settingsPath2);
+  await mkdir2(dir, { recursive: true });
+  await writeFile2(settingsPath2, JSON.stringify(settings, null, 2), "utf-8");
+}
+async function isInstalled() {
+  const settings = await loadClaudeSettings();
+  const command = settings.statusLine?.command ?? "";
+  return isKnownCommand(command) && (settings.statusLine?.padding === 0 || settings.statusLine?.padding === undefined);
+}
+function isBunxAvailable() {
+  try {
+    const command = process.platform === "win32" ? "where bunx" : "which bunx";
+    execSync(command, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function buildCommand(baseCommand) {
+  if (isCustomConfigPath()) {
+    return `${baseCommand} --config ${quotePathIfNeeded(getConfigPath())}`;
+  }
+  return baseCommand;
+}
+async function installStatusLine(useBunx = false) {
+  const settings = await loadClaudeSettings();
+  const baseCommand = useBunx ? CCSTATUSLINE_COMMANDS.BUNX : CCSTATUSLINE_COMMANDS.NPM;
+  settings.statusLine = {
+    type: "command",
+    command: buildCommand(baseCommand),
+    padding: 0
+  };
+  await saveClaudeSettings(settings);
+}
+async function uninstallStatusLine() {
+  const settings = await loadClaudeSettings();
+  if (settings.statusLine) {
+    delete settings.statusLine;
+    await saveClaudeSettings(settings);
+  }
+}
+async function getExistingStatusLine() {
+  const settings = await loadClaudeSettings();
+  return settings.statusLine?.command ?? null;
+}
+
+// src/utils/clone-settings.ts
+function cloneSettings(settings) {
+  const cloneFn = globalThis.structuredClone;
+  if (typeof cloneFn === "function") {
+    return cloneFn(settings);
+  }
+  return JSON.parse(JSON.stringify(settings));
 }
 
 // src/utils/open-url.ts
@@ -51201,6 +51284,32 @@ function runOpenCommand(command, args) {
   }
   return null;
 }
+var PLATFORM_OPEN_PLANS = {
+  darwin: [
+    {
+      command: "open",
+      args: (url2) => [url2]
+    }
+  ],
+  win32: [
+    {
+      command: "cmd",
+      args: (url2) => ["/c", "start", "", url2]
+    }
+  ],
+  linux: [
+    {
+      command: "xdg-open",
+      args: (url2) => [url2],
+      errorPrefix: "xdg-open failed: "
+    },
+    {
+      command: "gio",
+      args: (url2) => ["open", url2],
+      errorPrefix: "gio open failed: "
+    }
+  ]
+};
 function openExternalUrl(url2) {
   let parsedUrl;
   try {
@@ -51218,31 +51327,28 @@ function openExternalUrl(url2) {
     };
   }
   const platform3 = os4.platform();
-  if (platform3 === "darwin") {
-    const commandError = runOpenCommand("open", [url2]);
-    return commandError ? { success: false, error: commandError } : { success: true };
-  }
-  if (platform3 === "win32") {
-    const commandError = runOpenCommand("cmd", ["/c", "start", "", url2]);
-    return commandError ? { success: false, error: commandError } : { success: true };
+  const plans = PLATFORM_OPEN_PLANS[platform3];
+  if (!plans) {
+    return {
+      success: false,
+      error: `Unsupported platform: ${platform3}`
+    };
   }
-  if (platform3 === "linux") {
-    const xdgError = runOpenCommand("xdg-open", [url2]);
-    if (!xdgError) {
+  const errors3 = [];
+  for (const plan of plans) {
+    const commandError = runOpenCommand(plan.command, plan.args(url2));
+    if (!commandError) {
       return { success: true };
     }
-    const gioError = runOpenCommand("gio", ["open", url2]);
-    if (!gioError) {
-      return { success: true };
+    if (plan.errorPrefix) {
+      errors3.push(`${plan.errorPrefix}${commandError}`);
+    } else {
+      errors3.push(commandError);
     }
-    return {
-      success: false,
-      error: `xdg-open failed: ${xdgError}; gio open failed: ${gioError}`
-    };
   }
   return {
     success: false,
-    error: `Unsupported platform: ${platform3}`
+    error: errors3.join("; ")
   };
 }
 
@@ -51478,7 +51584,7 @@ import { execSync as execSync3 } from "child_process";
 import * as fs5 from "fs";
 import * as path4 from "path";
 var __dirname = "/Users/sirmalloc/Projects/Personal/ccstatusline/src/utils";
-var PACKAGE_VERSION = "2.1.6";
+var PACKAGE_VERSION = "2.1.8";
 function getPackageVersion() {
   if (/^\d+\.\d+\.\d+/.test(PACKAGE_VERSION)) {
     return PACKAGE_VERSION;
@@ -54566,54 +54672,309 @@ var CustomCommandEditor = ({ widget, onComplete, onCancel, action }) => {
     children: "Unknown editor mode"
   }, undefined, false, undefined, this);
 };
-// src/utils/usage.ts
-import {
-  execSync as execSync6,
-  spawnSync as spawnSync2
-} from "child_process";
-import * as fs7 from "fs";
-import * as os7 from "os";
-import * as path7 from "path";
-
-// src/utils/jsonl.ts
+// src/utils/usage-fetch.ts
+import { execSync as execSync6 } from "child_process";
 import * as fs6 from "fs";
-import { createHash } from "node:crypto";
-import os6 from "node:os";
-import path6 from "node:path";
+import * as https from "https";
+import * as os6 from "os";
+import * as path5 from "path";
 
-// node_modules/tinyglobby/dist/index.mjs
-import path5, { posix } from "path";
+// src/utils/usage-types.ts
+var FIVE_HOUR_BLOCK_MS = 5 * 60 * 60 * 1000;
+var SEVEN_DAY_WINDOW_MS = 7 * 24 * 60 * 60 * 1000;
+var UsageErrorSchema = exports_external.enum(["no-credentials", "timeout", "api-error", "parse-error"]);
 
-// node_modules/fdir/dist/index.mjs
-import { createRequire as createRequire2 } from "module";
-import { basename as basename2, dirname as dirname2, normalize, relative, resolve as resolve2, sep } from "path";
-import * as nativeFs from "fs";
-var __require2 = /* @__PURE__ */ createRequire2(import.meta.url);
-function cleanPath(path5) {
-  let normalized = normalize(path5);
+// src/utils/usage-fetch.ts
+var CACHE_DIR = path5.join(os6.homedir(), ".cache", "ccstatusline");
+var CACHE_FILE = path5.join(CACHE_DIR, "usage.json");
+var LOCK_FILE = path5.join(CACHE_DIR, "usage.lock");
+var CACHE_MAX_AGE = 180;
+var LOCK_MAX_AGE = 30;
+var TOKEN_CACHE_MAX_AGE = 3600;
+var UsageCredentialsSchema = exports_external.object({ claudeAiOauth: exports_external.object({ accessToken: exports_external.string().nullable().optional() }).optional() });
+var CachedUsageDataSchema = exports_external.object({
+  sessionUsage: exports_external.number().nullable().optional(),
+  sessionResetAt: exports_external.string().nullable().optional(),
+  weeklyUsage: exports_external.number().nullable().optional(),
+  weeklyResetAt: exports_external.string().nullable().optional(),
+  extraUsageEnabled: exports_external.boolean().nullable().optional(),
+  extraUsageLimit: exports_external.number().nullable().optional(),
+  extraUsageUsed: exports_external.number().nullable().optional(),
+  extraUsageUtilization: exports_external.number().nullable().optional(),
+  error: exports_external.string().nullable().optional()
+});
+var UsageApiResponseSchema = exports_external.object({
+  five_hour: exports_external.object({
+    utilization: exports_external.number().nullable().optional(),
+    resets_at: exports_external.string().nullable().optional()
+  }).optional(),
+  seven_day: exports_external.object({
+    utilization: exports_external.number().nullable().optional(),
+    resets_at: exports_external.string().nullable().optional()
+  }).optional(),
+  extra_usage: exports_external.object({
+    is_enabled: exports_external.boolean().nullable().optional(),
+    monthly_limit: exports_external.number().nullable().optional(),
+    used_credits: exports_external.number().nullable().optional(),
+    utilization: exports_external.number().nullable().optional()
+  }).optional()
+});
+function parseJsonWithSchema(rawJson, schema) {
+  try {
+    const parsed = schema.safeParse(JSON.parse(rawJson));
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}
+function parseUsageAccessToken(rawJson) {
+  const parsed = parseJsonWithSchema(rawJson, UsageCredentialsSchema);
+  return parsed?.claudeAiOauth?.accessToken ?? null;
+}
+function parseCachedUsageData(rawJson) {
+  const parsed = parseJsonWithSchema(rawJson, CachedUsageDataSchema);
+  if (!parsed) {
+    return null;
+  }
+  const parsedError = UsageErrorSchema.safeParse(parsed.error);
+  return {
+    sessionUsage: parsed.sessionUsage ?? undefined,
+    sessionResetAt: parsed.sessionResetAt ?? undefined,
+    weeklyUsage: parsed.weeklyUsage ?? undefined,
+    weeklyResetAt: parsed.weeklyResetAt ?? undefined,
+    extraUsageEnabled: parsed.extraUsageEnabled ?? undefined,
+    extraUsageLimit: parsed.extraUsageLimit ?? undefined,
+    extraUsageUsed: parsed.extraUsageUsed ?? undefined,
+    extraUsageUtilization: parsed.extraUsageUtilization ?? undefined,
+    error: parsedError.success ? parsedError.data : undefined
+  };
+}
+function parseUsageApiResponse(rawJson) {
+  const parsed = parseJsonWithSchema(rawJson, UsageApiResponseSchema);
+  if (!parsed) {
+    return null;
+  }
+  return {
+    sessionUsage: parsed.five_hour?.utilization ?? undefined,
+    sessionResetAt: parsed.five_hour?.resets_at ?? undefined,
+    weeklyUsage: parsed.seven_day?.utilization ?? undefined,
+    weeklyResetAt: parsed.seven_day?.resets_at ?? undefined,
+    extraUsageEnabled: parsed.extra_usage?.is_enabled ?? undefined,
+    extraUsageLimit: parsed.extra_usage?.monthly_limit ?? undefined,
+    extraUsageUsed: parsed.extra_usage?.used_credits ?? undefined,
+    extraUsageUtilization: parsed.extra_usage?.utilization ?? undefined
+  };
+}
+var cachedUsageData = null;
+var usageCacheTime = 0;
+var cachedUsageToken = null;
+var usageTokenCacheTime = 0;
+function setCachedUsageError(error43, now) {
+  const errorData = { error: error43 };
+  cachedUsageData = errorData;
+  usageCacheTime = now;
+  return errorData;
+}
+function getStaleUsageOrError(error43, now) {
+  const stale = readStaleUsageCache();
+  if (stale && !stale.error) {
+    cachedUsageData = stale;
+    usageCacheTime = now;
+    return stale;
+  }
+  return setCachedUsageError(error43, now);
+}
+function getUsageToken() {
+  const now = Math.floor(Date.now() / 1000);
+  if (cachedUsageToken && now - usageTokenCacheTime < TOKEN_CACHE_MAX_AGE) {
+    return cachedUsageToken;
+  }
+  try {
+    const isMac = process.platform === "darwin";
+    if (isMac) {
+      const result = execSync6('security find-generic-password -s "Claude Code-credentials" -w 2>/dev/null', { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+      const token2 = parseUsageAccessToken(result);
+      if (token2) {
+        cachedUsageToken = token2;
+        usageTokenCacheTime = now;
+      }
+      return token2;
+    }
+    const credFile = path5.join(getClaudeConfigDir(), ".credentials.json");
+    const token = parseUsageAccessToken(fs6.readFileSync(credFile, "utf8"));
+    if (token) {
+      cachedUsageToken = token;
+      usageTokenCacheTime = now;
+    }
+    return token;
+  } catch {
+    return null;
+  }
+}
+function readStaleUsageCache() {
+  try {
+    return parseCachedUsageData(fs6.readFileSync(CACHE_FILE, "utf8"));
+  } catch {
+    return null;
+  }
+}
+var USAGE_API_HOST = "api.anthropic.com";
+var USAGE_API_PATH = "/api/oauth/usage";
+async function fetchFromUsageApi(token) {
+  return new Promise((resolve3) => {
+    let settled = false;
+    const finish = (value) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      resolve3(value);
+    };
+    const request2 = https.request({
+      hostname: USAGE_API_HOST,
+      path: USAGE_API_PATH,
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "anthropic-beta": "oauth-2025-04-20"
+      },
+      timeout: 5000
+    }, (response) => {
+      let data = "";
+      response.setEncoding("utf8");
+      response.on("data", (chunk) => {
+        data += chunk;
+      });
+      response.on("end", () => {
+        if (response.statusCode === 200 && data) {
+          finish(data);
+          return;
+        }
+        finish(null);
+      });
+    });
+    request2.on("error", () => {
+      finish(null);
+    });
+    request2.on("timeout", () => {
+      request2.destroy();
+      finish(null);
+    });
+    request2.end();
+  });
+}
+async function fetchUsageData() {
+  const now = Math.floor(Date.now() / 1000);
+  if (cachedUsageData) {
+    const cacheAge = now - usageCacheTime;
+    if (!cachedUsageData.error && cacheAge < CACHE_MAX_AGE) {
+      return cachedUsageData;
+    }
+    if (cachedUsageData.error && cacheAge < LOCK_MAX_AGE) {
+      return cachedUsageData;
+    }
+  }
+  try {
+    const stat = fs6.statSync(CACHE_FILE);
+    const fileAge = now - Math.floor(stat.mtimeMs / 1000);
+    if (fileAge < CACHE_MAX_AGE) {
+      const fileData = parseCachedUsageData(fs6.readFileSync(CACHE_FILE, "utf8"));
+      if (fileData && !fileData.error) {
+        cachedUsageData = fileData;
+        usageCacheTime = now;
+        return fileData;
+      }
+    }
+  } catch {}
+  const token = getUsageToken();
+  if (!token) {
+    return getStaleUsageOrError("no-credentials", now);
+  }
+  try {
+    const lockStat = fs6.statSync(LOCK_FILE);
+    const lockAge = now - Math.floor(lockStat.mtimeMs / 1000);
+    if (lockAge < LOCK_MAX_AGE) {
+      const stale = readStaleUsageCache();
+      if (stale && !stale.error)
+        return stale;
+      return { error: "timeout" };
+    }
+  } catch {}
+  try {
+    const lockDir = path5.dirname(LOCK_FILE);
+    if (!fs6.existsSync(lockDir)) {
+      fs6.mkdirSync(lockDir, { recursive: true });
+    }
+    fs6.writeFileSync(LOCK_FILE, "");
+  } catch {}
+  try {
+    const response = await fetchFromUsageApi(token);
+    if (!response) {
+      return getStaleUsageOrError("api-error", now);
+    }
+    const usageData = parseUsageApiResponse(response);
+    if (!usageData) {
+      return getStaleUsageOrError("parse-error", now);
+    }
+    if (usageData.sessionUsage === undefined && usageData.weeklyUsage === undefined) {
+      return getStaleUsageOrError("parse-error", now);
+    }
+    try {
+      if (!fs6.existsSync(CACHE_DIR)) {
+        fs6.mkdirSync(CACHE_DIR, { recursive: true });
+      }
+      fs6.writeFileSync(CACHE_FILE, JSON.stringify(usageData));
+    } catch {}
+    cachedUsageData = usageData;
+    usageCacheTime = now;
+    return usageData;
+  } catch {
+    return getStaleUsageOrError("parse-error", now);
+  }
+}
+// src/utils/jsonl-cache.ts
+import * as fs9 from "fs";
+import { createHash } from "node:crypto";
+import os7 from "node:os";
+import path8 from "node:path";
+
+// src/utils/jsonl-blocks.ts
+import * as fs8 from "fs";
+import path7 from "node:path";
+
+// node_modules/tinyglobby/dist/index.mjs
+import path6, { posix } from "path";
+
+// node_modules/fdir/dist/index.mjs
+import { createRequire as createRequire2 } from "module";
+import { basename as basename2, dirname as dirname4, normalize, relative, resolve as resolve3, sep } from "path";
+import * as nativeFs from "fs";
+var __require2 = /* @__PURE__ */ createRequire2(import.meta.url);
+function cleanPath(path6) {
+  let normalized = normalize(path6);
   if (normalized.length > 1 && normalized[normalized.length - 1] === sep)
     normalized = normalized.substring(0, normalized.length - 1);
   return normalized;
 }
 var SLASHES_REGEX = /[\\/]/g;
-function convertSlashes(path5, separator) {
-  return path5.replace(SLASHES_REGEX, separator);
+function convertSlashes(path6, separator) {
+  return path6.replace(SLASHES_REGEX, separator);
 }
 var WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i;
-function isRootDirectory(path5) {
-  return path5 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path5);
+function isRootDirectory(path6) {
+  return path6 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path6);
 }
-function normalizePath(path5, options) {
+function normalizePath(path6, options) {
   const { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options;
-  const pathNeedsCleaning = process.platform === "win32" && path5.includes("/") || path5.startsWith(".");
+  const pathNeedsCleaning = process.platform === "win32" && path6.includes("/") || path6.startsWith(".");
   if (resolvePaths)
-    path5 = resolve2(path5);
+    path6 = resolve3(path6);
   if (normalizePath$1 || pathNeedsCleaning)
-    path5 = cleanPath(path5);
-  if (path5 === ".")
+    path6 = cleanPath(path6);
+  if (path6 === ".")
     return "";
-  const needsSeperator = path5[path5.length - 1] !== pathSeparator;
-  return convertSlashes(needsSeperator ? path5 + pathSeparator : path5, pathSeparator);
+  const needsSeperator = path6[path6.length - 1] !== pathSeparator;
+  return convertSlashes(needsSeperator ? path6 + pathSeparator : path6, pathSeparator);
 }
 function joinPathWithBasePath(filename, directoryPath) {
   return directoryPath + filename;
@@ -54653,9 +55014,9 @@ var pushDirectory = (directoryPath, paths) => {
   paths.push(directoryPath || ".");
 };
 var pushDirectoryFilter = (directoryPath, paths, filters) => {
-  const path5 = directoryPath || ".";
-  if (filters.every((filter) => filter(path5, true)))
-    paths.push(path5);
+  const path6 = directoryPath || ".";
+  if (filters.every((filter) => filter(path6, true)))
+    paths.push(path6);
 };
 var empty$2 = () => {};
 function build$6(root, options) {
@@ -54712,29 +55073,29 @@ var empty = () => {};
 function build$3(options) {
   return options.group ? groupFiles : empty;
 }
-var resolveSymlinksAsync = function(path5, state, callback$1) {
-  const { queue, fs: fs6, options: { suppressErrors } } = state;
+var resolveSymlinksAsync = function(path6, state, callback$1) {
+  const { queue, fs: fs7, options: { suppressErrors } } = state;
   queue.enqueue();
-  fs6.realpath(path5, (error43, resolvedPath) => {
+  fs7.realpath(path6, (error43, resolvedPath) => {
     if (error43)
       return queue.dequeue(suppressErrors ? null : error43, state);
-    fs6.stat(resolvedPath, (error$1, stat) => {
+    fs7.stat(resolvedPath, (error$1, stat) => {
       if (error$1)
         return queue.dequeue(suppressErrors ? null : error$1, state);
-      if (stat.isDirectory() && isRecursive(path5, resolvedPath, state))
+      if (stat.isDirectory() && isRecursive(path6, resolvedPath, state))
         return queue.dequeue(null, state);
       callback$1(stat, resolvedPath);
       queue.dequeue(null, state);
     });
   });
 };
-var resolveSymlinks = function(path5, state, callback$1) {
-  const { queue, fs: fs6, options: { suppressErrors } } = state;
+var resolveSymlinks = function(path6, state, callback$1) {
+  const { queue, fs: fs7, options: { suppressErrors } } = state;
   queue.enqueue();
   try {
-    const resolvedPath = fs6.realpathSync(path5);
-    const stat = fs6.statSync(resolvedPath);
-    if (stat.isDirectory() && isRecursive(path5, resolvedPath, state))
+    const resolvedPath = fs7.realpathSync(path6);
+    const stat = fs7.statSync(resolvedPath);
+    if (stat.isDirectory() && isRecursive(path6, resolvedPath, state))
       return;
     callback$1(stat, resolvedPath);
   } catch (e) {
@@ -54747,10 +55108,10 @@ function build$2(options, isSynchronous) {
     return null;
   return isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
 }
-function isRecursive(path5, resolved, state) {
+function isRecursive(path6, resolved, state) {
   if (state.options.useRealPaths)
     return isRecursiveUsingRealPaths(resolved, state);
-  let parent = dirname2(path5);
+  let parent = dirname4(path6);
   let depth = 1;
   while (parent !== state.root && depth < 2) {
     const resolvedPath = state.symlinks.get(parent);
@@ -54758,9 +55119,9 @@ function isRecursive(path5, resolved, state) {
     if (isSameRoot)
       depth++;
     else
-      parent = dirname2(parent);
+      parent = dirname4(parent);
   }
-  state.symlinks.set(path5, resolved);
+  state.symlinks.set(path6, resolved);
   return depth > 1;
 }
 function isRecursiveUsingRealPaths(resolved, state) {
@@ -54816,23 +55177,23 @@ var walkAsync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
   state.queue.enqueue();
   if (currentDepth < 0)
     return state.queue.dequeue(null, state);
-  const { fs: fs6 } = state;
+  const { fs: fs7 } = state;
   state.visited.push(crawlPath);
   state.counts.directories++;
-  fs6.readdir(crawlPath || ".", readdirOpts, (error43, entries = []) => {
+  fs7.readdir(crawlPath || ".", readdirOpts, (error43, entries = []) => {
     callback$1(entries, directoryPath, currentDepth);
     state.queue.dequeue(state.options.suppressErrors ? null : error43, state);
   });
 };
 var walkSync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
-  const { fs: fs6 } = state;
+  const { fs: fs7 } = state;
   if (currentDepth < 0)
     return;
   state.visited.push(crawlPath);
   state.counts.directories++;
   let entries = [];
   try {
-    entries = fs6.readdirSync(crawlPath || ".", readdirOpts);
+    entries = fs7.readdirSync(crawlPath || ".", readdirOpts);
   } catch (e) {
     if (!state.options.suppressErrors)
       throw e;
@@ -54938,23 +55299,23 @@ var Walker = class {
         const filename = this.joinPath(entry.name, directoryPath);
         this.pushFile(filename, files, this.state.counts, filters);
       } else if (entry.isDirectory()) {
-        let path5 = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
-        if (exclude && exclude(entry.name, path5))
+        let path6 = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
+        if (exclude && exclude(entry.name, path6))
           continue;
-        this.pushDirectory(path5, paths, filters);
-        this.walkDirectory(this.state, path5, path5, depth - 1, this.walk);
+        this.pushDirectory(path6, paths, filters);
+        this.walkDirectory(this.state, path6, path6, depth - 1, this.walk);
       } else if (this.resolveSymlink && entry.isSymbolicLink()) {
-        let path5 = joinPathWithBasePath(entry.name, directoryPath);
-        this.resolveSymlink(path5, this.state, (stat, resolvedPath) => {
+        let path6 = joinPathWithBasePath(entry.name, directoryPath);
+        this.resolveSymlink(path6, this.state, (stat, resolvedPath) => {
           if (stat.isDirectory()) {
             resolvedPath = normalizePath(resolvedPath, this.state.options);
-            if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path5 + pathSeparator))
+            if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path6 + pathSeparator))
               return;
-            this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path5 + pathSeparator, depth - 1, this.walk);
+            this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path6 + pathSeparator, depth - 1, this.walk);
           } else {
-            resolvedPath = useRealPaths ? resolvedPath : path5;
+            resolvedPath = useRealPaths ? resolvedPath : path6;
             const filename = basename2(resolvedPath);
-            const directoryPath$1 = normalizePath(dirname2(resolvedPath), this.state.options);
+            const directoryPath$1 = normalizePath(dirname4(resolvedPath), this.state.options);
             resolvedPath = this.joinPath(filename, directoryPath$1);
             this.pushFile(resolvedPath, files, this.state.counts, filters);
           }
@@ -55112,7 +55473,7 @@ var Builder = class {
       isMatch = globFn(patterns, ...options);
       this.globCache[patterns.join("\x00")] = isMatch;
     }
-    this.options.filters.push((path5) => isMatch(path5));
+    this.options.filters.push((path6) => isMatch(path6));
     return this;
   }
 };
@@ -55191,7 +55552,7 @@ function normalizePattern(pattern, expandDirectories, cwd2, props, isIgnore) {
   if (!result.endsWith("*") && expandDirectories)
     result += "/**";
   const escapedCwd = escapePath(cwd2);
-  if (path5.isAbsolute(result.replace(ESCAPING_BACKSLASHES, "")))
+  if (path6.isAbsolute(result.replace(ESCAPING_BACKSLASHES, "")))
     result = posix.relative(escapedCwd, result);
   else
     result = posix.normalize(result);
@@ -55228,7 +55589,7 @@ function normalizePattern(pattern, expandDirectories, cwd2, props, isIgnore) {
     }
     props.depthOffset = newCommonPath.length;
     props.commonPath = newCommonPath;
-    props.root = newCommonPath.length > 0 ? path5.posix.join(cwd2, ...newCommonPath) : cwd2;
+    props.root = newCommonPath.length > 0 ? path6.posix.join(cwd2, ...newCommonPath) : cwd2;
   }
   return result;
 }
@@ -55361,184 +55722,37 @@ function globSync(patternsOrOptions, options) {
     ...options,
     patterns: patternsOrOptions
   } : patternsOrOptions;
-  const cwd2 = opts.cwd ? path5.resolve(opts.cwd).replace(BACKSLASHES, "/") : process.cwd().replace(BACKSLASHES, "/");
+  const cwd2 = opts.cwd ? path6.resolve(opts.cwd).replace(BACKSLASHES, "/") : process.cwd().replace(BACKSLASHES, "/");
   return crawl(opts, cwd2, true);
 }
 
-// src/utils/jsonl.ts
+// src/utils/jsonl-lines.ts
+import * as fs7 from "fs";
 import { promisify } from "util";
-var readFile4 = promisify(fs6.readFile);
-var readFileSync4 = fs6.readFileSync;
-var statSync4 = fs6.statSync;
-var writeFileSync2 = fs6.writeFileSync;
-var mkdirSync3 = fs6.mkdirSync;
-var existsSync7 = fs6.existsSync;
-function normalizeConfigDir(configDir) {
-  return path6.resolve(configDir);
-}
-function getBlockCachePath(configDir = getClaudeConfigDir()) {
-  const normalizedConfigDir = normalizeConfigDir(configDir);
-  const configHash = createHash("sha256").update(normalizedConfigDir).digest("hex").slice(0, 16);
-  return path6.join(os6.homedir(), ".cache", "ccstatusline", `block-cache-${configHash}.json`);
-}
-function readBlockCache(expectedConfigDir) {
-  try {
-    const normalizedExpectedConfigDir = expectedConfigDir !== undefined ? normalizeConfigDir(expectedConfigDir) : undefined;
-    const cachePath = getBlockCachePath(normalizedExpectedConfigDir);
-    if (!existsSync7(cachePath)) {
-      return null;
-    }
-    const content = readFileSync4(cachePath, "utf-8");
-    const cache3 = JSON.parse(content);
-    if (typeof cache3.startTime !== "string") {
-      return null;
-    }
-    if (normalizedExpectedConfigDir !== undefined) {
-      if (typeof cache3.configDir !== "string") {
-        return null;
-      }
-      if (cache3.configDir !== normalizedExpectedConfigDir) {
-        return null;
-      }
-    }
-    const date5 = new Date(cache3.startTime);
-    if (Number.isNaN(date5.getTime())) {
-      return null;
-    }
-    return date5;
-  } catch {
-    return null;
-  }
+var readFile4 = promisify(fs7.readFile);
+var readFileSync5 = fs7.readFileSync;
+function splitJsonlContent(content) {
+  return content.trim().split(`
+`).filter((line) => line.length > 0);
 }
-function writeBlockCache(startTime, configDir = getClaudeConfigDir()) {
-  try {
-    const normalizedConfigDir = normalizeConfigDir(configDir);
-    const cachePath = getBlockCachePath(normalizedConfigDir);
-    const cacheDir = path6.dirname(cachePath);
-    if (!existsSync7(cacheDir)) {
-      mkdirSync3(cacheDir, { recursive: true });
-    }
-    const cache3 = {
-      startTime: startTime.toISOString(),
-      configDir: normalizedConfigDir
-    };
-    writeFileSync2(cachePath, JSON.stringify(cache3), "utf-8");
-  } catch {}
+async function readJsonlLines(filePath) {
+  const content = await readFile4(filePath, "utf-8");
+  return splitJsonlContent(content);
 }
-function getCachedBlockMetrics(sessionDurationHours = 5) {
-  const sessionDurationMs = sessionDurationHours * 60 * 60 * 1000;
-  const now = new Date;
-  const activeConfigDir = getClaudeConfigDir();
-  const cachedStartTime = readBlockCache(activeConfigDir);
-  if (cachedStartTime) {
-    const blockEndTime = new Date(cachedStartTime.getTime() + sessionDurationMs);
-    if (now.getTime() <= blockEndTime.getTime()) {
-      return {
-        startTime: cachedStartTime,
-        lastActivity: now
-      };
-    }
-  }
-  const metrics = getBlockMetrics();
-  if (metrics) {
-    writeBlockCache(metrics.startTime, activeConfigDir);
-  }
-  return metrics;
+function readJsonlLinesSync(filePath) {
+  const content = readFileSync5(filePath, "utf-8");
+  return splitJsonlContent(content);
 }
-async function getSessionDuration(transcriptPath) {
+function parseJsonlLine(line) {
   try {
-    if (!fs6.existsSync(transcriptPath)) {
-      return null;
-    }
-    const content = await readFile4(transcriptPath, "utf-8");
-    const lines = content.trim().split(`
-`).filter((line) => line.trim());
-    if (lines.length === 0) {
-      return null;
-    }
-    let firstTimestamp = null;
-    let lastTimestamp = null;
-    for (const line of lines) {
-      try {
-        const data = JSON.parse(line);
-        if (data.timestamp) {
-          firstTimestamp = new Date(data.timestamp);
-          break;
-        }
-      } catch {}
-    }
-    for (let i = lines.length - 1;i >= 0; i--) {
-      try {
-        const data = JSON.parse(lines[i] ?? "");
-        if (data.timestamp) {
-          lastTimestamp = new Date(data.timestamp);
-          break;
-        }
-      } catch {}
-    }
-    if (!firstTimestamp || !lastTimestamp) {
-      return null;
-    }
-    const durationMs = lastTimestamp.getTime() - firstTimestamp.getTime();
-    const totalMinutes = Math.floor(durationMs / (1000 * 60));
-    if (totalMinutes < 1) {
-      return "<1m";
-    }
-    const hours = Math.floor(totalMinutes / 60);
-    const minutes = totalMinutes % 60;
-    if (hours === 0) {
-      return `${minutes}m`;
-    } else if (minutes === 0) {
-      return `${hours}hr`;
-    } else {
-      return `${hours}hr ${minutes}m`;
-    }
+    return JSON.parse(line);
   } catch {
     return null;
   }
 }
-async function getTokenMetrics(transcriptPath) {
-  try {
-    if (!fs6.existsSync(transcriptPath)) {
-      return { inputTokens: 0, outputTokens: 0, cachedTokens: 0, totalTokens: 0, contextLength: 0 };
-    }
-    const content = await readFile4(transcriptPath, "utf-8");
-    const lines = content.trim().split(`
-`);
-    let inputTokens = 0;
-    let outputTokens = 0;
-    let cachedTokens = 0;
-    let contextLength = 0;
-    let mostRecentMainChainEntry = null;
-    let mostRecentTimestamp = null;
-    for (const line of lines) {
-      try {
-        const data = JSON.parse(line);
-        if (data.message?.usage) {
-          inputTokens += data.message.usage.input_tokens || 0;
-          outputTokens += data.message.usage.output_tokens || 0;
-          cachedTokens += data.message.usage.cache_read_input_tokens ?? 0;
-          cachedTokens += data.message.usage.cache_creation_input_tokens ?? 0;
-          if (data.isSidechain !== true && data.timestamp && !data.isApiErrorMessage) {
-            const entryTime = new Date(data.timestamp);
-            if (!mostRecentTimestamp || entryTime > mostRecentTimestamp) {
-              mostRecentTimestamp = entryTime;
-              mostRecentMainChainEntry = data;
-            }
-          }
-        }
-      } catch {}
-    }
-    if (mostRecentMainChainEntry?.message?.usage) {
-      const usage = mostRecentMainChainEntry.message.usage;
-      contextLength = (usage.input_tokens || 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0);
-    }
-    const totalTokens = inputTokens + outputTokens + cachedTokens;
-    return { inputTokens, outputTokens, cachedTokens, totalTokens, contextLength };
-  } catch {
-    return { inputTokens: 0, outputTokens: 0, cachedTokens: 0, totalTokens: 0, contextLength: 0 };
-  }
-}
+
+// src/utils/jsonl-blocks.ts
+var statSync5 = fs8.statSync;
 function getBlockMetrics() {
   const claudeDir = getClaudeConfigDir();
   if (!claudeDir)
@@ -55552,7 +55766,7 @@ function getBlockMetrics() {
 function findMostRecentBlockStartTime(rootDir, sessionDurationHours = 5) {
   const sessionDurationMs = sessionDurationHours * 60 * 60 * 1000;
   const now = new Date;
-  const pattern = path6.posix.join(rootDir.replace(/\\/g, "/"), "projects", "**", "*.jsonl");
+  const pattern = path7.posix.join(rootDir.replace(/\\/g, "/"), "projects", "**", "*.jsonl");
   const files = globSync([pattern], {
     absolute: true,
     cwd: rootDir
@@ -55560,7 +55774,7 @@ function findMostRecentBlockStartTime(rootDir, sessionDurationHours = 5) {
   if (files.length === 0)
     return null;
   const filesWithStats = files.map((file2) => {
-    const stats = statSync4(file2);
+    const stats = statSync5(file2);
     return { file: file2, mtime: stats.mtime };
   });
   filesWithStats.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
@@ -55646,30 +55860,27 @@ function findMostRecentBlockStartTime(rootDir, sessionDurationHours = 5) {
 function getAllTimestampsFromFile(filePath) {
   const timestamps = [];
   try {
-    const content = readFileSync4(filePath, "utf-8");
-    const lines = content.trim().split(`
-`).filter((line) => line.length > 0);
+    const lines = readJsonlLinesSync(filePath);
     for (const line of lines) {
-      try {
-        const json2 = JSON.parse(line);
-        const usage = json2.message?.usage;
-        if (!usage)
-          continue;
-        const hasInputTokens = typeof usage.input_tokens === "number";
-        const hasOutputTokens = typeof usage.output_tokens === "number";
-        if (!hasInputTokens || !hasOutputTokens)
-          continue;
-        if (json2.isSidechain === true)
-          continue;
-        const timestamp = json2.timestamp;
-        if (typeof timestamp !== "string")
-          continue;
-        const date5 = new Date(timestamp);
-        if (!Number.isNaN(date5.getTime()))
-          timestamps.push(date5);
-      } catch {
+      const json2 = parseJsonlLine(line);
+      if (!json2) {
         continue;
       }
+      const usage = json2.message?.usage;
+      if (!usage)
+        continue;
+      const hasInputTokens = typeof usage.input_tokens === "number";
+      const hasOutputTokens = typeof usage.output_tokens === "number";
+      if (!hasInputTokens || !hasOutputTokens)
+        continue;
+      if (json2.isSidechain === true)
+        continue;
+      const timestamp = json2.timestamp;
+      if (typeof timestamp !== "string")
+        continue;
+      const date5 = new Date(timestamp);
+      if (!Number.isNaN(date5.getTime()))
+        timestamps.push(date5);
     }
     return timestamps;
   } catch {
@@ -55682,268 +55893,187 @@ function floorToHour(timestamp) {
   return floored;
 }
 
-// src/utils/usage.ts
-var CACHE_DIR = path7.join(os7.homedir(), ".cache", "ccstatusline");
-var CACHE_FILE = path7.join(CACHE_DIR, "usage.json");
-var LOCK_FILE = path7.join(CACHE_DIR, "usage.lock");
-var CACHE_MAX_AGE = 180;
-var LOCK_MAX_AGE = 30;
-var TOKEN_CACHE_MAX_AGE = 3600;
-var FIVE_HOUR_BLOCK_MS = 5 * 60 * 60 * 1000;
-var UsageErrorSchema = exports_external.enum(["no-credentials", "timeout", "api-error", "parse-error"]);
-var UsageCredentialsSchema = exports_external.object({ claudeAiOauth: exports_external.object({ accessToken: exports_external.string().nullable().optional() }).optional() });
-var CachedUsageDataSchema = exports_external.object({
-  sessionUsage: exports_external.number().nullable().optional(),
-  sessionResetAt: exports_external.string().nullable().optional(),
-  weeklyUsage: exports_external.number().nullable().optional(),
-  extraUsageEnabled: exports_external.boolean().nullable().optional(),
-  extraUsageLimit: exports_external.number().nullable().optional(),
-  extraUsageUsed: exports_external.number().nullable().optional(),
-  extraUsageUtilization: exports_external.number().nullable().optional(),
-  error: exports_external.string().nullable().optional()
-});
-var UsageApiResponseSchema = exports_external.object({
-  five_hour: exports_external.object({
-    utilization: exports_external.number().nullable().optional(),
-    reset_at: exports_external.string().nullable().optional(),
-    resets_at: exports_external.string().nullable().optional()
-  }).optional(),
-  seven_day: exports_external.object({ utilization: exports_external.number().nullable().optional() }).optional(),
-  extra_usage: exports_external.object({
-    is_enabled: exports_external.boolean().nullable().optional(),
-    monthly_limit: exports_external.number().nullable().optional(),
-    used_credits: exports_external.number().nullable().optional(),
-    utilization: exports_external.number().nullable().optional()
-  }).optional()
-});
-function parseJsonWithSchema(rawJson, schema) {
-  try {
-    const parsed = schema.safeParse(JSON.parse(rawJson));
-    return parsed.success ? parsed.data : null;
-  } catch {
-    return null;
-  }
-}
-function parseUsageAccessToken(rawJson) {
-  const parsed = parseJsonWithSchema(rawJson, UsageCredentialsSchema);
-  return parsed?.claudeAiOauth?.accessToken ?? null;
-}
-function parseCachedUsageData(rawJson) {
-  const parsed = parseJsonWithSchema(rawJson, CachedUsageDataSchema);
-  if (!parsed) {
-    return null;
-  }
-  const parsedError = UsageErrorSchema.safeParse(parsed.error);
-  return {
-    sessionUsage: parsed.sessionUsage ?? undefined,
-    sessionResetAt: parsed.sessionResetAt ?? undefined,
-    weeklyUsage: parsed.weeklyUsage ?? undefined,
-    extraUsageEnabled: parsed.extraUsageEnabled ?? undefined,
-    extraUsageLimit: parsed.extraUsageLimit ?? undefined,
-    extraUsageUsed: parsed.extraUsageUsed ?? undefined,
-    extraUsageUtilization: parsed.extraUsageUtilization ?? undefined,
-    error: parsedError.success ? parsedError.data : undefined
-  };
-}
-function parseUsageApiResponse(rawJson) {
-  const parsed = parseJsonWithSchema(rawJson, UsageApiResponseSchema);
-  if (!parsed) {
-    return null;
-  }
-  return {
-    sessionUsage: parsed.five_hour?.utilization ?? undefined,
-    sessionResetAt: parsed.five_hour?.resets_at ?? parsed.five_hour?.reset_at ?? undefined,
-    weeklyUsage: parsed.seven_day?.utilization ?? undefined,
-    extraUsageEnabled: parsed.extra_usage?.is_enabled ?? undefined,
-    extraUsageLimit: parsed.extra_usage?.monthly_limit ?? undefined,
-    extraUsageUsed: parsed.extra_usage?.used_credits ?? undefined,
-    extraUsageUtilization: parsed.extra_usage?.utilization ?? undefined
-  };
-}
-var cachedUsageData = null;
-var usageCacheTime = 0;
-var cachedUsageToken = null;
-var usageTokenCacheTime = 0;
-function setCachedUsageError(error43, now) {
-  const errorData = { error: error43 };
-  cachedUsageData = errorData;
-  usageCacheTime = now;
-  return errorData;
+// src/utils/jsonl-cache.ts
+var readFileSync7 = fs9.readFileSync;
+var writeFileSync3 = fs9.writeFileSync;
+var mkdirSync4 = fs9.mkdirSync;
+var existsSync8 = fs9.existsSync;
+function normalizeConfigDir(configDir) {
+  return path8.resolve(configDir);
 }
-function getStaleUsageOrError(error43, now) {
-  const stale = readStaleUsageCache();
-  if (stale && !stale.error) {
-    cachedUsageData = stale;
-    usageCacheTime = now;
-    return stale;
-  }
-  return setCachedUsageError(error43, now);
+function getBlockCachePath(configDir = getClaudeConfigDir()) {
+  const normalizedConfigDir = normalizeConfigDir(configDir);
+  const configHash = createHash("sha256").update(normalizedConfigDir).digest("hex").slice(0, 16);
+  return path8.join(os7.homedir(), ".cache", "ccstatusline", `block-cache-${configHash}.json`);
 }
-function getUsageToken() {
-  const now = Math.floor(Date.now() / 1000);
-  if (cachedUsageToken && now - usageTokenCacheTime < TOKEN_CACHE_MAX_AGE) {
-    return cachedUsageToken;
-  }
+function readBlockCache(expectedConfigDir) {
   try {
-    const isMac = process.platform === "darwin";
-    if (isMac) {
-      const result = execSync6('security find-generic-password -s "Claude Code-credentials" -w 2>/dev/null', { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-      const token2 = parseUsageAccessToken(result);
-      if (token2) {
-        cachedUsageToken = token2;
-        usageTokenCacheTime = now;
+    const normalizedExpectedConfigDir = expectedConfigDir !== undefined ? normalizeConfigDir(expectedConfigDir) : undefined;
+    const cachePath = getBlockCachePath(normalizedExpectedConfigDir);
+    if (!existsSync8(cachePath)) {
+      return null;
+    }
+    const content = readFileSync7(cachePath, "utf-8");
+    const cache3 = JSON.parse(content);
+    if (typeof cache3.startTime !== "string") {
+      return null;
+    }
+    if (normalizedExpectedConfigDir !== undefined) {
+      if (typeof cache3.configDir !== "string") {
+        return null;
+      }
+      if (cache3.configDir !== normalizedExpectedConfigDir) {
+        return null;
       }
-      return token2;
     }
-    const credFile = path7.join(getClaudeConfigDir(), ".credentials.json");
-    const token = parseUsageAccessToken(fs7.readFileSync(credFile, "utf8"));
-    if (token) {
-      cachedUsageToken = token;
-      usageTokenCacheTime = now;
+    const date5 = new Date(cache3.startTime);
+    if (Number.isNaN(date5.getTime())) {
+      return null;
     }
-    return token;
+    return date5;
   } catch {
     return null;
   }
 }
-function readStaleUsageCache() {
+function writeBlockCache(startTime, configDir = getClaudeConfigDir()) {
   try {
-    return parseCachedUsageData(fs7.readFileSync(CACHE_FILE, "utf8"));
-  } catch {
-    return null;
-  }
+    const normalizedConfigDir = normalizeConfigDir(configDir);
+    const cachePath = getBlockCachePath(normalizedConfigDir);
+    const cacheDir = path8.dirname(cachePath);
+    if (!existsSync8(cacheDir)) {
+      mkdirSync4(cacheDir, { recursive: true });
+    }
+    const cache3 = {
+      startTime: startTime.toISOString(),
+      configDir: normalizedConfigDir
+    };
+    writeFileSync3(cachePath, JSON.stringify(cache3), "utf-8");
+  } catch {}
 }
-function fetchFromUsageApi(token) {
-  const script = `
-        const token = process.env.TOKEN;
-        if (!token) {
-            process.exit(1);
-        }
-
-        const https = require('https');
-        const options = {
-            hostname: 'api.anthropic.com',
-            path: '/api/oauth/usage',
-            method: 'GET',
-            headers: {
-                'Authorization': 'Bearer ' + token,
-                'anthropic-beta': 'oauth-2025-04-20'
-            },
-            timeout: 5000
-        };
-
-        const req = https.request(options, (res) => {
-            let data = '';
-            res.on('data', chunk => data += chunk);
-            res.on('end', () => {
-                if (res.statusCode === 200 && data) {
-                    process.stdout.write(data);
-                } else {
-                    process.exit(1);
-                }
-            });
-        });
-
-        req.on('error', () => process.exit(1));
-        req.on('timeout', () => {
-            req.destroy();
-            process.exit(1);
-        });
-        req.end();
-    `;
-  const runtimePath = process.execPath || "node";
-  const result = spawnSync2(runtimePath, ["-e", script], {
-    encoding: "utf8",
-    timeout: 6000,
-    env: { ...process.env, TOKEN: token }
-  });
-  if (result.error || result.status !== 0 || !result.stdout) {
-    return null;
+function getCachedBlockMetrics(sessionDurationHours = 5) {
+  const sessionDurationMs = sessionDurationHours * 60 * 60 * 1000;
+  const now = new Date;
+  const activeConfigDir = getClaudeConfigDir();
+  const cachedStartTime = readBlockCache(activeConfigDir);
+  if (cachedStartTime) {
+    const blockEndTime = new Date(cachedStartTime.getTime() + sessionDurationMs);
+    if (now.getTime() <= blockEndTime.getTime()) {
+      return {
+        startTime: cachedStartTime,
+        lastActivity: now
+      };
+    }
+  }
+  const metrics = getBlockMetrics();
+  if (metrics) {
+    writeBlockCache(metrics.startTime, activeConfigDir);
   }
-  return result.stdout;
+  return metrics;
 }
-function fetchUsageData() {
-  const now = Math.floor(Date.now() / 1000);
-  if (cachedUsageData) {
-    const cacheAge = now - usageCacheTime;
-    if (!cachedUsageData.error && cacheAge < CACHE_MAX_AGE) {
-      return cachedUsageData;
+// src/utils/jsonl-metrics.ts
+import * as fs10 from "fs";
+async function getSessionDuration(transcriptPath) {
+  try {
+    if (!fs10.existsSync(transcriptPath)) {
+      return null;
     }
-    if (cachedUsageData.error && cacheAge < LOCK_MAX_AGE) {
-      return cachedUsageData;
+    const lines = await readJsonlLines(transcriptPath);
+    if (lines.length === 0) {
+      return null;
     }
-  }
-  try {
-    const stat = fs7.statSync(CACHE_FILE);
-    const fileAge = now - Math.floor(stat.mtimeMs / 1000);
-    if (fileAge < CACHE_MAX_AGE) {
-      const fileData = parseCachedUsageData(fs7.readFileSync(CACHE_FILE, "utf8"));
-      if (fileData && !fileData.error) {
-        cachedUsageData = fileData;
-        usageCacheTime = now;
-        return fileData;
+    let firstTimestamp = null;
+    let lastTimestamp = null;
+    for (const line of lines) {
+      const data = parseJsonlLine(line);
+      if (data?.timestamp) {
+        firstTimestamp = new Date(data.timestamp);
+        break;
       }
     }
-  } catch {}
-  const token = getUsageToken();
-  if (!token) {
-    return getStaleUsageOrError("no-credentials", now);
-  }
-  try {
-    const lockStat = fs7.statSync(LOCK_FILE);
-    const lockAge = now - Math.floor(lockStat.mtimeMs / 1000);
-    if (lockAge < LOCK_MAX_AGE) {
-      const stale = readStaleUsageCache();
-      if (stale && !stale.error)
-        return stale;
-      return { error: "timeout" };
+    for (let i = lines.length - 1;i >= 0; i--) {
+      const line = lines[i];
+      if (!line) {
+        continue;
+      }
+      const data = parseJsonlLine(line);
+      if (data?.timestamp) {
+        lastTimestamp = new Date(data.timestamp);
+        break;
+      }
     }
-  } catch {}
-  try {
-    const lockDir = path7.dirname(LOCK_FILE);
-    if (!fs7.existsSync(lockDir)) {
-      fs7.mkdirSync(lockDir, { recursive: true });
+    if (!firstTimestamp || !lastTimestamp) {
+      return null;
     }
-    fs7.writeFileSync(LOCK_FILE, "");
-  } catch {}
-  try {
-    const response = fetchFromUsageApi(token);
-    if (!response) {
-      return getStaleUsageOrError("api-error", now);
+    const durationMs = lastTimestamp.getTime() - firstTimestamp.getTime();
+    const totalMinutes = Math.floor(durationMs / (1000 * 60));
+    if (totalMinutes < 1) {
+      return "<1m";
     }
-    const usageData = parseUsageApiResponse(response);
-    if (!usageData) {
-      return getStaleUsageOrError("parse-error", now);
+    const hours = Math.floor(totalMinutes / 60);
+    const minutes = totalMinutes % 60;
+    if (hours === 0) {
+      return `${minutes}m`;
+    } else if (minutes === 0) {
+      return `${hours}hr`;
+    } else {
+      return `${hours}hr ${minutes}m`;
     }
-    if (usageData.sessionUsage === undefined && usageData.weeklyUsage === undefined) {
-      return getStaleUsageOrError("parse-error", now);
+  } catch {
+    return null;
+  }
+}
+async function getTokenMetrics(transcriptPath) {
+  try {
+    if (!fs10.existsSync(transcriptPath)) {
+      return { inputTokens: 0, outputTokens: 0, cachedTokens: 0, totalTokens: 0, contextLength: 0 };
     }
-    try {
-      if (!fs7.existsSync(CACHE_DIR)) {
-        fs7.mkdirSync(CACHE_DIR, { recursive: true });
+    const lines = await readJsonlLines(transcriptPath);
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cachedTokens = 0;
+    let contextLength = 0;
+    let mostRecentMainChainEntry = null;
+    let mostRecentTimestamp = null;
+    for (const line of lines) {
+      const data = parseJsonlLine(line);
+      if (data?.message?.usage) {
+        inputTokens += data.message.usage.input_tokens || 0;
+        outputTokens += data.message.usage.output_tokens || 0;
+        cachedTokens += data.message.usage.cache_read_input_tokens ?? 0;
+        cachedTokens += data.message.usage.cache_creation_input_tokens ?? 0;
+        if (data.isSidechain !== true && data.timestamp && !data.isApiErrorMessage) {
+          const entryTime = new Date(data.timestamp);
+          if (!mostRecentTimestamp || entryTime > mostRecentTimestamp) {
+            mostRecentTimestamp = entryTime;
+            mostRecentMainChainEntry = data;
+          }
+        }
       }
-      fs7.writeFileSync(CACHE_FILE, JSON.stringify(usageData));
-    } catch {}
-    cachedUsageData = usageData;
-    usageCacheTime = now;
-    return usageData;
+    }
+    if (mostRecentMainChainEntry?.message?.usage) {
+      const usage = mostRecentMainChainEntry.message.usage;
+      contextLength = (usage.input_tokens || 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0);
+    }
+    const totalTokens = inputTokens + outputTokens + cachedTokens;
+    return { inputTokens, outputTokens, cachedTokens, totalTokens, contextLength };
   } catch {
-    return getStaleUsageOrError("parse-error", now);
+    return { inputTokens: 0, outputTokens: 0, cachedTokens: 0, totalTokens: 0, contextLength: 0 };
   }
 }
+// src/utils/usage-windows.ts
 function clamp(value, min, max) {
   return Math.max(min, Math.min(max, value));
 }
-function buildUsageWindow(resetAtMs, nowMs) {
-  if (!Number.isFinite(resetAtMs) || !Number.isFinite(nowMs)) {
+function buildUsageWindow(resetAtMs, nowMs, durationMs) {
+  if (!Number.isFinite(resetAtMs) || !Number.isFinite(nowMs) || !Number.isFinite(durationMs) || durationMs <= 0) {
     return null;
   }
-  const startAtMs = resetAtMs - FIVE_HOUR_BLOCK_MS;
-  const elapsedMs = clamp(nowMs - startAtMs, 0, FIVE_HOUR_BLOCK_MS);
-  const remainingMs = FIVE_HOUR_BLOCK_MS - elapsedMs;
-  const elapsedPercent = elapsedMs / FIVE_HOUR_BLOCK_MS * 100;
+  const startAtMs = resetAtMs - durationMs;
+  const elapsedMs = clamp(nowMs - startAtMs, 0, durationMs);
+  const remainingMs = durationMs - elapsedMs;
+  const elapsedPercent = elapsedMs / durationMs * 100;
   return {
-    sessionDurationMs: FIVE_HOUR_BLOCK_MS,
+    sessionDurationMs: durationMs,
     elapsedMs,
     remainingMs,
     elapsedPercent,
@@ -55958,14 +56088,14 @@ function getUsageWindowFromResetAt(sessionResetAt, nowMs = Date.now()) {
   if (Number.isNaN(resetAtMs)) {
     return null;
   }
-  return buildUsageWindow(resetAtMs, nowMs);
+  return buildUsageWindow(resetAtMs, nowMs, FIVE_HOUR_BLOCK_MS);
 }
 function getUsageWindowFromBlockMetrics(blockMetrics, nowMs = Date.now()) {
   const startAtMs = blockMetrics.startTime.getTime();
   if (Number.isNaN(startAtMs)) {
     return null;
   }
-  return buildUsageWindow(startAtMs + FIVE_HOUR_BLOCK_MS, nowMs);
+  return buildUsageWindow(startAtMs + FIVE_HOUR_BLOCK_MS, nowMs, FIVE_HOUR_BLOCK_MS);
 }
 function resolveUsageWindowWithFallback(usageData, blockMetrics, nowMs = Date.now()) {
   const usageWindow = getUsageWindowFromResetAt(usageData.sessionResetAt, nowMs);
@@ -55978,6 +56108,19 @@ function resolveUsageWindowWithFallback(usageData, blockMetrics, nowMs = Date.no
   }
   return getUsageWindowFromBlockMetrics(fallbackMetrics, nowMs);
 }
+function getWeeklyUsageWindowFromResetAt(weeklyResetAt, nowMs = Date.now()) {
+  if (!weeklyResetAt) {
+    return null;
+  }
+  const resetAtMs = Date.parse(weeklyResetAt);
+  if (Number.isNaN(resetAtMs)) {
+    return null;
+  }
+  return buildUsageWindow(resetAtMs, nowMs, SEVEN_DAY_WINDOW_MS);
+}
+function resolveWeeklyUsageWindow(usageData, nowMs = Date.now()) {
+  return getWeeklyUsageWindowFromResetAt(usageData.weeklyResetAt, nowMs);
+}
 function formatUsageDuration(durationMs) {
   const clampedMs = Math.max(0, durationMs);
   const elapsedHours = Math.floor(clampedMs / (1000 * 60 * 60));
@@ -56004,7 +56147,6 @@ function makeUsageProgressBar(percent, width = 15) {
   const empty2 = width - filled;
   return "[" + "█".repeat(filled) + "░".repeat(empty2) + "]";
 }
-
 // src/widgets/shared/usage-display.ts
 function getUsageDisplayMode(item) {
   const mode = item.metadata?.display;
@@ -56102,7 +56244,7 @@ class BlockTimerWidget {
       }
       return formatRawOrLabeledValue(item, "Block: ", "3hr 45m");
     }
-    const usageData = fetchUsageData();
+    const usageData = context.usageData ?? {};
     const window2 = resolveUsageWindowWithFallback(usageData, context.blockMetrics);
     if (!window2) {
       if (isUsageProgressMode(displayMode)) {
@@ -56283,27 +56425,27 @@ class CurrentWorkingDirWidget {
   supportsColors(item) {
     return true;
   }
-  abbreviateHomeDir(path8) {
+  abbreviateHomeDir(path9) {
     const homeDir = os8.homedir();
-    if (path8 === homeDir) {
+    if (path9 === homeDir) {
       return "~";
     }
-    if (path8.startsWith(homeDir)) {
-      const boundaryChar = path8[homeDir.length];
+    if (path9.startsWith(homeDir)) {
+      const boundaryChar = path9[homeDir.length];
       if (boundaryChar !== "/" && boundaryChar !== "\\") {
-        return path8;
+        return path9;
       }
-      return "~" + path8.slice(homeDir.length);
+      return "~" + path9.slice(homeDir.length);
     }
-    return path8;
+    return path9;
   }
-  abbreviatePath(path8) {
+  abbreviatePath(path9) {
     const homeDir = os8.homedir();
-    const useBackslash = path8.includes("\\") && !path8.includes("/");
+    const useBackslash = path9.includes("\\") && !path9.includes("/");
     const sep2 = useBackslash ? "\\" : "/";
-    let normalizedPath = path8;
-    if (path8.startsWith(homeDir)) {
-      normalizedPath = "~" + path8.slice(homeDir.length);
+    let normalizedPath = path9;
+    if (path9.startsWith(homeDir)) {
+      normalizedPath = "~" + path9.slice(homeDir.length);
     }
     const parts = normalizedPath.split(/[\\/]+/).filter((part) => part !== "");
     const abbreviated = parts.map((part, index) => {
@@ -56503,7 +56645,7 @@ class FreeMemoryWidget {
   }
 }
 // src/widgets/SessionName.ts
-import * as fs8 from "fs";
+import * as fs11 from "fs";
 
 class SessionNameWidget {
   getDefaultColor() {
@@ -56530,7 +56672,7 @@ class SessionNameWidget {
       return null;
     }
     try {
-      const content = fs8.readFileSync(transcriptPath, "utf-8");
+      const content = fs11.readFileSync(transcriptPath, "utf-8");
       const lines = content.split(`
 `);
       for (let i = lines.length - 1;i >= 0; i--) {
@@ -56596,7 +56738,7 @@ class SessionUsageWidget {
       }
       return formatRawOrLabeledValue(item, "Session: ", `${previewPercent.toFixed(1)}%`);
     }
-    const data = fetchUsageData();
+    const data = context.usageData ?? {};
     if (data.error)
       return getUsageErrorMessage(data.error);
     if (data.sessionUsage === undefined)
@@ -56665,7 +56807,7 @@ class WeeklyUsageWidget {
       }
       return formatRawOrLabeledValue(item, "Weekly: ", `${previewPercent.toFixed(1)}%`);
     }
-    const data = fetchUsageData();
+    const data = context.usageData ?? {};
     if (data.error)
       return getUsageErrorMessage(data.error);
     if (data.weeklyUsage === undefined)
@@ -56692,7 +56834,7 @@ class WeeklyUsageWidget {
     return true;
   }
 }
-// src/widgets/ResetTimer.ts
+// src/widgets/BlockResetTimer.ts
 function makeTimerProgressBar2(percent, width) {
   const clampedPercent = Math.max(0, Math.min(100, percent));
   const filledWidth = Math.floor(clampedPercent / 100 * width);
@@ -56700,15 +56842,15 @@ function makeTimerProgressBar2(percent, width) {
   return "█".repeat(filledWidth) + "░".repeat(emptyWidth);
 }
 
-class ResetTimerWidget {
+class BlockResetTimerWidget {
   getDefaultColor() {
     return "brightBlue";
   }
   getDescription() {
-    return "Shows time remaining until current 5hr block reset";
+    return "Shows time remaining until current 5hr block reset window";
   }
   getDisplayName() {
-    return "Reset Timer";
+    return "Block Reset Timer";
   }
   getCategory() {
     return "Usage";
@@ -56740,7 +56882,7 @@ class ResetTimerWidget {
       }
       return formatRawOrLabeledValue(item, "Reset: ", "4hr 30m");
     }
-    const usageData = fetchUsageData();
+    const usageData = context.usageData ?? {};
     const window2 = resolveUsageWindowWithFallback(usageData, context.blockMetrics);
     if (!window2) {
       if (usageData.error) {
@@ -56771,6 +56913,85 @@ class ResetTimerWidget {
     return true;
   }
 }
+// src/widgets/WeeklyResetTimer.ts
+function makeTimerProgressBar3(percent, width) {
+  const clampedPercent = Math.max(0, Math.min(100, percent));
+  const filledWidth = Math.floor(clampedPercent / 100 * width);
+  const emptyWidth = width - filledWidth;
+  return "█".repeat(filledWidth) + "░".repeat(emptyWidth);
+}
+
+class WeeklyResetTimerWidget {
+  getDefaultColor() {
+    return "brightBlue";
+  }
+  getDescription() {
+    return "Shows time remaining until weekly usage reset";
+  }
+  getDisplayName() {
+    return "Weekly Reset Timer";
+  }
+  getCategory() {
+    return "Usage";
+  }
+  getEditorDisplay(item) {
+    return {
+      displayText: this.getDisplayName(),
+      modifierText: getUsageDisplayModifierText(item)
+    };
+  }
+  handleEditorAction(action, item) {
+    if (action === "toggle-progress") {
+      return cycleUsageDisplayMode(item);
+    }
+    if (action === "toggle-invert") {
+      return toggleUsageInverted(item);
+    }
+    return null;
+  }
+  render(item, context, settings) {
+    const displayMode = getUsageDisplayMode(item);
+    const inverted = isUsageInverted(item);
+    if (context.isPreview) {
+      const previewPercent = inverted ? 90 : 10;
+      if (isUsageProgressMode(displayMode)) {
+        const barWidth = getUsageProgressBarWidth(displayMode);
+        const progressBar = makeTimerProgressBar3(previewPercent, barWidth);
+        return formatRawOrLabeledValue(item, "Weekly Reset ", `[${progressBar}] ${previewPercent.toFixed(1)}%`);
+      }
+      return formatRawOrLabeledValue(item, "Weekly Reset: ", "36hr 30m");
+    }
+    const usageData = context.usageData ?? {};
+    const window2 = resolveWeeklyUsageWindow(usageData);
+    if (!window2) {
+      if (usageData.error) {
+        return getUsageErrorMessage(usageData.error);
+      }
+      return null;
+    }
+    if (isUsageProgressMode(displayMode)) {
+      const barWidth = getUsageProgressBarWidth(displayMode);
+      const percent = inverted ? window2.remainingPercent : window2.elapsedPercent;
+      const progressBar = makeTimerProgressBar3(percent, barWidth);
+      const percentage = percent.toFixed(1);
+      return formatRawOrLabeledValue(item, "Weekly Reset ", `[${progressBar}] ${percentage}%`);
+    }
+    const remainingTime = formatUsageDuration(window2.remainingMs);
+    return formatRawOrLabeledValue(item, "Weekly Reset: ", remainingTime);
+  }
+  getCustomKeybinds() {
+    return [
+      { key: "p", label: "(p)rogress toggle", action: "toggle-progress" },
+      { key: "v", label: "in(v)ert fill", action: "toggle-invert" }
+    ];
+  }
+  supportsRawValue() {
+    return true;
+  }
+  supportsColors(item) {
+    return true;
+  }
+}
 // src/widgets/ContextBar.ts
 function getDisplayMode(item) {
   return item.metadata?.display === "progress" ? "progress" : "progress-short";
@@ -57047,45 +57268,64 @@ var LinkEditor = ({ widget, onComplete, onCancel, action }) => {
     ]
   }, undefined, true, undefined, this);
 };
+// src/utils/widget-manifest.ts
+var WIDGET_MANIFEST = [
+  { type: "model", create: () => new ModelWidget },
+  { type: "output-style", create: () => new OutputStyleWidget },
+  { type: "git-branch", create: () => new GitBranchWidget },
+  { type: "git-changes", create: () => new GitChangesWidget },
+  { type: "git-insertions", create: () => new GitInsertionsWidget },
+  { type: "git-deletions", create: () => new GitDeletionsWidget },
+  { type: "git-root-dir", create: () => new GitRootDirWidget },
+  { type: "git-worktree", create: () => new GitWorktreeWidget },
+  { type: "current-working-dir", create: () => new CurrentWorkingDirWidget },
+  { type: "tokens-input", create: () => new TokensInputWidget },
+  { type: "tokens-output", create: () => new TokensOutputWidget },
+  { type: "tokens-cached", create: () => new TokensCachedWidget },
+  { type: "tokens-total", create: () => new TokensTotalWidget },
+  { type: "context-length", create: () => new ContextLengthWidget },
+  { type: "context-percentage", create: () => new ContextPercentageWidget },
+  { type: "context-percentage-usable", create: () => new ContextPercentageUsableWidget },
+  { type: "session-clock", create: () => new SessionClockWidget },
+  { type: "session-cost", create: () => new SessionCostWidget },
+  { type: "block-timer", create: () => new BlockTimerWidget },
+  { type: "terminal-width", create: () => new TerminalWidthWidget },
+  { type: "version", create: () => new VersionWidget },
+  { type: "custom-text", create: () => new CustomTextWidget },
+  { type: "custom-command", create: () => new CustomCommandWidget },
+  { type: "link", create: () => new LinkWidget },
+  { type: "claude-session-id", create: () => new ClaudeSessionIdWidget },
+  { type: "session-name", create: () => new SessionNameWidget },
+  { type: "free-memory", create: () => new FreeMemoryWidget },
+  { type: "session-usage", create: () => new SessionUsageWidget },
+  { type: "weekly-usage", create: () => new WeeklyUsageWidget },
+  { type: "reset-timer", create: () => new BlockResetTimerWidget },
+  { type: "weekly-reset-timer", create: () => new WeeklyResetTimerWidget },
+  { type: "context-bar", create: () => new ContextBarWidget }
+];
+var LAYOUT_WIDGET_MANIFEST = [
+  {
+    type: "separator",
+    displayName: "Separator",
+    description: "A separator character between status line widgets",
+    category: "Layout"
+  },
+  {
+    type: "flex-separator",
+    displayName: "Flex Separator",
+    description: "Expands to fill available terminal width",
+    category: "Layout"
+  }
+];
+
 // src/utils/widgets.ts
-var widgetRegistry = new Map([
-  ["model", new ModelWidget],
-  ["output-style", new OutputStyleWidget],
-  ["git-branch", new GitBranchWidget],
-  ["git-changes", new GitChangesWidget],
-  ["git-insertions", new GitInsertionsWidget],
-  ["git-deletions", new GitDeletionsWidget],
-  ["git-root-dir", new GitRootDirWidget],
-  ["git-worktree", new GitWorktreeWidget],
-  ["current-working-dir", new CurrentWorkingDirWidget],
-  ["tokens-input", new TokensInputWidget],
-  ["tokens-output", new TokensOutputWidget],
-  ["tokens-cached", new TokensCachedWidget],
-  ["tokens-total", new TokensTotalWidget],
-  ["context-length", new ContextLengthWidget],
-  ["context-percentage", new ContextPercentageWidget],
-  ["context-percentage-usable", new ContextPercentageUsableWidget],
-  ["session-clock", new SessionClockWidget],
-  ["session-cost", new SessionCostWidget],
-  ["block-timer", new BlockTimerWidget],
-  ["terminal-width", new TerminalWidthWidget],
-  ["version", new VersionWidget],
-  ["custom-text", new CustomTextWidget],
-  ["custom-command", new CustomCommandWidget],
-  ["link", new LinkWidget],
-  ["claude-session-id", new ClaudeSessionIdWidget],
-  ["session-name", new SessionNameWidget],
-  ["free-memory", new FreeMemoryWidget],
-  ["session-usage", new SessionUsageWidget],
-  ["weekly-usage", new WeeklyUsageWidget],
-  ["reset-timer", new ResetTimerWidget],
-  ["context-bar", new ContextBarWidget]
-]);
+var widgetRegistry = new Map(WIDGET_MANIFEST.map((entry) => [entry.type, entry.create()]));
+var layoutWidgetTypes = new Set(LAYOUT_WIDGET_MANIFEST.map((entry) => entry.type));
 function getWidget(type) {
   return widgetRegistry.get(type) ?? null;
 }
 function getAllWidgetTypes(settings) {
-  const allTypes = Array.from(widgetRegistry.keys());
+  const allTypes = WIDGET_MANIFEST.map((entry) => entry.type);
   if (!settings.powerline.enabled) {
     if (!settings.defaultSeparator) {
       allTypes.push("separator");
@@ -57094,30 +57334,18 @@ function getAllWidgetTypes(settings) {
   }
   return allTypes;
 }
-var LAYOUT_WIDGETS = {
-  separator: {
-    displayName: "Separator",
-    description: "A separator character between status line widgets",
-    category: "Layout"
-  },
-  "flex-separator": {
-    displayName: "Flex Separator",
-    description: "Expands to fill available terminal width",
-    category: "Layout"
+var layoutCatalogEntries = new Map(LAYOUT_WIDGET_MANIFEST.map((entry) => [
+  entry.type,
+  {
+    type: entry.type,
+    displayName: entry.displayName,
+    description: entry.description,
+    category: entry.category,
+    searchText: `${entry.displayName} ${entry.description} ${entry.type}`.toLowerCase()
   }
-};
+]));
 function getLayoutCatalogEntry(type) {
-  const layout = LAYOUT_WIDGETS[type];
-  if (!layout) {
-    return null;
-  }
-  return {
-    type,
-    displayName: layout.displayName,
-    description: layout.description,
-    category: layout.category,
-    searchText: `${layout.displayName} ${layout.description} ${type}`.toLowerCase()
-  };
+  return layoutCatalogEntries.get(type) ?? null;
 }
 function getWidgetCatalog(settings) {
   return getAllWidgetTypes(settings).map((type) => {
@@ -61200,7 +61428,7 @@ var App2 = () => {
   });
   const handleInstallSelection = import_react46.useCallback((command, displayName, useBunx) => {
     getExistingStatusLine().then((existing) => {
-      const isAlreadyInstalled = [CCSTATUSLINE_COMMANDS.NPM, CCSTATUSLINE_COMMANDS.BUNX, CCSTATUSLINE_COMMANDS.SELF_MANAGED].includes(existing ?? "");
+      const isAlreadyInstalled = isKnownCommand(existing ?? "");
       let message;
       if (existing && !isAlreadyInstalled) {
         message = `This will modify ${getClaudeSettingsPath()}
@@ -61347,6 +61575,10 @@ ${GITHUB_REPO_URL}`,
           }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this),
+      isCustomConfigPath() && /* @__PURE__ */ jsx_dev_runtime18.jsxDEV(Text, {
+        dimColor: true,
+        children: `Config: ${getConfigPath()}`
+      }, undefined, false, undefined, this),
       /* @__PURE__ */ jsx_dev_runtime18.jsxDEV(StatusLinePreview, {
         lines: settings.lines,
         terminalWidth,
@@ -61578,6 +61810,24 @@ var StatusJSONSchema = exports_external.looseObject({
   }).nullable().optional()
 });
 
+// src/utils/usage-prefetch.ts
+var USAGE_WIDGET_TYPES = new Set([
+  "session-usage",
+  "weekly-usage",
+  "block-timer",
+  "reset-timer",
+  "weekly-reset-timer"
+]);
+function hasUsageDependentWidgets(lines) {
+  return lines.some((line) => line.some((item) => USAGE_WIDGET_TYPES.has(item.type)));
+}
+async function prefetchUsageDataIfNeeded(lines) {
+  if (!hasUsageDependentWidgets(lines)) {
+    return null;
+  }
+  return await fetchUsageData();
+}
+
 // src/ccstatusline.ts
 function hasSessionDurationInStatusJson(data) {
   const durationMs = data.cost?.total_duration_ms;
@@ -61628,9 +61878,11 @@ async function renderMultipleLines(data) {
   if (hasSessionClock && !hasSessionDurationInStatusJson(data) && data.transcript_path) {
     sessionDuration = await getSessionDuration(data.transcript_path);
   }
+  const usageData = await prefetchUsageDataIfNeeded(lines);
   const context = {
     data,
     tokenMetrics,
+    usageData,
     sessionDuration,
     isPreview: false
   };
@@ -61669,7 +61921,20 @@ async function renderMultipleLines(data) {
     }
   }
 }
+function parseConfigArg() {
+  const idx = process.argv.indexOf("--config");
+  if (idx === -1)
+    return;
+  const configPath = process.argv[idx + 1];
+  if (!configPath || configPath.startsWith("--")) {
+    console.error("--config requires a file path argument");
+    process.exit(1);
+  }
+  process.argv.splice(idx, 2);
+  return configPath;
+}
 async function main() {
+  initConfigPath(parseConfigArg());
   if (!process.stdin.isTTY) {
     await ensureWindowsUtf8CodePage();
     const input = await readStdin();