ccstatusline-usage 2.4.3 → 2.4.5

package/dist/ccstatusline.js

@@ -52319,6 +52319,7 @@ var init_Settings = __esm(() => {
     overrideBackgroundColor: exports_external.string().optional(),
     overrideForegroundColor: exports_external.string().optional(),
     globalBold: exports_external.boolean().default(false),
+    gitCacheTtlSeconds: exports_external.number().min(0).max(60).default(5),
     minimalistMode: exports_external.boolean().default(false),
     powerline: PowerlineConfigSchema.default({
       enabled: false,
@@ -52795,6 +52796,175 @@ class OutputStyleWidget {
 
 // src/utils/git.ts
 import { execFileSync } from "child_process";
+import { createHash } from "node:crypto";
+import * as fs2 from "node:fs";
+import * as os3 from "node:os";
+import * as path from "node:path";
+function getCacheDir() {
+  return path.join(os3.homedir(), ".cache", "ccstatusline");
+}
+function getCachePath(gitDir) {
+  const repoHash = createHash("sha256").update(gitDir).digest("hex").slice(0, 16);
+  return path.join(getCacheDir(), "git-cache", `git-${repoHash}.json`);
+}
+function getMtimeMs(filePath) {
+  try {
+    return fs2.statSync(filePath).mtimeMs;
+  } catch {
+    return null;
+  }
+}
+function normalizeDirectory(candidate) {
+  try {
+    const resolved = path.resolve(candidate);
+    const stats = fs2.statSync(resolved);
+    return stats.isDirectory() ? resolved : path.dirname(resolved);
+  } catch {
+    return null;
+  }
+}
+function readGitDirFile(gitFilePath) {
+  try {
+    const content = fs2.readFileSync(gitFilePath, "utf-8").trim();
+    const match = /^gitdir:\s*(.+)$/i.exec(content);
+    if (!match?.[1]) {
+      return null;
+    }
+    return path.resolve(path.dirname(gitFilePath), match[1]);
+  } catch {
+    return null;
+  }
+}
+function discoverGitDir(startDir) {
+  let current = startDir;
+  for (;; ) {
+    const gitPath = path.join(current, ".git");
+    try {
+      const stats = fs2.statSync(gitPath);
+      if (stats.isDirectory()) {
+        return gitPath;
+      }
+      if (stats.isFile()) {
+        return readGitDirFile(gitPath);
+      }
+    } catch {}
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function getGitRepoMetadata(cwd2) {
+  if (!cwd2) {
+    return null;
+  }
+  const startDir = normalizeDirectory(cwd2);
+  if (!startDir) {
+    return null;
+  }
+  const gitDir = discoverGitDir(startDir);
+  if (!gitDir) {
+    return null;
+  }
+  return {
+    cachePath: getCachePath(gitDir),
+    headMtimeMs: getMtimeMs(path.join(gitDir, "HEAD")),
+    indexMtimeMs: getMtimeMs(path.join(gitDir, "index"))
+  };
+}
+function getGitCacheTtlMs(context) {
+  const ttlSeconds = context.gitCacheTtlSeconds;
+  if (typeof ttlSeconds !== "number" || !Number.isFinite(ttlSeconds)) {
+    return DEFAULT_GIT_CACHE_TTL_SECONDS * 1000;
+  }
+  return Math.min(60, Math.max(0, ttlSeconds)) * 1000;
+}
+function isCacheEntry(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const entry = value;
+  return (typeof entry.output === "string" || entry.output === null) && typeof entry.createdAt === "number" && (typeof entry.headMtimeMs === "number" || entry.headMtimeMs === null) && (typeof entry.indexMtimeMs === "number" || entry.indexMtimeMs === null);
+}
+function isCacheEntryFresh(entry, metadata, ttlMs, now2) {
+  if (metadata) {
+    if (entry.headMtimeMs !== metadata.headMtimeMs || entry.indexMtimeMs !== metadata.indexMtimeMs) {
+      return false;
+    }
+  }
+  return ttlMs === 0 || now2 - entry.createdAt <= ttlMs;
+}
+function readPersistentCache(cachePath) {
+  try {
+    const parsed = JSON.parse(fs2.readFileSync(cachePath, "utf-8"));
+    if (typeof parsed !== "object" || parsed === null) {
+      return null;
+    }
+    const data = parsed;
+    if (data.version !== GIT_CACHE_SCHEMA_VERSION || typeof data.cwd !== "string" && data.cwd !== null || typeof data.entries !== "object" || data.entries === null) {
+      return null;
+    }
+    const entries = {};
+    for (const [key, value] of Object.entries(data.entries)) {
+      if (isCacheEntry(value)) {
+        entries[key] = value;
+      }
+    }
+    return {
+      version: GIT_CACHE_SCHEMA_VERSION,
+      cwd: data.cwd,
+      entries
+    };
+  } catch {
+    return null;
+  }
+}
+function writePersistentCache(cachePath, cache3) {
+  try {
+    const cacheDir = path.dirname(cachePath);
+    fs2.mkdirSync(cacheDir, { recursive: true });
+    const tempPath = `${cachePath}.${process.pid}.${Date.now()}.tmp`;
+    fs2.writeFileSync(tempPath, JSON.stringify(cache3), "utf-8");
+    fs2.renameSync(tempPath, cachePath);
+  } catch {}
+}
+function readPersistentCacheEntry(metadata, cacheKey, cwd2, ttlMs, now2) {
+  if (!metadata) {
+    return null;
+  }
+  const cache3 = readPersistentCache(metadata.cachePath);
+  if (cache3?.cwd !== (cwd2 ?? null)) {
+    return null;
+  }
+  const entry = cache3.entries[cacheKey];
+  if (!entry || !isCacheEntryFresh(entry, metadata, ttlMs, now2)) {
+    return null;
+  }
+  return entry;
+}
+function writePersistentCacheEntry(metadata, cacheKey, cwd2, entry) {
+  if (!metadata) {
+    return;
+  }
+  const cacheCwd = cwd2 ?? null;
+  const existingCache = readPersistentCache(metadata.cachePath);
+  const cache3 = existingCache?.cwd === cacheCwd ? existingCache : {
+    version: GIT_CACHE_SCHEMA_VERSION,
+    cwd: cacheCwd,
+    entries: {}
+  };
+  cache3.entries[cacheKey] = entry;
+  writePersistentCache(metadata.cachePath, cache3);
+}
+function createCacheEntry(output, metadata, now2) {
+  return {
+    output,
+    createdAt: now2,
+    headMtimeMs: metadata?.headMtimeMs ?? null,
+    indexMtimeMs: metadata?.indexMtimeMs ?? null
+  };
+}
 function resolveGitCwd(context) {
   const candidates = [
     context.data?.cwd,
@@ -52815,21 +52985,37 @@ function runGit(command, context) {
 function runGitArgs(args, context, cacheCommand) {
   const cwd2 = resolveGitCwd(context);
   const cacheToken = cacheCommand ?? args.join("\x00");
-  const cacheKey = `${cacheToken}|${cwd2 ?? ""}`;
-  if (gitCommandCache.has(cacheKey)) {
-    return gitCommandCache.get(cacheKey) ?? null;
+  const memoryCacheKey = `${cacheToken}|${cwd2 ?? ""}`;
+  const persistentCacheKey = cacheToken;
+  const metadata = getGitRepoMetadata(cwd2);
+  const ttlMs = getGitCacheTtlMs(context);
+  const now2 = Date.now();
+  const memoryEntry = gitCommandCache.get(memoryCacheKey);
+  if (memoryEntry && isCacheEntryFresh(memoryEntry, metadata, ttlMs, now2)) {
+    return memoryEntry.output;
+  }
+  const persistentEntry = readPersistentCacheEntry(metadata, persistentCacheKey, cwd2, ttlMs, now2);
+  if (persistentEntry) {
+    gitCommandCache.set(memoryCacheKey, persistentEntry);
+    return persistentEntry.output;
   }
   try {
     const output = execFileSync("git", args, {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "ignore"],
+      env: { ...process.env, GIT_OPTIONAL_LOCKS: "0" },
+      windowsHide: true,
       ...cwd2 ? { cwd: cwd2 } : {}
     }).trimEnd();
     const result2 = output.length > 0 ? output : null;
-    gitCommandCache.set(cacheKey, result2);
+    const entry = createCacheEntry(result2, metadata, now2);
+    gitCommandCache.set(memoryCacheKey, entry);
+    writePersistentCacheEntry(metadata, persistentCacheKey, cwd2, entry);
     return result2;
   } catch {
-    gitCommandCache.set(cacheKey, null);
+    const entry = createCacheEntry(null, metadata, now2);
+    gitCommandCache.set(memoryCacheKey, entry);
+    writePersistentCacheEntry(metadata, persistentCacheKey, cwd2, entry);
     return null;
   }
 }
@@ -52858,7 +53044,7 @@ function hasRenameOrCopyStatus(line) {
   return line.startsWith("R") || line.startsWith("C") || line[1] === "R" || line[1] === "C";
 }
 function getGitStatus(context) {
-  const output = runGit("--no-optional-locks status --porcelain -z", context);
+  const output = runGit("status --porcelain -z", context);
   if (!output) {
     return { staged: false, unstaged: false, untracked: false, conflicts: false };
   }
@@ -52888,7 +53074,7 @@ function getGitStatus(context) {
   return { staged, unstaged, untracked, conflicts };
 }
 function getGitFileStatusCounts(context) {
-  const output = runGit("--no-optional-locks status --porcelain -z", context);
+  const output = runGit("status --porcelain -z", context);
   if (!output) {
     return { staged: 0, unstaged: 0, untracked: 0 };
   }
@@ -52935,13 +53121,13 @@ function getGitConflictCount(context) {
 `).map((line) => {
     const parts = line.split(/\s+/).slice(3);
     return parts.join(" ");
-  }).filter((path) => path.length > 0));
+  }).filter((path2) => path2.length > 0));
   return files.size;
 }
 function getGitShortSha(context) {
   return runGit("rev-parse --short HEAD", context);
 }
-var gitCommandCache;
+var DEFAULT_GIT_CACHE_TTL_SECONDS = 5, GIT_CACHE_SCHEMA_VERSION = 1, gitCommandCache;
 var init_git = __esm(() => {
   gitCommandCache = new Map;
 });
@@ -53059,8 +53245,8 @@ function renderOsc8Link(url2, text) {
 function encodeGitRefForUrlPath(ref) {
   return ref.split("/").map((segment) => encodeURIComponent(segment)).join("/");
 }
-function encodeFilePathForUri(path) {
-  return path.replace(/\\/g, "/").split("/").map((segment) => encodeURIComponent(segment)).join("/");
+function encodeFilePathForUri(path2) {
+  return path2.replace(/\\/g, "/").split("/").map((segment) => encodeURIComponent(segment)).join("/");
 }
 function buildIdeFileUrl(filePath, ideLinkMode) {
   const normalizedPath = filePath.replace(/\\/g, "/");
@@ -53209,7 +53395,7 @@ class GitBranchWidget {
     return displayText;
   }
   getGitBranch(context) {
-    return runGit("branch --show-current", context);
+    return runGit("symbolic-ref --short HEAD", context);
   }
   getCustomKeybinds() {
     return [
@@ -53715,19 +53901,19 @@ var init_GitRootDir = __esm(() => {
 import { execFileSync as execFileSync2 } from "child_process";
 import {
   existsSync as existsSync2,
-  mkdirSync,
-  readFileSync as readFileSync2,
-  statSync,
-  writeFileSync
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync3,
+  statSync as statSync2,
+  writeFileSync as writeFileSync2
 } from "fs";
-import { createHash } from "node:crypto";
-import os3 from "node:os";
-import path from "node:path";
-function getCacheDir(deps) {
-  return path.join(deps.getHomedir(), ".cache", "ccstatusline");
+import { createHash as createHash2 } from "node:crypto";
+import os4 from "node:os";
+import path2 from "node:path";
+function getCacheDir2(deps) {
+  return path2.join(deps.getHomedir(), ".cache", "ccstatusline");
 }
 function getGitReviewCacheDir(deps) {
-  return path.join(getCacheDir(deps), "git-review");
+  return path2.join(getCacheDir2(deps), "git-review");
 }
 function runGitForCache(args, cwd2, deps) {
   try {
@@ -53735,14 +53921,15 @@ function runGitForCache(args, cwd2, deps) {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "ignore"],
       cwd: cwd2,
-      timeout: CLI_TIMEOUT
+      timeout: CLI_TIMEOUT,
+      windowsHide: true
     }).trim();
   } catch {
     return "";
   }
 }
 function getCurrentBranch(cwd2, deps) {
-  const branch = runGitForCache(["branch", "--show-current"], cwd2, deps);
+  const branch = runGitForCache(["symbolic-ref", "--short", "HEAD"], cwd2, deps);
   return branch.length > 0 ? branch : null;
 }
 function getCacheRef(cwd2, deps) {
@@ -53756,9 +53943,9 @@ function getCacheRef(cwd2, deps) {
   }
   return "unknown";
 }
-function getCachePath(cwd2, ref, deps) {
-  const hash2 = createHash("sha256").update(cwd2).update("\x00").update(ref).digest("hex").slice(0, 16);
-  return path.join(getGitReviewCacheDir(deps), `git-review-${hash2}.json`);
+function getCachePath2(cwd2, ref, deps) {
+  const hash2 = createHash2("sha256").update(cwd2).update("\x00").update(ref).digest("hex").slice(0, 16);
+  return path2.join(getGitReviewCacheDir(deps), `git-review-${hash2}.json`);
 }
 function readCache(cachePath, deps) {
   try {
@@ -53838,7 +54025,8 @@ function isCliAvailable(cli, deps) {
   try {
     deps.execFileSync(cli, ["--version"], {
       stdio: ["pipe", "pipe", "ignore"],
-      timeout: CLI_TIMEOUT
+      timeout: CLI_TIMEOUT,
+      windowsHide: true
     });
     return true;
   } catch {
@@ -53849,7 +54037,8 @@ function isCliAuthedForHost(cli, host, deps) {
   try {
     deps.execFileSync(cli, ["auth", "status", "--hostname", host], {
       stdio: ["pipe", "pipe", "ignore"],
-      timeout: CLI_TIMEOUT
+      timeout: CLI_TIMEOUT,
+      windowsHide: true
     });
     return true;
   } catch {
@@ -53881,7 +54070,8 @@ function fetchFromGh(cwd2, repoRef, deps) {
     encoding: "utf8",
     stdio: ["pipe", "pipe", "ignore"],
     cwd: cwd2,
-    timeout: CLI_TIMEOUT
+    timeout: CLI_TIMEOUT,
+    windowsHide: true
   }).trim();
   if (output.length === 0) {
     return null;
@@ -53913,7 +54103,8 @@ function fetchFromGlab(cwd2, repoRef, deps) {
     encoding: "utf8",
     stdio: ["pipe", "pipe", "ignore"],
     cwd: cwd2,
-    timeout: CLI_TIMEOUT
+    timeout: CLI_TIMEOUT,
+    windowsHide: true
   }).trim();
   if (output.length === 0) {
     return null;
@@ -53945,7 +54136,7 @@ function fetchFromProvider(provider, cwd2, repoRef, deps) {
   return null;
 }
 function fetchGitReviewData(cwd2, deps = DEFAULT_GIT_REVIEW_CACHE_DEPS) {
-  const cachePath = getCachePath(cwd2, getCacheRef(cwd2, deps), deps);
+  const cachePath = getCachePath2(cwd2, getCacheRef(cwd2, deps), deps);
   const cached2 = readCache(cachePath, deps);
   if (cached2 !== "miss") {
     return cached2;
@@ -53991,11 +54182,11 @@ var init_git_review_cache = __esm(() => {
   DEFAULT_GIT_REVIEW_CACHE_DEPS = {
     execFileSync: execFileSync2,
     existsSync: existsSync2,
-    mkdirSync,
-    readFileSync: readFileSync2,
-    statSync,
-    writeFileSync,
-    getHomedir: os3.homedir,
+    mkdirSync: mkdirSync2,
+    readFileSync: readFileSync3,
+    statSync: statSync2,
+    writeFileSync: writeFileSync2,
+    getHomedir: os4.homedir,
     now: Date.now
   };
 });
@@ -55151,6 +55342,11 @@ function getContextWindowMetrics(data) {
     currentUsageTotalTokens = inputTokens + outputTokens + cacheCreationTokens + cacheReadTokens;
     contextLengthTokens = inputTokens + cacheCreationTokens + cacheReadTokens;
     cachedTokens = cacheCreationTokens + cacheReadTokens;
+    if (currentUsageTotalTokens === 0) {
+      currentUsageTotalTokens = null;
+      contextLengthTokens = null;
+      cachedTokens = null;
+    }
   }
   const rawUsedPercentage = toFiniteNonNegativeNumber(contextWindow.used_percentage);
   const rawRemainingPercentage = toFiniteNonNegativeNumber(contextWindow.remaining_percentage);
@@ -56048,20 +56244,20 @@ var init_context_percentage = __esm(() => {
 
 // src/utils/terminal.ts
 import { execSync } from "child_process";
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs3 from "fs";
+import * as path3 from "path";
 function getPackageVersion() {
   if (/^\d+\.\d+\.\d+/.test(PACKAGE_VERSION)) {
     return PACKAGE_VERSION;
   }
   const possiblePaths = [
-    path2.join(__dirname, "..", "..", "package.json"),
-    path2.join(__dirname, "..", "package.json")
+    path3.join(__dirname, "..", "..", "package.json"),
+    path3.join(__dirname, "..", "package.json")
   ];
   for (const packageJsonPath of possiblePaths) {
     try {
-      if (fs2.existsSync(packageJsonPath)) {
-        const packageJson = JSON.parse(fs2.readFileSync(packageJsonPath, "utf-8"));
+      if (fs3.existsSync(packageJsonPath)) {
+        const packageJson = JSON.parse(fs3.readFileSync(packageJsonPath, "utf-8"));
         return packageJson.version ?? "";
       }
     } catch {}
@@ -56077,6 +56273,13 @@ function probeTerminalWidth() {
         return parsed;
     } catch {}
   }
+  const overrideRaw = process.env.CCSTATUSLINE_WIDTH;
+  if (overrideRaw) {
+    const override = parsePositiveInteger(overrideRaw);
+    if (override !== null) {
+      return override;
+    }
+  }
   if (process.platform === "win32") {
     return null;
   }
@@ -56099,7 +56302,8 @@ function probeTerminalWidth() {
   try {
     const width = execSync("tput cols 2>/dev/null", {
       encoding: "utf8",
-      stdio: ["pipe", "pipe", "ignore"]
+      stdio: ["pipe", "pipe", "ignore"],
+      windowsHide: true
     }).trim();
     return parsePositiveInteger(width);
   } catch {}
@@ -56117,7 +56321,8 @@ function getParentProcessId(pid) {
     const parentPidOutput = execSync(`ps -o ppid= -p ${pid}`, {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "ignore"],
-      shell: "/bin/sh"
+      shell: "/bin/sh",
+      windowsHide: true
     }).trim();
     return parsePositiveInteger(parentPidOutput);
   } catch {
@@ -56129,7 +56334,8 @@ function getTTYForProcess(pid) {
     const tty2 = execSync(`ps -o tty= -p ${pid}`, {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "ignore"],
-      shell: "/bin/sh"
+      shell: "/bin/sh",
+      windowsHide: true
     }).replace(/\s+/g, "");
     if (!tty2 || tty2 === "??" || tty2 === "?") {
       return null;
@@ -56140,16 +56346,27 @@ function getTTYForProcess(pid) {
   }
 }
 function getWidthForTTY(tty2) {
-  try {
-    const width = execSync(`stty size < /dev/${tty2} | awk '{print $2}'`, {
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "ignore"],
-      shell: "/bin/sh"
-    }).trim();
-    return parsePositiveInteger(width);
-  } catch {
-    return null;
+  const devicePath = `/dev/${tty2}`;
+  const attempts = [
+    `stty -F ${devicePath} size`,
+    `stty -f ${devicePath} size`,
+    `stty size < ${devicePath}`
+  ];
+  for (const cmd of attempts) {
+    try {
+      const width = execSync(`${cmd} 2>/dev/null | awk '{print $2}'`, {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "ignore"],
+        shell: "/bin/sh",
+        windowsHide: true
+      }).trim();
+      const parsed = parsePositiveInteger(width);
+      if (parsed !== null) {
+        return parsed;
+      }
+    } catch {}
   }
+  return null;
 }
 function getTerminalWidth() {
   return probeTerminalWidth();
@@ -56157,7 +56374,7 @@ function getTerminalWidth() {
 function canDetectTerminalWidth() {
   return probeTerminalWidth() !== null;
 }
-var __dirname = "/Users/peter/Documents/Code/ccstatusline-usage/src/utils", PACKAGE_VERSION = "2.4.3";
+var __dirname = "/Users/peter/Documents/Code/ccstatusline-usage/src/utils", PACKAGE_VERSION = "2.4.5";
 var init_terminal = () => {};
 
 // node_modules/ms/index.js
@@ -56617,7 +56834,7 @@ var require_has_flag = __commonJS((exports, module) => {
 
 // node_modules/supports-color/index.js
 var require_supports_color = __commonJS((exports, module) => {
-  var os4 = __require("os");
+  var os5 = __require("os");
   var tty2 = __require("tty");
   var hasFlag2 = require_has_flag();
   var { env: env3 } = process;
@@ -56674,7 +56891,7 @@ var require_supports_color = __commonJS((exports, module) => {
       return min2;
     }
     if (process.platform === "win32") {
-      const osRelease = os4.release().split(".");
+      const osRelease = os5.release().split(".");
       if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
         return Number(osRelease[2]) >= 14931 ? 3 : 2;
       }
@@ -57022,7 +57239,7 @@ var init_dist4 = __esm(() => {
 
 // node_modules/https-proxy-agent/dist/parse-proxy-response.js
 function parseProxyResponse(socket) {
-  return new Promise((resolve, reject2) => {
+  return new Promise((resolve2, reject2) => {
     let buffersLength = 0;
     const buffers = [];
     function read() {
@@ -57091,7 +57308,7 @@ function parseProxyResponse(socket) {
       }
       debug("got proxy server response: %o %o", firstLine, headers);
       cleanup();
-      resolve({
+      resolve2({
         connect: {
           statusCode,
           statusText,
@@ -57231,10 +57448,13 @@ var init_usage_types = __esm(() => {
 
 // src/utils/usage-fetch.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import * as fs3 from "fs";
+import * as fs4 from "fs";
 import * as https from "https";
-import * as os4 from "os";
-import * as path3 from "path";
+import * as os5 from "os";
+import * as path4 from "path";
+function getUsageApiBucketUtilization(bucket) {
+  return bucket === null ? 0 : bucket?.utilization ?? undefined;
+}
 function parseJsonWithSchema(rawJson, schema) {
   try {
     const parsed = schema.safeParse(JSON.parse(rawJson));
@@ -57275,13 +57495,13 @@ function parseUsageApiResponse(rawJson) {
     return null;
   }
   return {
-    sessionUsage: parsed.five_hour?.utilization ?? undefined,
+    sessionUsage: getUsageApiBucketUtilization(parsed.five_hour),
     sessionResetAt: parsed.five_hour?.resets_at ?? undefined,
-    weeklyUsage: parsed.seven_day?.utilization ?? undefined,
+    weeklyUsage: getUsageApiBucketUtilization(parsed.seven_day),
     weeklyResetAt: parsed.seven_day?.resets_at ?? undefined,
-    weeklySonnetUsage: parsed.seven_day_sonnet === null ? 0 : parsed.seven_day_sonnet?.utilization ?? undefined,
+    weeklySonnetUsage: getUsageApiBucketUtilization(parsed.seven_day_sonnet),
     weeklySonnetResetAt: parsed.seven_day_sonnet?.resets_at ?? undefined,
-    weeklyOpusUsage: parsed.seven_day_opus === null ? 0 : parsed.seven_day_opus?.utilization ?? undefined,
+    weeklyOpusUsage: getUsageApiBucketUtilization(parsed.seven_day_opus),
     weeklyOpusResetAt: parsed.seven_day_opus?.resets_at ?? undefined,
     extraUsageEnabled: parsed.extra_usage?.is_enabled ?? undefined,
     extraUsageLimit: parsed.extra_usage?.monthly_limit ?? undefined,
@@ -57290,8 +57510,8 @@ function parseUsageApiResponse(rawJson) {
   };
 }
 function ensureCacheDirExists() {
-  if (!fs3.existsSync(CACHE_DIR)) {
-    fs3.mkdirSync(CACHE_DIR, { recursive: true });
+  if (!fs4.existsSync(CACHE_DIR)) {
+    fs4.mkdirSync(CACHE_DIR, { recursive: true });
   }
 }
 function setCachedUsageError(error48, now2, maxAge = LOCK_MAX_AGE) {
@@ -57307,8 +57527,14 @@ function cacheUsageData(data, now2) {
   usageErrorCacheMaxAge = LOCK_MAX_AGE;
   return data;
 }
+function hasRequiredUsageField(data, field) {
+  if (data[field] !== undefined) {
+    return true;
+  }
+  return data.extraUsageEnabled === false && EXTRA_USAGE_DETAIL_FIELDS.has(field);
+}
 function hasRequiredUsageFields(data, requiredFields = []) {
-  return requiredFields.every((field) => data[field] !== undefined);
+  return requiredFields.every((field) => hasRequiredUsageField(data, field));
 }
 function getStaleUsageOrError(error48, now2, errorCacheMaxAge = LOCK_MAX_AGE, requiredFields = []) {
   const stale = readStaleUsageCache();
@@ -57387,7 +57613,7 @@ function parseMacKeychainCredentialCandidates(rawDump, servicePrefix = MACOS_USA
 }
 function readMacKeychainSecret(service) {
   try {
-    return execFileSync3("security", ["find-generic-password", "-s", service, "-w"], { encoding: "utf8", stdio: ["pipe", "pipe", "ignore"] }).trim();
+    return execFileSync3("security", ["find-generic-password", "-s", service, "-w"], { encoding: "utf8", stdio: ["pipe", "pipe", "ignore"], windowsHide: true }).trim();
   } catch {
     return null;
   }
@@ -57401,7 +57627,8 @@ function listMacKeychainCredentialCandidates() {
     const rawDump = execFileSync3("security", ["dump-keychain"], {
       encoding: "utf8",
       maxBuffer: MACOS_SECURITY_DUMP_MAX_BUFFER,
-      stdio: ["pipe", "pipe", "ignore"]
+      stdio: ["pipe", "pipe", "ignore"],
+      windowsHide: true
     });
     return parseMacKeychainCredentialCandidates(rawDump);
   } catch {
@@ -57420,8 +57647,8 @@ function readUsageTokenFromMacKeychainCandidates() {
 }
 function readUsageTokenFromCredentialsFile() {
   try {
-    const credFile = path3.join(getClaudeConfigDir(), ".credentials.json");
-    return parseUsageAccessToken(fs3.readFileSync(credFile, "utf8"));
+    const credFile = path4.join(getClaudeConfigDir(), ".credentials.json");
+    return parseUsageAccessToken(fs4.readFileSync(credFile, "utf8"));
   } catch {
     return null;
   }
@@ -57434,7 +57661,7 @@ function getUsageToken() {
 }
 function readStaleUsageCache() {
   try {
-    return parseCachedUsageData(fs3.readFileSync(CACHE_FILE, "utf8"));
+    return parseCachedUsageData(fs4.readFileSync(CACHE_FILE, "utf8"));
   } catch {
     return null;
   }
@@ -57442,13 +57669,13 @@ function readStaleUsageCache() {
 function writeUsageLock(blockedUntil, error48) {
   try {
     ensureCacheDirExists();
-    fs3.writeFileSync(LOCK_FILE, JSON.stringify({ blockedUntil, error: error48 }));
+    fs4.writeFileSync(LOCK_FILE, JSON.stringify({ blockedUntil, error: error48 }));
   } catch {}
 }
 function readActiveUsageLock(now2) {
   let hasValidJsonLock = false;
   try {
-    const parsed = parseJsonWithSchema(fs3.readFileSync(LOCK_FILE, "utf8"), UsageLockSchema);
+    const parsed = parseJsonWithSchema(fs4.readFileSync(LOCK_FILE, "utf8"), UsageLockSchema);
     if (parsed) {
       hasValidJsonLock = true;
       if (parsed.blockedUntil > now2) {
@@ -57464,7 +57691,7 @@ function readActiveUsageLock(now2) {
     return null;
   }
   try {
-    const lockStat = fs3.statSync(LOCK_FILE);
+    const lockStat = fs4.statSync(LOCK_FILE);
     const lockMtime = Math.floor(lockStat.mtimeMs / 1000);
     const blockedUntil = lockMtime + LOCK_MAX_AGE;
     if (blockedUntil > now2) {
@@ -57519,14 +57746,14 @@ function getUsageApiRequestOptions(token) {
   }
 }
 async function fetchFromUsageApi(token) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     let settled = false;
     const finish = (value) => {
       if (settled) {
         return;
       }
       settled = true;
-      resolve(value);
+      resolve2(value);
     };
     const requestOptions = getUsageApiRequestOptions(token);
     if (!requestOptions) {
@@ -57577,10 +57804,10 @@ async function fetchUsageData(options = {}) {
     }
   }
   try {
-    const stat = fs3.statSync(CACHE_FILE);
+    const stat = fs4.statSync(CACHE_FILE);
     const fileAge = now2 - Math.floor(stat.mtimeMs / 1000);
     if (fileAge < CACHE_MAX_AGE) {
-      const fileData = parseCachedUsageData(fs3.readFileSync(CACHE_FILE, "utf8"));
+      const fileData = parseCachedUsageData(fs4.readFileSync(CACHE_FILE, "utf8"));
       if (fileData && !fileData.error && hasRequiredUsageFields(fileData, requiredFields)) {
         return cacheUsageData(fileData, now2);
       }
@@ -57606,32 +57833,40 @@ async function fetchUsageData(options = {}) {
     }
     const usageData = parseUsageApiResponse(response.body);
     if (!usageData) {
+      writeUsageLock(now2 + LOCK_MAX_AGE, "parse-error");
       return getStaleUsageOrError("parse-error", now2, LOCK_MAX_AGE, requiredFields);
     }
     if (usageData.sessionUsage === undefined && usageData.weeklyUsage === undefined) {
+      writeUsageLock(now2 + LOCK_MAX_AGE, "parse-error");
       return getStaleUsageOrError("parse-error", now2, LOCK_MAX_AGE, requiredFields);
     }
     try {
       ensureCacheDirExists();
-      fs3.writeFileSync(CACHE_FILE, JSON.stringify(usageData));
+      fs4.writeFileSync(CACHE_FILE, JSON.stringify(usageData));
     } catch {}
     return cacheUsageData(usageData, now2);
   } catch {
+    writeUsageLock(now2 + LOCK_MAX_AGE, "parse-error");
     return getStaleUsageOrError("parse-error", now2, LOCK_MAX_AGE, requiredFields);
   }
 }
-var CACHE_DIR, CACHE_FILE, LOCK_FILE, CACHE_MAX_AGE = 180, LOCK_MAX_AGE = 30, DEFAULT_RATE_LIMIT_BACKOFF = 300, MACOS_USAGE_CREDENTIALS_SERVICE = "Claude Code-credentials", MACOS_SECURITY_DUMP_MAX_BUFFER, UsageCredentialsSchema, UsageLockErrorSchema, UsageLockSchema, CachedUsageDataSchema, PerModelWeeklyBucketSchema, UsageApiResponseSchema, cachedUsageData = null, usageCacheTime = 0, usageErrorCacheMaxAge, USAGE_API_HOST = "api.anthropic.com", USAGE_API_PATH = "/api/oauth/usage", USAGE_API_TIMEOUT_MS = 5000;
+var CACHE_DIR, CACHE_FILE, LOCK_FILE, CACHE_MAX_AGE = 180, LOCK_MAX_AGE = 30, DEFAULT_RATE_LIMIT_BACKOFF = 300, MACOS_USAGE_CREDENTIALS_SERVICE = "Claude Code-credentials", MACOS_SECURITY_DUMP_MAX_BUFFER, EXTRA_USAGE_DETAIL_FIELDS, UsageCredentialsSchema, UsageLockErrorSchema, UsageLockSchema, CachedUsageDataSchema, UsageApiBucketSchema, UsageApiResponseSchema, cachedUsageData = null, usageCacheTime = 0, usageErrorCacheMaxAge, USAGE_API_HOST = "api.anthropic.com", USAGE_API_PATH = "/api/oauth/usage", USAGE_API_TIMEOUT_MS = 5000;
 var init_usage_fetch = __esm(async () => {
   init_dist5();
   init_zod();
   init_usage_types();
   await init_claude_settings();
-  CACHE_DIR = path3.join(os4.homedir(), ".cache", "ccstatusline");
-  CACHE_FILE = path3.join(CACHE_DIR, "usage.json");
-  LOCK_FILE = path3.join(CACHE_DIR, "usage.lock");
+  CACHE_DIR = path4.join(os5.homedir(), ".cache", "ccstatusline");
+  CACHE_FILE = path4.join(CACHE_DIR, "usage.json");
+  LOCK_FILE = path4.join(CACHE_DIR, "usage.lock");
   MACOS_SECURITY_DUMP_MAX_BUFFER = 8 * 1024 * 1024;
+  EXTRA_USAGE_DETAIL_FIELDS = new Set([
+    "extraUsageLimit",
+    "extraUsageUsed",
+    "extraUsageUtilization"
+  ]);
   UsageCredentialsSchema = exports_external.object({ claudeAiOauth: exports_external.object({ accessToken: exports_external.string().nullable().optional() }).optional() });
-  UsageLockErrorSchema = exports_external.enum(["timeout", "rate-limited"]);
+  UsageLockErrorSchema = exports_external.enum(["timeout", "rate-limited", "parse-error"]);
   UsageLockSchema = exports_external.object({
     blockedUntil: exports_external.number(),
     error: UsageLockErrorSchema.optional()
@@ -57652,27 +57887,21 @@ var init_usage_fetch = __esm(async () => {
     error: exports_external.string().nullable().optional(),
     provider: exports_external.enum(["anthropic", "opencode"]).nullable().optional()
   });
-  PerModelWeeklyBucketSchema = exports_external.object({
+  UsageApiBucketSchema = exports_external.looseObject({
     utilization: exports_external.number().nullable().optional(),
     resets_at: exports_external.string().nullable().optional()
   }).nullable().optional();
-  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(),
-    seven_day_sonnet: PerModelWeeklyBucketSchema,
-    seven_day_opus: PerModelWeeklyBucketSchema,
-    extra_usage: exports_external.object({
+  UsageApiResponseSchema = exports_external.looseObject({
+    five_hour: UsageApiBucketSchema,
+    seven_day: UsageApiBucketSchema,
+    seven_day_sonnet: UsageApiBucketSchema,
+    seven_day_opus: UsageApiBucketSchema,
+    extra_usage: exports_external.looseObject({
       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()
+    }).nullable().optional()
   });
   usageErrorCacheMaxAge = LOCK_MAX_AGE;
 });
@@ -58835,6 +59064,12 @@ function toggleUsageDateMode(item) {
 function toggleUsageHourFormat(item) {
   return toggleMetadataFlag(item, "hour12");
 }
+function isUsageWeekdayEnabled(item) {
+  return isMetadataFlagEnabled(item, "weekday");
+}
+function toggleUsageWeekday(item) {
+  return toggleMetadataFlag(item, "weekday");
+}
 function getUsageDisplayModifierText(item, options = {}) {
   const mode = getUsageDisplayMode(item);
   const modifiers = [];
@@ -58923,6 +59158,9 @@ function getUsageTimerCustomKeybinds(item, options = {}) {
     if (options.includeHourFormat) {
       keybinds.push(HOUR_FORMAT_TOGGLE_KEYBIND);
     }
+    if (options.includeWeekday) {
+      keybinds.push(WEEKDAY_TOGGLE_KEYBIND);
+    }
     if (options.includeTimezone) {
       keybinds.push(TIMEZONE_KEYBIND);
     }
@@ -58932,7 +59170,7 @@ function getUsageTimerCustomKeybinds(item, options = {}) {
   }
   return keybinds;
 }
-var SLIDER_WIDTH = 10, PROGRESS_TOGGLE_KEYBIND, INVERT_TOGGLE_KEYBIND, COMPACT_TOGGLE_KEYBIND, CURSOR_TOGGLE_KEYBIND, DATE_TOGGLE_KEYBIND, HOUR_FORMAT_TOGGLE_KEYBIND, TIMEZONE_KEYBIND, LOCALE_KEYBIND;
+var SLIDER_WIDTH = 10, PROGRESS_TOGGLE_KEYBIND, INVERT_TOGGLE_KEYBIND, COMPACT_TOGGLE_KEYBIND, CURSOR_TOGGLE_KEYBIND, DATE_TOGGLE_KEYBIND, HOUR_FORMAT_TOGGLE_KEYBIND, WEEKDAY_TOGGLE_KEYBIND, TIMEZONE_KEYBIND, LOCALE_KEYBIND;
 var init_usage_display = __esm(() => {
   init_locales2();
   PROGRESS_TOGGLE_KEYBIND = { key: "p", label: "(p)rogress toggle", action: "toggle-progress" };
@@ -58941,6 +59179,7 @@ var init_usage_display = __esm(() => {
   CURSOR_TOGGLE_KEYBIND = { key: "t", label: "(t)ime cursor", action: "toggle-cursor" };
   DATE_TOGGLE_KEYBIND = { key: "t", label: "(t)imestamp", action: "toggle-date" };
   HOUR_FORMAT_TOGGLE_KEYBIND = { key: "h", label: "12/24 (h)our", action: "toggle-hour-format" };
+  WEEKDAY_TOGGLE_KEYBIND = { key: "w", label: "(w)eekday", action: "toggle-weekday" };
   TIMEZONE_KEYBIND = { key: "z", label: "time(z)one", action: "edit-timezone" };
   LOCALE_KEYBIND = { key: "l", label: "(l)ocale", action: "edit-locale" };
 });
@@ -59847,7 +60086,8 @@ class CustomCommandWidget {
           input: jsonInput,
           timeout,
           stdio: ["pipe", "pipe", "ignore"],
-          env: process.env
+          env: process.env,
+          windowsHide: true
         }).trim();
         if (!item.preserveColors) {
           output = getVisibleText(output);
@@ -60059,31 +60299,31 @@ var init_CustomCommand = __esm(async () => {
 
 // node_modules/fdir/dist/index.mjs
 import { createRequire as createRequire2 } from "module";
-import { basename, dirname, normalize, relative, resolve, sep } from "path";
+import { basename, dirname as dirname2, normalize, relative, resolve as resolve2, sep } from "path";
 import * as nativeFs from "fs";
-function cleanPath(path4) {
-  let normalized = normalize(path4);
+function cleanPath(path5) {
+  let normalized = normalize(path5);
   if (normalized.length > 1 && normalized[normalized.length - 1] === sep)
     normalized = normalized.substring(0, normalized.length - 1);
   return normalized;
 }
-function convertSlashes(path4, separator) {
-  return path4.replace(SLASHES_REGEX, separator);
+function convertSlashes(path5, separator) {
+  return path5.replace(SLASHES_REGEX, separator);
 }
-function isRootDirectory(path4) {
-  return path4 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path4);
+function isRootDirectory(path5) {
+  return path5 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path5);
 }
-function normalizePath(path4, options) {
+function normalizePath(path5, options) {
   const { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options;
-  const pathNeedsCleaning = process.platform === "win32" && path4.includes("/") || path4.startsWith(".");
+  const pathNeedsCleaning = process.platform === "win32" && path5.includes("/") || path5.startsWith(".");
   if (resolvePaths)
-    path4 = resolve(path4);
+    path5 = resolve2(path5);
   if (normalizePath$1 || pathNeedsCleaning)
-    path4 = cleanPath(path4);
-  if (path4 === ".")
+    path5 = cleanPath(path5);
+  if (path5 === ".")
     return "";
-  const needsSeperator = path4[path4.length - 1] !== pathSeparator;
-  return convertSlashes(needsSeperator ? path4 + pathSeparator : path4, pathSeparator);
+  const needsSeperator = path5[path5.length - 1] !== pathSeparator;
+  return convertSlashes(needsSeperator ? path5 + pathSeparator : path5, pathSeparator);
 }
 function joinPathWithBasePath(filename, directoryPath) {
   return directoryPath + filename;
@@ -60149,10 +60389,10 @@ function build$2(options, isSynchronous) {
     return null;
   return isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
 }
-function isRecursive(path4, resolved, state) {
+function isRecursive(path5, resolved, state) {
   if (state.options.useRealPaths)
     return isRecursiveUsingRealPaths(resolved, state);
-  let parent = dirname(path4);
+  let parent = dirname2(path5);
   let depth = 1;
   while (parent !== state.root && depth < 2) {
     const resolvedPath = state.symlinks.get(parent);
@@ -60160,9 +60400,9 @@ function isRecursive(path4, resolved, state) {
     if (isSameRoot)
       depth++;
     else
-      parent = dirname(parent);
+      parent = dirname2(parent);
   }
-  state.symlinks.set(path4, resolved);
+  state.symlinks.set(path5, resolved);
   return depth > 1;
 }
 function isRecursiveUsingRealPaths(resolved, state) {
@@ -60208,9 +60448,9 @@ function sync(root, options) {
 var __require2, SLASHES_REGEX, WINDOWS_ROOT_DIR_REGEX, pushDirectory = (directoryPath, paths) => {
   paths.push(directoryPath || ".");
 }, pushDirectoryFilter = (directoryPath, paths, filters) => {
-  const path4 = directoryPath || ".";
-  if (filters.every((filter2) => filter2(path4, true)))
-    paths.push(path4);
+  const path5 = directoryPath || ".";
+  if (filters.every((filter2) => filter2(path5, true)))
+    paths.push(path5);
 }, empty$2 = () => {}, pushFileFilterAndCount = (filename, _paths, counts, filters) => {
   if (filters.every((filter2) => filter2(filename, false)))
     counts.files++;
@@ -60231,28 +60471,28 @@ var __require2, SLASHES_REGEX, WINDOWS_ROOT_DIR_REGEX, pushDirectory = (director
     files,
     dir: directory
   });
-}, empty = () => {}, resolveSymlinksAsync = function(path4, state, callback$1) {
-  const { queue, fs: fs4, options: { suppressErrors } } = state;
+}, empty = () => {}, resolveSymlinksAsync = function(path5, state, callback$1) {
+  const { queue, fs: fs5, options: { suppressErrors } } = state;
   queue.enqueue();
-  fs4.realpath(path4, (error48, resolvedPath) => {
+  fs5.realpath(path5, (error48, resolvedPath) => {
     if (error48)
       return queue.dequeue(suppressErrors ? null : error48, state);
-    fs4.stat(resolvedPath, (error$1, stat) => {
+    fs5.stat(resolvedPath, (error$1, stat) => {
       if (error$1)
         return queue.dequeue(suppressErrors ? null : error$1, state);
-      if (stat.isDirectory() && isRecursive(path4, resolvedPath, state))
+      if (stat.isDirectory() && isRecursive(path5, resolvedPath, state))
         return queue.dequeue(null, state);
       callback$1(stat, resolvedPath);
       queue.dequeue(null, state);
     });
   });
-}, resolveSymlinks = function(path4, state, callback$1) {
-  const { queue, fs: fs4, options: { suppressErrors } } = state;
+}, resolveSymlinks = function(path5, state, callback$1) {
+  const { queue, fs: fs5, options: { suppressErrors } } = state;
   queue.enqueue();
   try {
-    const resolvedPath = fs4.realpathSync(path4);
-    const stat = fs4.statSync(resolvedPath);
-    if (stat.isDirectory() && isRecursive(path4, resolvedPath, state))
+    const resolvedPath = fs5.realpathSync(path5);
+    const stat = fs5.statSync(resolvedPath);
+    if (stat.isDirectory() && isRecursive(path5, resolvedPath, state))
       return;
     callback$1(stat, resolvedPath);
   } catch (e) {
@@ -60283,22 +60523,22 @@ var __require2, SLASHES_REGEX, WINDOWS_ROOT_DIR_REGEX, pushDirectory = (director
   state.queue.enqueue();
   if (currentDepth < 0)
     return state.queue.dequeue(null, state);
-  const { fs: fs4 } = state;
+  const { fs: fs5 } = state;
   state.visited.push(crawlPath);
   state.counts.directories++;
-  fs4.readdir(crawlPath || ".", readdirOpts, (error48, entries = []) => {
+  fs5.readdir(crawlPath || ".", readdirOpts, (error48, entries = []) => {
     callback$1(entries, directoryPath, currentDepth);
     state.queue.dequeue(state.options.suppressErrors ? null : error48, state);
   });
 }, walkSync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
-  const { fs: fs4 } = state;
+  const { fs: fs5 } = state;
   if (currentDepth < 0)
     return;
   state.visited.push(crawlPath);
   state.counts.directories++;
   let entries = [];
   try {
-    entries = fs4.readdirSync(crawlPath || ".", readdirOpts);
+    entries = fs5.readdirSync(crawlPath || ".", readdirOpts);
   } catch (e) {
     if (!state.options.suppressErrors)
       throw e;
@@ -60397,23 +60637,23 @@ var __require2, SLASHES_REGEX, WINDOWS_ROOT_DIR_REGEX, pushDirectory = (director
         const filename = this.joinPath(entry.name, directoryPath);
         this.pushFile(filename, files, this.state.counts, filters);
       } else if (entry.isDirectory()) {
-        let path4 = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
-        if (exclude && exclude(entry.name, path4))
+        let path5 = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
+        if (exclude && exclude(entry.name, path5))
           continue;
-        this.pushDirectory(path4, paths, filters);
-        this.walkDirectory(this.state, path4, path4, depth - 1, this.walk);
+        this.pushDirectory(path5, paths, filters);
+        this.walkDirectory(this.state, path5, path5, depth - 1, this.walk);
       } else if (this.resolveSymlink && entry.isSymbolicLink()) {
-        let path4 = joinPathWithBasePath(entry.name, directoryPath);
-        this.resolveSymlink(path4, this.state, (stat, resolvedPath) => {
+        let path5 = joinPathWithBasePath(entry.name, directoryPath);
+        this.resolveSymlink(path5, this.state, (stat, resolvedPath) => {
           if (stat.isDirectory()) {
             resolvedPath = normalizePath(resolvedPath, this.state.options);
-            if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path4 + pathSeparator))
+            if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path5 + pathSeparator))
               return;
-            this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path4 + pathSeparator, depth - 1, this.walk);
+            this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path5 + pathSeparator, depth - 1, this.walk);
           } else {
-            resolvedPath = useRealPaths ? resolvedPath : path4;
+            resolvedPath = useRealPaths ? resolvedPath : path5;
             const filename = basename(resolvedPath);
-            const directoryPath$1 = normalizePath(dirname(resolvedPath), this.state.options);
+            const directoryPath$1 = normalizePath(dirname2(resolvedPath), this.state.options);
             resolvedPath = this.joinPath(filename, directoryPath$1);
             this.pushFile(resolvedPath, files, this.state.counts, filters);
           }
@@ -60547,7 +60787,7 @@ var __require2, SLASHES_REGEX, WINDOWS_ROOT_DIR_REGEX, pushDirectory = (director
       isMatch2 = globFn(patterns, ...options);
       this.globCache[patterns.join("\x00")] = isMatch2;
     }
-    this.options.filters.push((path4) => isMatch2(path4));
+    this.options.filters.push((path5) => isMatch2(path5));
     return this;
   }
 };
@@ -60760,8 +61000,8 @@ var require_utils = __commonJS((exports) => {
     }
     return output;
   };
-  exports.basename = (path4, { windows } = {}) => {
-    const segs = path4.split(windows ? /[\\/]/ : "/");
+  exports.basename = (path5, { windows } = {}) => {
+    const segs = path5.split(windows ? /[\\/]/ : "/");
     const last2 = segs[segs.length - 1];
     if (last2 === "") {
       return segs[segs.length - 2];
@@ -62242,8 +62482,8 @@ var require_picomatch2 = __commonJS((exports, module) => {
 });
 
 // node_modules/tinyglobby/dist/index.mjs
-import { readdir, readdirSync, realpath, realpathSync, stat, statSync as statSync3 } from "fs";
-import { isAbsolute, posix, resolve as resolve2 } from "path";
+import { readdir, readdirSync, realpath, realpathSync, stat, statSync as statSync4 } from "fs";
+import { isAbsolute, posix, resolve as resolve3 } from "path";
 import { fileURLToPath } from "url";
 function getPartialMatcher(patterns, options = {}) {
   const patternsCount = patterns.length;
@@ -62315,10 +62555,10 @@ function buildRelative(cwd2, root) {
     return p[p.length - 1] === "/" && result2 !== "" ? `${result2}/` : result2 || ".";
   };
 }
-function splitPattern(path4) {
+function splitPattern(path5) {
   var _result$parts;
-  const result2 = import_picomatch.default.scan(path4, splitPatternOptions);
-  return ((_result$parts = result2.parts) === null || _result$parts === undefined ? undefined : _result$parts.length) ? result2.parts : [path4];
+  const result2 = import_picomatch.default.scan(path5, splitPatternOptions);
+  return ((_result$parts = result2.parts) === null || _result$parts === undefined ? undefined : _result$parts.length) ? result2.parts : [path5];
 }
 function isDynamicPattern(pattern, options) {
   if ((options === null || options === undefined ? undefined : options.caseSensitiveMatch) === false)
@@ -62434,14 +62674,14 @@ function buildCrawler(options, patterns) {
     maxDepth = Math.round(options.deep - props.depthOffset);
   const crawler = new Builder({
     filters: [debug3 ? (p, isDirectory) => {
-      const path4 = format(p, isDirectory);
-      const matches2 = matcher(path4) && !ignore(path4);
+      const path5 = format(p, isDirectory);
+      const matches2 = matcher(path5) && !ignore(path5);
       if (matches2)
-        log(`matched ${path4}`);
+        log(`matched ${path5}`);
       return matches2;
     } : (p, isDirectory) => {
-      const path4 = format(p, isDirectory);
-      return matcher(path4) && !ignore(path4);
+      const path5 = format(p, isDirectory);
+      return matcher(path5) && !ignore(path5);
     }],
     exclude: debug3 ? (_, p) => {
       const skipped = excludePredicate(_, p);
@@ -62478,7 +62718,7 @@ function getOptions2(options) {
     ...defaultOptions,
     ...options
   };
-  opts.cwd = (opts.cwd instanceof URL ? fileURLToPath(opts.cwd) : resolve2(opts.cwd)).replace(BACKSLASHES, "/");
+  opts.cwd = (opts.cwd instanceof URL ? fileURLToPath(opts.cwd) : resolve3(opts.cwd)).replace(BACKSLASHES, "/");
   opts.ignore = ensureStringArray(opts.ignore);
   opts.fs && (opts.fs = {
     readdir: opts.fs.readdir || readdir,
@@ -62486,7 +62726,7 @@ function getOptions2(options) {
     realpath: opts.fs.realpath || realpath,
     realpathSync: opts.fs.realpathSync || realpathSync,
     stat: opts.fs.stat || stat,
-    statSync: opts.fs.statSync || statSync3
+    statSync: opts.fs.statSync || statSync4
   });
   if (opts.debug)
     log("globbing with options:", opts);
@@ -62505,7 +62745,7 @@ function globSync(globInput, options) {
   const [crawler, relative2] = getCrawler(globInput, options);
   return crawler ? formatPaths(crawler.sync(), relative2) : [];
 }
-var import_picomatch, isReadonlyArray, BACKSLASHES, isWin, ONLY_PARENT_DIRECTORIES, WIN32_ROOT_DIR, isRoot, splitPatternOptions, POSIX_UNESCAPED_GLOB_SYMBOLS, WIN32_UNESCAPED_GLOB_SYMBOLS, escapePosixPath = (path4) => path4.replace(POSIX_UNESCAPED_GLOB_SYMBOLS, "\\$&"), escapeWin32Path = (path4) => path4.replace(WIN32_UNESCAPED_GLOB_SYMBOLS, "\\$&"), escapePath, PARENT_DIRECTORY, ESCAPING_BACKSLASHES, defaultOptions;
+var import_picomatch, isReadonlyArray, BACKSLASHES, isWin, ONLY_PARENT_DIRECTORIES, WIN32_ROOT_DIR, isRoot, splitPatternOptions, POSIX_UNESCAPED_GLOB_SYMBOLS, WIN32_UNESCAPED_GLOB_SYMBOLS, escapePosixPath = (path5) => path5.replace(POSIX_UNESCAPED_GLOB_SYMBOLS, "\\$&"), escapeWin32Path = (path5) => path5.replace(WIN32_UNESCAPED_GLOB_SYMBOLS, "\\$&"), escapePath, PARENT_DIRECTORY, ESCAPING_BACKSLASHES, defaultOptions;
 var init_dist7 = __esm(() => {
   init_dist6();
   import_picomatch = __toESM(require_picomatch2(), 1);
@@ -62532,7 +62772,7 @@ var init_dist7 = __esm(() => {
 });
 
 // src/utils/jsonl-lines.ts
-import * as fs4 from "fs";
+import * as fs5 from "fs";
 import { promisify } from "util";
 function splitJsonlContent(content) {
   return content.trim().split(`
@@ -62543,7 +62783,7 @@ async function readJsonlLines(filePath) {
   return splitJsonlContent(content);
 }
 function readJsonlLinesSync(filePath) {
-  const content = readFileSync6(filePath, "utf-8");
+  const content = readFileSync7(filePath, "utf-8");
   return splitJsonlContent(content);
 }
 function parseJsonlLine(line) {
@@ -62553,15 +62793,15 @@ function parseJsonlLine(line) {
     return null;
   }
 }
-var readFile2, readFileSync6;
+var readFile2, readFileSync7;
 var init_jsonl_lines = __esm(() => {
-  readFile2 = promisify(fs4.readFile);
-  readFileSync6 = fs4.readFileSync;
+  readFile2 = promisify(fs5.readFile);
+  readFileSync7 = fs5.readFileSync;
 });
 
 // src/utils/jsonl-blocks.ts
-import * as fs5 from "fs";
-import path4 from "node:path";
+import * as fs6 from "fs";
+import path5 from "node:path";
 function getBlockMetrics() {
   const claudeDir = getClaudeConfigDir();
   if (!claudeDir)
@@ -62575,7 +62815,7 @@ function getBlockMetrics() {
 function findMostRecentBlockStartTime(rootDir, sessionDurationHours = 5) {
   const sessionDurationMs = sessionDurationHours * 60 * 60 * 1000;
   const now2 = new Date;
-  const pattern = path4.posix.join(rootDir.replace(/\\/g, "/"), "projects", "**", "*.jsonl");
+  const pattern = path5.posix.join(rootDir.replace(/\\/g, "/"), "projects", "**", "*.jsonl");
   const files = globSync([pattern], {
     absolute: true,
     cwd: rootDir
@@ -62583,7 +62823,7 @@ function findMostRecentBlockStartTime(rootDir, sessionDurationHours = 5) {
   if (files.length === 0)
     return null;
   const filesWithStats = files.map((file2) => {
-    const stats = statSync5(file2);
+    const stats = statSync6(file2);
     return { file: file2, mtime: stats.mtime };
   });
   filesWithStats.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
@@ -62701,26 +62941,26 @@ function floorToHour(timestamp) {
   floored.setUTCMinutes(0, 0, 0);
   return floored;
 }
-var statSync5;
+var statSync6;
 var init_jsonl_blocks = __esm(async () => {
   init_dist7();
   init_jsonl_lines();
   await init_claude_settings();
-  statSync5 = fs5.statSync;
+  statSync6 = fs6.statSync;
 });
 
 // src/utils/jsonl-cache.ts
-import * as fs6 from "fs";
-import { createHash as createHash2 } from "node:crypto";
-import os5 from "node:os";
-import path5 from "node:path";
+import * as fs7 from "fs";
+import { createHash as createHash3 } from "node:crypto";
+import os6 from "node:os";
+import path6 from "node:path";
 function normalizeConfigDir(configDir) {
-  return path5.resolve(configDir);
+  return path6.resolve(configDir);
 }
 function getBlockCachePath(configDir = getClaudeConfigDir()) {
   const normalizedConfigDir = normalizeConfigDir(configDir);
-  const configHash = createHash2("sha256").update(normalizedConfigDir).digest("hex").slice(0, 16);
-  return path5.join(os5.homedir(), ".cache", "ccstatusline", `block-cache-${configHash}.json`);
+  const configHash = createHash3("sha256").update(normalizedConfigDir).digest("hex").slice(0, 16);
+  return path6.join(os6.homedir(), ".cache", "ccstatusline", `block-cache-${configHash}.json`);
 }
 function readBlockCache(expectedConfigDir) {
   try {
@@ -62729,7 +62969,7 @@ function readBlockCache(expectedConfigDir) {
     if (!existsSync6(cachePath)) {
       return null;
     }
-    const content = readFileSync8(cachePath, "utf-8");
+    const content = readFileSync9(cachePath, "utf-8");
     const cache3 = JSON.parse(content);
     if (typeof cache3.startTime !== "string") {
       return null;
@@ -62755,15 +62995,15 @@ function writeBlockCache(startTime, configDir = getClaudeConfigDir()) {
   try {
     const normalizedConfigDir = normalizeConfigDir(configDir);
     const cachePath = getBlockCachePath(normalizedConfigDir);
-    const cacheDir = path5.dirname(cachePath);
+    const cacheDir = path6.dirname(cachePath);
     if (!existsSync6(cacheDir)) {
-      mkdirSync4(cacheDir, { recursive: true });
+      mkdirSync5(cacheDir, { recursive: true });
     }
     const cache3 = {
       startTime: startTime.toISOString(),
       configDir: normalizedConfigDir
     };
-    writeFileSync4(cachePath, JSON.stringify(cache3), "utf-8");
+    writeFileSync5(cachePath, JSON.stringify(cache3), "utf-8");
   } catch {}
 }
 function getCachedBlockMetrics(sessionDurationHours = 5) {
@@ -62786,21 +63026,21 @@ function getCachedBlockMetrics(sessionDurationHours = 5) {
   }
   return metrics;
 }
-var readFileSync8, writeFileSync4, mkdirSync4, existsSync6;
+var readFileSync9, writeFileSync5, mkdirSync5, existsSync6;
 var init_jsonl_cache = __esm(async () => {
   await __promiseAll([
     init_claude_settings(),
     init_jsonl_blocks()
   ]);
-  readFileSync8 = fs6.readFileSync;
-  writeFileSync4 = fs6.writeFileSync;
-  mkdirSync4 = fs6.mkdirSync;
-  existsSync6 = fs6.existsSync;
+  readFileSync9 = fs7.readFileSync;
+  writeFileSync5 = fs7.writeFileSync;
+  mkdirSync5 = fs7.mkdirSync;
+  existsSync6 = fs7.existsSync;
 });
 
 // src/utils/jsonl-metrics.ts
-import * as fs7 from "fs";
-import path6 from "node:path";
+import * as fs8 from "fs";
+import path7 from "node:path";
 function collectAgentIds(value, agentIds) {
   if (!value || typeof value !== "object") {
     return;
@@ -62832,7 +63072,7 @@ function getReferencedSubagentIds(lines) {
 }
 async function getSessionDuration(transcriptPath) {
   try {
-    if (!fs7.existsSync(transcriptPath)) {
+    if (!fs8.existsSync(transcriptPath)) {
       return null;
     }
     const lines = await readJsonlLines(transcriptPath);
@@ -62882,7 +63122,7 @@ async function getSessionDuration(transcriptPath) {
 }
 async function getTokenMetrics(transcriptPath) {
   try {
-    if (!fs7.existsSync(transcriptPath)) {
+    if (!fs8.existsSync(transcriptPath)) {
       return { inputTokens: 0, outputTokens: 0, cachedTokens: 0, totalTokens: 0, contextLength: 0 };
     }
     const lines = await readJsonlLines(transcriptPath);
@@ -63096,20 +63336,20 @@ function getSubagentTranscriptPaths(transcriptPath, referencedAgentIds) {
   if (referencedAgentIds.size === 0) {
     return [];
   }
-  const transcriptDir = path6.dirname(transcriptPath);
-  const transcriptStem = path6.parse(transcriptPath).name;
+  const transcriptDir = path7.dirname(transcriptPath);
+  const transcriptStem = path7.parse(transcriptPath).name;
   const candidateDirs = [
-    path6.join(transcriptDir, "subagents"),
-    path6.join(transcriptDir, transcriptStem, "subagents")
+    path7.join(transcriptDir, "subagents"),
+    path7.join(transcriptDir, transcriptStem, "subagents")
   ];
   const seenPaths = new Set;
   const matchedPaths = [];
   for (const subagentsDir of candidateDirs) {
-    if (!fs7.existsSync(subagentsDir)) {
+    if (!fs8.existsSync(subagentsDir)) {
       continue;
     }
     try {
-      const dirEntries = fs7.readdirSync(subagentsDir, { withFileTypes: true });
+      const dirEntries = fs8.readdirSync(subagentsDir, { withFileTypes: true });
       for (const entry of dirEntries) {
         if (!entry.isFile()) {
           continue;
@@ -63121,7 +63361,7 @@ function getSubagentTranscriptPaths(transcriptPath, referencedAgentIds) {
         if (!referencedAgentIds.has(match[1])) {
           continue;
         }
-        const fullPath = path6.join(subagentsDir, entry.name);
+        const fullPath = path7.join(subagentsDir, entry.name);
         if (seenPaths.has(fullPath)) {
           continue;
         }
@@ -63138,7 +63378,7 @@ async function getSpeedMetricsCollection(transcriptPath, options = {}) {
   const normalizedWindows = Array.from(new Set((options.windowSeconds ?? []).map((window2) => normalizeWindowSeconds(window2)).filter((window2) => window2 !== null)));
   const emptyWindowedMetrics = buildEmptyWindowedMetrics(normalizedWindows);
   try {
-    if (!fs7.existsSync(transcriptPath)) {
+    if (!fs8.existsSync(transcriptPath)) {
       return {
         sessionAverage: createEmptySpeedMetrics(),
         windowed: emptyWindowedMetrics
@@ -63335,44 +63575,69 @@ function formatUsageDuration(durationMs, compact2 = false, useDays = true) {
 function pad2(value) {
   return value.toString().padStart(2, "0");
 }
-function formatResetAtUtc(date5, compact2, hour12) {
+function formatResetAtUtc(date5, compact2, hour12, weekday = false) {
   const year = date5.getUTCFullYear();
   const month = pad2(date5.getUTCMonth() + 1);
   const day = pad2(date5.getUTCDate());
   const hours = pad2(date5.getUTCHours());
   const minutes = pad2(date5.getUTCMinutes());
+  const weekdayName = weekday ? UTC_WEEKDAY_NAMES[date5.getUTCDay()] : "";
   if (hour12) {
     const hour = date5.getUTCHours();
     const displayHour = hour % 12 || 12;
     const period = hour >= 12 ? "PM" : "AM";
+    if (weekday) {
+      return compact2 ? `${weekdayName} ${displayHour}:${minutes} ${period}Z` : `${weekdayName} ${displayHour}:${minutes} ${period} UTC`;
+    }
     return compact2 ? `${month}-${day} ${displayHour}:${minutes} ${period}Z` : `${year}-${month}-${day} ${displayHour}:${minutes} ${period} UTC`;
   }
+  if (weekday) {
+    return compact2 ? `${weekdayName} ${hours}:${minutes}Z` : `${weekdayName} ${hours}:${minutes} UTC`;
+  }
   return compact2 ? `${month}-${day} ${hours}:${minutes}Z` : `${year}-${month}-${day} ${hours}:${minutes} UTC`;
 }
 function normalizeDayPeriod(dayPeriod) {
   return dayPeriod.replace(/\./g, "").toUpperCase();
 }
-function formatResetAtInTimezone(date5, compact2, timezone, locale, hour12) {
+function formatResetAtInTimezone(date5, compact2, timezone, locale, hour12, weekday = false) {
   try {
-    const formatter = new Intl.DateTimeFormat(locale, {
+    const options = {
       timeZone: timezone,
-      year: "numeric",
-      month: "2-digit",
-      day: "2-digit",
       hour: "2-digit",
       minute: "2-digit",
       hour12,
       timeZoneName: "short"
-    });
+    };
+    if (weekday) {
+      options.weekday = "short";
+    } else {
+      options.year = "numeric";
+      options.month = "2-digit";
+      options.day = "2-digit";
+    }
+    const formatter = new Intl.DateTimeFormat(locale, options);
     const parts = formatter.formatToParts(date5);
     const get2 = (type) => parts.find((p) => p.type === type)?.value ?? "";
-    const year = get2("year");
-    const month = get2("month");
-    const day = get2("day");
     const hour = get2("hour");
     const minute = get2("minute");
     const dayPeriod = get2("dayPeriod");
     const tzName = get2("timeZoneName");
+    if (weekday) {
+      const weekdayName = get2("weekday");
+      if (!weekdayName || !hour || !minute) {
+        return null;
+      }
+      if (hour12) {
+        const displayHour = hour.startsWith("0") ? hour.slice(1) : hour;
+        const normalizedDayPeriod = dayPeriod ? normalizeDayPeriod(dayPeriod) : "";
+        const time3 = `${displayHour}:${minute}${normalizedDayPeriod ? ` ${normalizedDayPeriod}` : ""}`;
+        return compact2 ? `${weekdayName} ${time3}` : `${weekdayName} ${time3} ${tzName}`;
+      }
+      return compact2 ? `${weekdayName} ${hour}:${minute}` : `${weekdayName} ${hour}:${minute} ${tzName}`;
+    }
+    const year = get2("year");
+    const month = get2("month");
+    const day = get2("day");
     if (!year || !month || !day || !hour || !minute) {
       return null;
     }
@@ -63387,7 +63652,7 @@ function formatResetAtInTimezone(date5, compact2, timezone, locale, hour12) {
     return null;
   }
 }
-function formatUsageResetAt(resetAt, compact2 = false, timezone, localeOrHour12, hour12Arg = false) {
+function formatUsageResetAt(resetAt, compact2 = false, timezone, localeOrHour12, hour12Arg = false, weekday = false) {
   if (!resetAt) {
     return null;
   }
@@ -63399,21 +63664,21 @@ function formatUsageResetAt(resetAt, compact2 = false, timezone, localeOrHour12,
   const locale = typeof localeOrHour12 === "string" ? localeOrHour12 : undefined;
   const hour12 = typeof localeOrHour12 === "boolean" ? localeOrHour12 : hour12Arg;
   if (!timezone || timezone === "UTC") {
-    return formatResetAtUtc(date5, compact2, hour12);
+    return formatResetAtUtc(date5, compact2, hour12, weekday);
   }
   const resolvedTimezone = timezone === "local" ? undefined : timezone;
   const resolvedLocale = locale && locale.length > 0 ? locale : DEFAULT_TZ_LOCALE;
-  const localized = formatResetAtInTimezone(date5, compact2, resolvedTimezone, resolvedLocale, hour12);
+  const localized = formatResetAtInTimezone(date5, compact2, resolvedTimezone, resolvedLocale, hour12, weekday);
   if (localized) {
     return localized;
   }
   if (resolvedLocale !== DEFAULT_TZ_LOCALE) {
-    const fallback = formatResetAtInTimezone(date5, compact2, resolvedTimezone, DEFAULT_TZ_LOCALE, hour12);
+    const fallback = formatResetAtInTimezone(date5, compact2, resolvedTimezone, DEFAULT_TZ_LOCALE, hour12, weekday);
     if (fallback) {
       return fallback;
     }
   }
-  return formatResetAtUtc(date5, compact2, hour12);
+  return formatResetAtUtc(date5, compact2, hour12, weekday);
 }
 function getUsageErrorMessage(error48) {
   switch (error48) {
@@ -63444,10 +63709,11 @@ function makePendulumBar(delta, halfWidth = 7) {
   }
   return "[" + "░".repeat(halfWidth) + "|" + "█".repeat(fill2) + "░".repeat(halfWidth - fill2) + "]";
 }
-var DEFAULT_TZ_LOCALE = "en-US", DARK_RED_OPEN = "\x1B[38;2;204;0;0m", DARK_RED_CLOSE = "\x1B[39m";
+var UTC_WEEKDAY_NAMES, DEFAULT_TZ_LOCALE = "en-US", DARK_RED_OPEN = "\x1B[38;2;204;0;0m", DARK_RED_CLOSE = "\x1B[39m";
 var init_usage_windows = __esm(async () => {
   init_usage_types();
   await init_jsonl();
+  UTC_WEEKDAY_NAMES = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
 });
 
 // src/utils/usage.ts
@@ -63563,7 +63829,7 @@ var init_BlockTimer = __esm(async () => {
 });
 
 // src/widgets/CurrentWorkingDir.tsx
-import * as os6 from "node:os";
+import * as os7 from "node:os";
 
 class CurrentWorkingDirWidget {
   getDefaultColor() {
@@ -63708,27 +63974,27 @@ class CurrentWorkingDirWidget {
   supportsColors(item) {
     return true;
   }
-  abbreviateHomeDir(path7) {
-    const homeDir = os6.homedir();
-    if (path7 === homeDir) {
+  abbreviateHomeDir(path8) {
+    const homeDir = os7.homedir();
+    if (path8 === homeDir) {
       return "~";
     }
-    if (path7.startsWith(homeDir)) {
-      const boundaryChar = path7[homeDir.length];
+    if (path8.startsWith(homeDir)) {
+      const boundaryChar = path8[homeDir.length];
       if (boundaryChar !== "/" && boundaryChar !== "\\") {
-        return path7;
+        return path8;
       }
-      return "~" + path7.slice(homeDir.length);
+      return "~" + path8.slice(homeDir.length);
     }
-    return path7;
+    return path8;
   }
-  abbreviatePath(path7) {
-    const homeDir = os6.homedir();
-    const useBackslash = path7.includes("\\") && !path7.includes("/");
+  abbreviatePath(path8) {
+    const homeDir = os7.homedir();
+    const useBackslash = path8.includes("\\") && !path8.includes("/");
     const sep2 = useBackslash ? "\\" : "/";
-    let normalizedPath = path7;
-    if (path7.startsWith(homeDir)) {
-      normalizedPath = "~" + path7.slice(homeDir.length);
+    let normalizedPath = path8;
+    if (path8.startsWith(homeDir)) {
+      normalizedPath = "~" + path8.slice(homeDir.length);
     }
     const parts = normalizedPath.split(/[\\/]+/).filter((part) => part !== "");
     const abbreviated = parts.map((part, index) => {
@@ -63863,6 +64129,7 @@ function runJjArgs(args, context, allowEmpty = false) {
     const output = execFileSync4("jj", args, {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "ignore"],
+      windowsHide: true,
       ...cwd2 ? { cwd: cwd2 } : {}
     }).trimEnd();
     return allowEmpty || output.length > 0 ? output : null;
@@ -64500,7 +64767,7 @@ var init_JjRevision = __esm(() => {
 });
 
 // src/widgets/ClaudeAccountEmail.ts
-import * as fs8 from "fs";
+import * as fs9 from "fs";
 
 class ClaudeAccountEmailWidget {
   getDefaultColor() {
@@ -64523,7 +64790,7 @@ class ClaudeAccountEmailWidget {
       return item.rawValue ? "you@example.com" : "Account: you@example.com";
     }
     try {
-      const content = fs8.readFileSync(getClaudeJsonPath(), "utf-8");
+      const content = fs9.readFileSync(getClaudeJsonPath(), "utf-8");
       const data = JSON.parse(content);
       const email3 = data.oauthAccount?.emailAddress;
       if (typeof email3 !== "string" || email3.length === 0) {
@@ -64877,7 +65144,7 @@ var init_TotalSpeed = __esm(async () => {
 
 // src/widgets/FreeMemory.ts
 import { execSync as execSync3 } from "child_process";
-import os7 from "os";
+import os8 from "os";
 function formatBytes(bytes) {
   const GB = 1024 ** 3;
   const MB = 1024 ** 2;
@@ -64892,7 +65159,7 @@ function formatBytes(bytes) {
 }
 function getUsedMemoryMacOS() {
   try {
-    const output = execSync3("vm_stat", { encoding: "utf8" });
+    const output = execSync3("vm_stat", { encoding: "utf8", windowsHide: true });
     const lines = output.split(`
 `);
     const firstLine = lines[0];
@@ -64941,12 +65208,12 @@ class FreeMemoryWidget {
     if (context.isPreview) {
       return item.rawValue ? "12.4G/16.0G" : "Mem: 12.4G/16.0G";
     }
-    const total = os7.totalmem();
+    const total = os8.totalmem();
     let used;
-    if (os7.platform() === "darwin") {
-      used = getUsedMemoryMacOS() ?? total - os7.freemem();
+    if (os8.platform() === "darwin") {
+      used = getUsedMemoryMacOS() ?? total - os8.freemem();
     } else {
-      used = total - os7.freemem();
+      used = total - os8.freemem();
     }
     const value = `${formatBytes(used)}/${formatBytes(total)}`;
     return item.rawValue ? value : `Mem: ${value}`;
@@ -64961,7 +65228,7 @@ class FreeMemoryWidget {
 var init_FreeMemory = () => {};
 
 // src/widgets/SessionName.ts
-import * as fs9 from "fs";
+import * as fs10 from "fs";
 
 class SessionNameWidget {
   getDefaultColor() {
@@ -64988,7 +65255,7 @@ class SessionNameWidget {
       return null;
     }
     try {
-      const content = fs9.readFileSync(transcriptPath, "utf-8");
+      const content = fs10.readFileSync(transcriptPath, "utf-8");
       const lines = content.split(`
 `);
       for (let i = lines.length - 1;i >= 0; i--) {
@@ -65552,9 +65819,9 @@ class SessionUsageWidget {
       return null;
     const extraUsed = data.extraUsageUsed;
     const extraLimit = data.extraUsageLimit;
-    if (size2 !== "mobile" && data.extraUsageEnabled === true && extraUsed !== undefined && extraLimit !== undefined && data.sessionUsage >= 100 && (data.weeklyUsage === undefined || data.weeklyUsage < 100)) {
+    if (data.extraUsageEnabled === true && extraUsed !== undefined && extraLimit !== undefined && data.sessionUsage >= 100 && (data.weeklyUsage === undefined || data.weeklyUsage < 100)) {
       const extraPercent = computeExtraPercent(extraUsed, extraLimit);
-      return formatSplitUsageBar("Session", "S", extraPercent, size2);
+      return formatSplitUsageBar("Session", "S", extraPercent, size2, extraUsed, extraLimit);
     }
     return formatUsageBar("Session", "S", data.sessionUsage, size2);
   }
@@ -65728,6 +65995,9 @@ class ContextBarWidget {
       const u = cw.current_usage;
       used = (Number(u.input_tokens) || 0) + (Number(u.output_tokens) || 0) + (Number(u.cache_creation_input_tokens) || 0) + (Number(u.cache_read_input_tokens) || 0);
     }
+    if (used === 0 && context.tokenMetrics && context.tokenMetrics.contextLength > 0) {
+      used = context.tokenMetrics.contextLength;
+    }
     if (isNaN(total) || isNaN(used))
       return null;
     const percent = total > 0 ? used / total * 100 : 0;
@@ -65746,7 +66016,7 @@ class ContextBarWidget {
     return true;
   }
 }
-var DARK_RED_OPEN2 = "\x1B[38;2;204;0;0m", DARK_RED_CLOSE2 = "\x1B[39m", MOBILE_THRESHOLD = 134, MEDIUM_THRESHOLD2 = 178, MOBILE_BAR_WIDTH = 4, MEDIUM_BAR_WIDTH = 8, DEFAULT_BAR_WIDTH = 15;
+var DARK_RED_OPEN2 = "\x1B[38;2;204;0;0m", DARK_RED_CLOSE2 = "\x1B[39m", MOBILE_THRESHOLD = 134, MEDIUM_THRESHOLD2 = 178, MOBILE_BAR_WIDTH = 4, MEDIUM_BAR_WIDTH = 8, DEFAULT_BAR_WIDTH = 16;
 var init_ApiUsage = __esm(async () => {
   init_model_context2();
   init_usage_display();
@@ -65758,6 +66028,37 @@ var init_ApiUsage = __esm(async () => {
   ]);
 });
 
+// src/widgets/shared/extra-usage-disabled.ts
+function isHideExtraUsageDisabledEnabled(item) {
+  return isMetadataFlagEnabled(item, HIDE_DISABLED_KEY);
+}
+function handleToggleExtraUsageDisabledAction(action, item) {
+  if (action !== TOGGLE_HIDE_DISABLED_ACTION) {
+    return null;
+  }
+  return toggleMetadataFlag(item, HIDE_DISABLED_KEY);
+}
+function getHideExtraUsageDisabledKeybind() {
+  return HIDE_DISABLED_KEYBIND;
+}
+function appendHideDisabledModifier(modifierText, item) {
+  if (!isHideExtraUsageDisabledEnabled(item)) {
+    return modifierText;
+  }
+  if (!modifierText) {
+    return "(hide if disabled)";
+  }
+  return `${modifierText.slice(0, -1)}, hide if disabled)`;
+}
+var HIDE_DISABLED_KEY = "hideIfDisabled", TOGGLE_HIDE_DISABLED_ACTION = "toggle-hide-disabled", HIDE_DISABLED_KEYBIND;
+var init_extra_usage_disabled = __esm(() => {
+  HIDE_DISABLED_KEYBIND = {
+    key: "h",
+    label: "(h)ide if disabled",
+    action: TOGGLE_HIDE_DISABLED_ACTION
+  };
+});
+
 // src/widgets/shared/progress-bar.ts
 function makeTimerProgressBar2(percent, width, options) {
   const clampedPercent = Math.max(0, Math.min(100, percent));
@@ -65776,16 +66077,16 @@ function makeTimerProgressBar2(percent, width, options) {
   return bar;
 }
 
-// src/widgets/WeeklySonnetUsage.ts
-class WeeklySonnetUsageWidget {
+// src/widgets/ExtraUsageUtilization.ts
+class ExtraUsageUtilizationWidget {
   getDefaultColor() {
-    return "brightBlue";
+    return "green";
   }
   getDescription() {
-    return "Shows weekly Sonnet API usage percentage";
+    return "Shows extra usage (pay-as-you-go) utilization percentage";
   }
   getDisplayName() {
-    return "Weekly Sonnet Usage";
+    return "Extra Usage Utilization";
   }
   getCategory() {
     return "Usage";
@@ -65793,70 +66094,65 @@ class WeeklySonnetUsageWidget {
   getEditorDisplay(item) {
     return {
       displayText: this.getDisplayName(),
-      modifierText: getUsageDisplayModifierText(item)
+      modifierText: appendHideDisabledModifier(getUsageDisplayModifierText(item), item)
     };
   }
   handleEditorAction(action, item) {
+    const hideDisabledItem = handleToggleExtraUsageDisabledAction(action, item);
+    if (hideDisabledItem) {
+      return hideDisabledItem;
+    }
     if (action === "toggle-progress") {
       return cycleUsageDisplayMode(item, [], true);
     }
     if (action === "toggle-invert") {
       return toggleUsageInverted(item);
     }
-    if (action === "toggle-cursor") {
-      return toggleUsageCursor(item);
-    }
     return null;
   }
   render(item, context, settings) {
     const displayMode = getUsageDisplayMode(item);
     const inverted = isUsageInverted(item);
-    const showCursor = isUsageCursorEnabled(item);
     if (context.isPreview) {
-      const previewPercent = 8;
+      const previewPercent = 2.6;
       const renderedPercent2 = inverted ? 100 - previewPercent : previewPercent;
       if (isUsageProgressMode(displayMode)) {
         const width = getUsageProgressBarWidth(displayMode);
-        const progressBar = makeTimerProgressBar2(renderedPercent2, width, showCursor ? { cursorPercent: 50 } : undefined);
-        const progressDisplay = `[${progressBar}] ${renderedPercent2.toFixed(1)}%`;
-        return formatRawOrLabeledValue(item, LABEL, progressDisplay);
+        const progressBar = makeTimerProgressBar2(renderedPercent2, width);
+        return formatRawOrLabeledValue(item, "Overage: ", `[${progressBar}] ${renderedPercent2.toFixed(1)}%`);
       }
       if (isUsageSliderMode(displayMode)) {
-        const slider = makeSliderBar(renderedPercent2, undefined, showCursor ? { cursorPercent: 50 } : undefined);
+        const slider = makeSliderBar(renderedPercent2);
         const sliderDisplay = displayMode === "slider" ? `${slider} ${renderedPercent2.toFixed(1)}%` : slider;
-        return formatRawOrLabeledValue(item, LABEL, sliderDisplay);
+        return formatRawOrLabeledValue(item, "Overage: ", sliderDisplay);
       }
-      return formatRawOrLabeledValue(item, LABEL, `${previewPercent.toFixed(1)}%`);
+      return formatRawOrLabeledValue(item, "Overage: ", `${previewPercent.toFixed(1)}%`);
     }
     const data = context.usageData ?? {};
-    if (data.error)
-      return getUsageErrorMessage(data.error);
-    if (data.weeklySonnetUsage === undefined)
+    if (data.extraUsageEnabled === false) {
+      return isHideExtraUsageDisabledEnabled(item) ? null : formatRawOrLabeledValue(item, "Overage: ", "n/a");
+    }
+    if (data.extraUsageEnabled !== true || data.extraUsageUtilization === undefined) {
+      if (data.error)
+        return getUsageErrorMessage(data.error);
       return null;
-    const percent = Math.max(0, Math.min(100, data.weeklySonnetUsage));
+    }
+    const percent = Math.max(0, Math.min(100, data.extraUsageUtilization));
     const renderedPercent = inverted ? 100 - percent : percent;
-    const getCursorOptions = () => {
-      if (!showCursor) {
-        return;
-      }
-      const window2 = resolveWeeklySonnetUsageWindow(data);
-      return window2 ? { cursorPercent: window2.elapsedPercent } : undefined;
-    };
     if (isUsageProgressMode(displayMode)) {
       const width = getUsageProgressBarWidth(displayMode);
-      const progressBar = makeTimerProgressBar2(renderedPercent, width, getCursorOptions());
-      const progressDisplay = `[${progressBar}] ${renderedPercent.toFixed(1)}%`;
-      return formatRawOrLabeledValue(item, LABEL, progressDisplay);
+      const progressBar = makeTimerProgressBar2(renderedPercent, width);
+      return formatRawOrLabeledValue(item, "Overage: ", `[${progressBar}] ${renderedPercent.toFixed(1)}%`);
     }
     if (isUsageSliderMode(displayMode)) {
-      const slider = makeSliderBar(renderedPercent, undefined, getCursorOptions());
+      const slider = makeSliderBar(renderedPercent);
       const sliderDisplay = displayMode === "slider" ? `${slider} ${renderedPercent.toFixed(1)}%` : slider;
-      return formatRawOrLabeledValue(item, LABEL, sliderDisplay);
+      return formatRawOrLabeledValue(item, "Overage: ", sliderDisplay);
     }
-    return formatRawOrLabeledValue(item, LABEL, `${percent.toFixed(1)}%`);
+    return formatRawOrLabeledValue(item, "Overage: ", `${percent.toFixed(1)}%`);
   }
   getCustomKeybinds(item) {
-    return getUsagePercentCustomKeybinds(item);
+    return [...getUsagePercentCustomKeybinds(item), getHideExtraUsageDisabledKeybind()];
   }
   supportsRawValue() {
     return true;
@@ -65865,22 +66161,79 @@ class WeeklySonnetUsageWidget {
     return true;
   }
 }
-var LABEL = "Weekly Sonnet: ";
-var init_WeeklySonnetUsage = __esm(async () => {
+var init_ExtraUsageUtilization = __esm(async () => {
+  init_extra_usage_disabled();
   init_usage_display();
   await init_usage();
 });
 
-// src/widgets/WeeklyOpusUsage.ts
-class WeeklyOpusUsageWidget {
+// src/widgets/ExtraUsageRemaining.ts
+class ExtraUsageRemainingWidget {
+  getDefaultColor() {
+    return "green";
+  }
+  getDescription() {
+    return "Shows remaining USD of your monthly extra usage limit";
+  }
+  getDisplayName() {
+    return "Extra Usage Remaining";
+  }
+  getCategory() {
+    return "Usage";
+  }
+  getEditorDisplay(item) {
+    return {
+      displayText: this.getDisplayName(),
+      modifierText: appendHideDisabledModifier(undefined, item)
+    };
+  }
+  handleEditorAction(action, item) {
+    return handleToggleExtraUsageDisabledAction(action, item);
+  }
+  render(item, context, settings) {
+    if (context.isPreview) {
+      return formatRawOrLabeledValue(item, "Overage Left: ", "$3,894.00");
+    }
+    const data = context.usageData ?? {};
+    if (data.extraUsageEnabled === false) {
+      return isHideExtraUsageDisabledEnabled(item) ? null : formatRawOrLabeledValue(item, "Overage Left: ", "n/a");
+    }
+    if (data.extraUsageEnabled !== true || data.extraUsageLimit === undefined || data.extraUsageUsed === undefined) {
+      if (data.error)
+        return getUsageErrorMessage(data.error);
+      return null;
+    }
+    const limitDollars = data.extraUsageLimit / 100;
+    const usedDollars = data.extraUsageUsed / 100;
+    const remaining = Math.max(0, limitDollars - usedDollars);
+    const formatted = `$${remaining.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+    return formatRawOrLabeledValue(item, "Overage Left: ", formatted);
+  }
+  getCustomKeybinds() {
+    return [getHideExtraUsageDisabledKeybind()];
+  }
+  supportsRawValue() {
+    return true;
+  }
+  supportsColors(item) {
+    return true;
+  }
+}
+var init_ExtraUsageRemaining = __esm(async () => {
+  init_extra_usage_disabled();
+  await init_usage();
+});
+
+// src/widgets/WeeklySonnetUsage.ts
+class WeeklySonnetUsageWidget {
   getDefaultColor() {
     return "brightBlue";
   }
   getDescription() {
-    return "Shows weekly Opus API usage percentage";
+    return "Shows weekly Sonnet API usage percentage";
   }
   getDisplayName() {
-    return "Weekly Opus Usage";
+    return "Weekly Sonnet Usage";
   }
   getCategory() {
     return "Usage";
@@ -65908,27 +66261,124 @@ class WeeklyOpusUsageWidget {
     const inverted = isUsageInverted(item);
     const showCursor = isUsageCursorEnabled(item);
     if (context.isPreview) {
-      const previewPercent = 4;
+      const previewPercent = 8;
       const renderedPercent2 = inverted ? 100 - previewPercent : previewPercent;
       if (isUsageProgressMode(displayMode)) {
         const width = getUsageProgressBarWidth(displayMode);
         const progressBar = makeTimerProgressBar2(renderedPercent2, width, showCursor ? { cursorPercent: 50 } : undefined);
         const progressDisplay = `[${progressBar}] ${renderedPercent2.toFixed(1)}%`;
-        return formatRawOrLabeledValue(item, LABEL2, progressDisplay);
+        return formatRawOrLabeledValue(item, LABEL, progressDisplay);
       }
       if (isUsageSliderMode(displayMode)) {
         const slider = makeSliderBar(renderedPercent2, undefined, showCursor ? { cursorPercent: 50 } : undefined);
         const sliderDisplay = displayMode === "slider" ? `${slider} ${renderedPercent2.toFixed(1)}%` : slider;
-        return formatRawOrLabeledValue(item, LABEL2, sliderDisplay);
+        return formatRawOrLabeledValue(item, LABEL, sliderDisplay);
       }
-      return formatRawOrLabeledValue(item, LABEL2, `${previewPercent.toFixed(1)}%`);
+      return formatRawOrLabeledValue(item, LABEL, `${previewPercent.toFixed(1)}%`);
     }
     const data = context.usageData ?? {};
-    if (data.error)
-      return getUsageErrorMessage(data.error);
-    if (data.weeklyOpusUsage === undefined)
+    if (data.weeklySonnetUsage === undefined) {
+      if (data.error)
+        return getUsageErrorMessage(data.error);
       return null;
-    const percent = Math.max(0, Math.min(100, data.weeklyOpusUsage));
+    }
+    const percent = Math.max(0, Math.min(100, data.weeklySonnetUsage));
+    const renderedPercent = inverted ? 100 - percent : percent;
+    const getCursorOptions = () => {
+      if (!showCursor) {
+        return;
+      }
+      const window2 = resolveWeeklySonnetUsageWindow(data);
+      return window2 ? { cursorPercent: window2.elapsedPercent } : undefined;
+    };
+    if (isUsageProgressMode(displayMode)) {
+      const width = getUsageProgressBarWidth(displayMode);
+      const progressBar = makeTimerProgressBar2(renderedPercent, width, getCursorOptions());
+      const progressDisplay = `[${progressBar}] ${renderedPercent.toFixed(1)}%`;
+      return formatRawOrLabeledValue(item, LABEL, progressDisplay);
+    }
+    if (isUsageSliderMode(displayMode)) {
+      const slider = makeSliderBar(renderedPercent, undefined, getCursorOptions());
+      const sliderDisplay = displayMode === "slider" ? `${slider} ${renderedPercent.toFixed(1)}%` : slider;
+      return formatRawOrLabeledValue(item, LABEL, sliderDisplay);
+    }
+    return formatRawOrLabeledValue(item, LABEL, `${percent.toFixed(1)}%`);
+  }
+  getCustomKeybinds(item) {
+    return getUsagePercentCustomKeybinds(item);
+  }
+  supportsRawValue() {
+    return true;
+  }
+  supportsColors(item) {
+    return true;
+  }
+}
+var LABEL = "Weekly Sonnet: ";
+var init_WeeklySonnetUsage = __esm(async () => {
+  init_usage_display();
+  await init_usage();
+});
+
+// src/widgets/WeeklyOpusUsage.ts
+class WeeklyOpusUsageWidget {
+  getDefaultColor() {
+    return "brightBlue";
+  }
+  getDescription() {
+    return "Shows weekly Opus API usage percentage";
+  }
+  getDisplayName() {
+    return "Weekly Opus Usage";
+  }
+  getCategory() {
+    return "Usage";
+  }
+  getEditorDisplay(item) {
+    return {
+      displayText: this.getDisplayName(),
+      modifierText: getUsageDisplayModifierText(item)
+    };
+  }
+  handleEditorAction(action, item) {
+    if (action === "toggle-progress") {
+      return cycleUsageDisplayMode(item, [], true);
+    }
+    if (action === "toggle-invert") {
+      return toggleUsageInverted(item);
+    }
+    if (action === "toggle-cursor") {
+      return toggleUsageCursor(item);
+    }
+    return null;
+  }
+  render(item, context, settings) {
+    const displayMode = getUsageDisplayMode(item);
+    const inverted = isUsageInverted(item);
+    const showCursor = isUsageCursorEnabled(item);
+    if (context.isPreview) {
+      const previewPercent = 4;
+      const renderedPercent2 = inverted ? 100 - previewPercent : previewPercent;
+      if (isUsageProgressMode(displayMode)) {
+        const width = getUsageProgressBarWidth(displayMode);
+        const progressBar = makeTimerProgressBar2(renderedPercent2, width, showCursor ? { cursorPercent: 50 } : undefined);
+        const progressDisplay = `[${progressBar}] ${renderedPercent2.toFixed(1)}%`;
+        return formatRawOrLabeledValue(item, LABEL2, progressDisplay);
+      }
+      if (isUsageSliderMode(displayMode)) {
+        const slider = makeSliderBar(renderedPercent2, undefined, showCursor ? { cursorPercent: 50 } : undefined);
+        const sliderDisplay = displayMode === "slider" ? `${slider} ${renderedPercent2.toFixed(1)}%` : slider;
+        return formatRawOrLabeledValue(item, LABEL2, sliderDisplay);
+      }
+      return formatRawOrLabeledValue(item, LABEL2, `${previewPercent.toFixed(1)}%`);
+    }
+    const data = context.usageData ?? {};
+    if (data.weeklyOpusUsage === undefined) {
+      if (data.error)
+        return getUsageErrorMessage(data.error);
+      return null;
+    }
+    const percent = Math.max(0, Math.min(100, data.weeklyOpusUsage));
     const renderedPercent = inverted ? 100 - percent : percent;
     const getCursorOptions = () => {
       if (!showCursor) {
@@ -66005,6 +66455,9 @@ function getWeeklyResetModifierText(item) {
       if (isUsage12HourClock(item)) {
         modifiers.push("12hr");
       }
+      if (isUsageWeekdayEnabled(item)) {
+        modifiers.push("weekday");
+      }
     } else if (isWeeklyResetHoursOnly(item)) {
       modifiers.push("hours only");
     }
@@ -66055,6 +66508,9 @@ class WeeklyResetTimerWidget {
     if (action === "toggle-hour-format") {
       return toggleUsageHourFormat(item);
     }
+    if (action === "toggle-weekday") {
+      return toggleUsageWeekday(item);
+    }
     if (action === "toggle-hours") {
       return toggleWeeklyResetHoursOnly(item);
     }
@@ -66079,8 +66535,10 @@ class WeeklyResetTimerWidget {
         return formatRawOrLabeledValue(item, "Weekly Reset ", sliderDisplay);
       }
       if (dateMode) {
-        const resetAt = formatUsageResetAt(WEEKLY_RESET_PREVIEW_AT, compact2, getUsageTimezone(item), getUsageLocale(item), isUsage12HourClock(item));
-        return formatRawOrLabeledValue(item, "Weekly Reset: ", resetAt ?? (compact2 ? "03-15 08:30Z" : "2026-03-15 08:30 UTC"));
+        const weekday = isUsageWeekdayEnabled(item);
+        const resetAt = formatUsageResetAt(WEEKLY_RESET_PREVIEW_AT, compact2, getUsageTimezone(item), getUsageLocale(item), isUsage12HourClock(item), weekday);
+        const fallback = weekday ? compact2 ? "Sun 08:30Z" : "Sun 08:30 UTC" : compact2 ? "03-15 08:30Z" : "2026-03-15 08:30 UTC";
+        return formatRawOrLabeledValue(item, "Weekly Reset: ", resetAt ?? fallback);
       }
       return formatRawOrLabeledValue(item, "Weekly Reset: ", formatUsageDuration(WEEKLY_PREVIEW_DURATION_MS, compact2, useDays));
     }
@@ -66108,7 +66566,7 @@ class WeeklyResetTimerWidget {
     if (dateMode) {
       const timezone = getUsageTimezone(item);
       const locale = getUsageLocale(item);
-      const resetAt = formatUsageResetAt(usageData.weeklyResetAt, compact2, timezone, locale, isUsage12HourClock(item));
+      const resetAt = formatUsageResetAt(usageData.weeklyResetAt, compact2, timezone, locale, isUsage12HourClock(item), isUsageWeekdayEnabled(item));
       if (resetAt) {
         return formatRawOrLabeledValue(item, "Weekly Reset: ", resetAt);
       }
@@ -66120,6 +66578,7 @@ class WeeklyResetTimerWidget {
     const keybinds = getUsageTimerCustomKeybinds(item, {
       includeDate: true,
       includeHourFormat: true,
+      includeWeekday: true,
       includeLocale: true,
       includeTimezone: true
     });
@@ -66620,7 +67079,7 @@ var init_ThinkingEffort = __esm(async () => {
 
 // src/widgets/Battery.ts
 import { execSync as execSync4 } from "child_process";
-import { readFileSync as readFileSync11 } from "fs";
+import { readFileSync as readFileSync12 } from "fs";
 function getMacBatteryInfo() {
   try {
     const output = execSync4("pmset -g batt", { encoding: "utf-8", timeout: 2000 });
@@ -66640,8 +67099,8 @@ function getMacBatteryInfo() {
 }
 function getLinuxBatteryInfo() {
   try {
-    const capacity = readFileSync11("/sys/class/power_supply/BAT0/capacity", "utf-8").trim();
-    const status = readFileSync11("/sys/class/power_supply/BAT0/status", "utf-8").trim().toLowerCase();
+    const capacity = readFileSync12("/sys/class/power_supply/BAT0/capacity", "utf-8").trim();
+    const status = readFileSync12("/sys/class/power_supply/BAT0/status", "utf-8").trim().toLowerCase();
     const percent = parseInt(capacity, 10);
     if (isNaN(percent)) {
       return null;
@@ -67570,6 +68029,137 @@ var init_VoiceStatus = __esm(async () => {
   FORMATS3 = ["icon", "icon-text", "text", "word"];
 });
 
+// src/widgets/RemoteControlStatus.ts
+function getFormat4(item) {
+  const f = item.metadata?.format;
+  return FORMATS4.includes(f ?? "") ? f : DEFAULT_FORMAT4;
+}
+function setFormat4(item, format) {
+  if (format === DEFAULT_FORMAT4) {
+    const { format: removedFormat, ...restMetadata } = item.metadata ?? {};
+    return {
+      ...item,
+      metadata: Object.keys(restMetadata).length > 0 ? restMetadata : undefined
+    };
+  }
+  return {
+    ...item,
+    metadata: {
+      ...item.metadata ?? {},
+      format
+    }
+  };
+}
+function isNerdFontEnabled4(item) {
+  return item.metadata?.[NERD_FONT_METADATA_KEY4] === "true";
+}
+function toggleNerdFont4(item) {
+  if (!isNerdFontEnabled4(item)) {
+    return {
+      ...item,
+      metadata: {
+        ...item.metadata ?? {},
+        [NERD_FONT_METADATA_KEY4]: "true"
+      }
+    };
+  }
+  const { [NERD_FONT_METADATA_KEY4]: removedNerdFont, ...restMetadata } = item.metadata ?? {};
+  return {
+    ...item,
+    metadata: Object.keys(restMetadata).length > 0 ? restMetadata : undefined
+  };
+}
+function formatStatus2(enabled, format, nerdFont) {
+  const stateText = enabled ? "on" : "off";
+  const stateDot = enabled ? STATE_DOT_ON2 : STATE_DOT_OFF2;
+  const icon = nerdFont ? enabled ? SATELLITE_NERD_FONT : SATELLITE_SLASH_NERD_FONT : SATELLITE_EMOJI;
+  switch (format) {
+    case "icon":
+      return nerdFont ? icon : `${icon} ${stateDot}`;
+    case "icon-text":
+      return `${icon} ${stateText}`;
+    case "text":
+      return stateText;
+    case "word":
+      return `remote ${stateText}`;
+    case "label-check":
+      return `remote ${enabled ? CHECK_EMOJI : CROSS_EMOJI}`;
+    case "label-mark":
+      return `remote ${enabled ? CHECK_MARK : CROSS_MARK}`;
+  }
+}
+
+class RemoteControlStatusWidget {
+  getDefaultColor() {
+    return "blue";
+  }
+  getDescription() {
+    return "Shows whether Claude Code remote control is attached to the current session";
+  }
+  getDisplayName() {
+    return "Remote Control Status";
+  }
+  getCategory() {
+    return "Core";
+  }
+  getEditorDisplay(item) {
+    const modifiers = [getFormat4(item)];
+    if (isNerdFontEnabled4(item)) {
+      modifiers.push("nerd font");
+    }
+    return {
+      displayText: this.getDisplayName(),
+      modifierText: `(${modifiers.join(", ")})`
+    };
+  }
+  handleEditorAction(action, item) {
+    if (action === CYCLE_FORMAT_ACTION4) {
+      const currentFormat = getFormat4(item);
+      const nextFormat = FORMATS4[(FORMATS4.indexOf(currentFormat) + 1) % FORMATS4.length] ?? DEFAULT_FORMAT4;
+      return setFormat4(item, nextFormat);
+    }
+    if (action === TOGGLE_NERD_FONT_ACTION4) {
+      return toggleNerdFont4(item);
+    }
+    return null;
+  }
+  render(item, context, _settings) {
+    const format = getFormat4(item);
+    const nerdFont = isNerdFontEnabled4(item);
+    if (context.isPreview) {
+      if (item.rawValue) {
+        return "on";
+      }
+      return formatStatus2(true, format, nerdFont);
+    }
+    const status = getRemoteControlStatus(context.data?.session_id);
+    if (status === null) {
+      return null;
+    }
+    if (item.rawValue) {
+      return status.enabled ? "on" : "off";
+    }
+    return formatStatus2(status.enabled, format, nerdFont);
+  }
+  getCustomKeybinds() {
+    return [
+      { key: "f", label: "(f)ormat", action: CYCLE_FORMAT_ACTION4 },
+      { key: "n", label: "(n)erd font", action: TOGGLE_NERD_FONT_ACTION4 }
+    ];
+  }
+  supportsRawValue() {
+    return true;
+  }
+  supportsColors(_item) {
+    return true;
+  }
+}
+var SATELLITE_EMOJI = "\uD83D\uDCE1", SATELLITE_NERD_FONT = "", SATELLITE_SLASH_NERD_FONT = "", STATE_DOT_OFF2 = "○", STATE_DOT_ON2 = "◉", FORMATS4, CHECK_EMOJI = "✅", CROSS_EMOJI = "❌", CHECK_MARK = "✓", CROSS_MARK = "✗", DEFAULT_FORMAT4 = "icon", CYCLE_FORMAT_ACTION4 = "cycle-format", TOGGLE_NERD_FONT_ACTION4 = "toggle-nerd-font", NERD_FONT_METADATA_KEY4 = "nerdFont";
+var init_RemoteControlStatus = __esm(async () => {
+  await init_claude_settings();
+  FORMATS4 = ["icon", "icon-text", "text", "word", "label-check", "label-mark"];
+});
+
 // src/widgets/index.ts
 var init_widgets = __esm(async () => {
   init_GitBranch();
@@ -67630,6 +68220,8 @@ var init_widgets = __esm(async () => {
     init_OutputSpeed(),
     init_TotalSpeed(),
     init_ApiUsage(),
+    init_ExtraUsageUtilization(),
+    init_ExtraUsageRemaining(),
     init_WeeklySonnetUsage(),
     init_WeeklyOpusUsage(),
     init_WeeklyResetTimer(),
@@ -67637,7 +68229,8 @@ var init_widgets = __esm(async () => {
     init_Skills(),
     init_ThinkingEffort(),
     init_WeeklyPace(),
-    init_VoiceStatus()
+    init_VoiceStatus(),
+    init_RemoteControlStatus()
   ]);
 });
 
@@ -67709,6 +68302,8 @@ var init_widget_manifest = __esm(async () => {
     { type: "session-usage", create: () => new SessionUsageWidget },
     { type: "weekly-usage", create: () => new WeeklyUsageWidget },
     { type: "reset-timer", create: () => new ResetTimerWidget },
+    { type: "extra-usage-utilization", create: () => new ExtraUsageUtilizationWidget },
+    { type: "extra-usage-remaining", create: () => new ExtraUsageRemainingWidget },
     { type: "weekly-sonnet-usage", create: () => new WeeklySonnetUsageWidget },
     { type: "weekly-opus-usage", create: () => new WeeklyOpusUsageWidget },
     { type: "weekly-reset-timer", create: () => new WeeklyResetTimerWidget },
@@ -67720,6 +68315,7 @@ var init_widget_manifest = __esm(async () => {
     { type: "weekly-pace", create: () => new WeeklyPaceWidget },
     { type: "off-peak", create: () => new OffPeakWidget },
     { type: "voice-status", create: () => new VoiceStatusWidget },
+    { type: "remote-control-status", create: () => new RemoteControlStatusWidget },
     { type: "worktree-mode", create: () => new GitWorktreeModeWidget },
     { type: "worktree-name", create: () => new GitWorktreeNameWidget },
     { type: "worktree-branch", create: () => new GitWorktreeBranchWidget },
@@ -67904,11 +68500,11 @@ var init_hooks = __esm(async () => {
 });
 
 // src/utils/config.ts
-import * as fs10 from "fs";
-import * as os8 from "os";
-import * as path7 from "path";
+import * as fs11 from "fs";
+import * as os9 from "os";
+import * as path8 from "path";
 function initConfigPath(filePath) {
-  settingsPath = filePath ? path7.resolve(filePath) : DEFAULT_SETTINGS_PATH;
+  settingsPath = filePath ? path8.resolve(filePath) : DEFAULT_SETTINGS_PATH;
 }
 function getConfigPath() {
   return settingsPath;
@@ -67917,13 +68513,13 @@ function isCustomConfigPath() {
   return settingsPath !== DEFAULT_SETTINGS_PATH;
 }
 function getSettingsPaths() {
-  const configDir = path7.dirname(settingsPath);
-  const parsedPath = path7.parse(settingsPath);
+  const configDir = path8.dirname(settingsPath);
+  const parsedPath = path8.parse(settingsPath);
   const backupBaseName = parsedPath.ext ? `${parsedPath.name}.bak` : `${parsedPath.base}.bak`;
   return {
     configDir,
     settingsPath,
-    settingsBackupPath: path7.join(configDir, backupBaseName)
+    settingsBackupPath: path8.join(configDir, backupBaseName)
   };
 }
 async function ensureDir(dir) {
@@ -67940,7 +68536,7 @@ async function writeSettingsJson(settings, paths) {
 }
 async function backupBadSettings(paths) {
   try {
-    if (fs10.existsSync(paths.settingsPath)) {
+    if (fs11.existsSync(paths.settingsPath)) {
       const content = await readFile3(paths.settingsPath, "utf-8");
       await writeFile(paths.settingsBackupPath, content, "utf-8");
       console.error(`Bad settings backed up to ${paths.settingsBackupPath}`);
@@ -67970,7 +68566,7 @@ async function recoverWithDefaults(paths) {
 async function loadSettings() {
   const paths = getSettingsPaths();
   try {
-    if (!fs10.existsSync(paths.settingsPath))
+    if (!fs11.existsSync(paths.settingsPath))
       return await writeDefaultSettings(paths);
     const content = await readFile3(paths.settingsPath, "utf-8");
     let rawData;
@@ -68021,7 +68617,7 @@ async function saveSettings(settings) {
 }
 async function saveInstallationMetadata(metadata) {
   const paths = getSettingsPaths();
-  if (!metadata && !fs10.existsSync(paths.settingsPath)) {
+  if (!metadata && !fs11.existsSync(paths.settingsPath)) {
     return;
   }
   const settings = await loadSettings();
@@ -68041,18 +68637,18 @@ var init_config = __esm(async () => {
   init_Settings();
   init_migrations();
   await init_widgets2();
-  readFile3 = fs10.promises.readFile;
-  writeFile = fs10.promises.writeFile;
-  mkdir = fs10.promises.mkdir;
-  DEFAULT_SETTINGS_PATH = path7.join(os8.homedir(), ".config", "ccstatusline", "settings.json");
+  readFile3 = fs11.promises.readFile;
+  writeFile = fs11.promises.writeFile;
+  mkdir = fs11.promises.mkdir;
+  DEFAULT_SETTINGS_PATH = path8.join(os9.homedir(), ".config", "ccstatusline", "settings.json");
   settingsPath = DEFAULT_SETTINGS_PATH;
 });
 
 // src/utils/claude-settings.ts
 import { execSync as execSync5 } from "child_process";
-import * as fs11 from "fs";
-import * as os9 from "os";
-import * as path8 from "path";
+import * as fs12 from "fs";
+import * as os10 from "os";
+import * as path9 from "path";
 function isKnownCommand(command) {
   const prefixes = [CCSTATUSLINE_COMMANDS.AUTO_NPX, CCSTATUSLINE_COMMANDS.AUTO_BUNX, CCSTATUSLINE_COMMANDS.GLOBAL];
   return prefixes.some((prefix) => command === prefix || command.startsWith(`${prefix} --config `)) || /(?:^|[\s"'\\/])ccstatusline\.ts(?=$|[\s"'])/.test(command);
@@ -68076,9 +68672,9 @@ function getClaudeConfigDir() {
   const envConfigDir = process.env.CLAUDE_CONFIG_DIR;
   if (envConfigDir) {
     try {
-      const resolvedPath = path8.resolve(envConfigDir);
-      if (fs11.existsSync(resolvedPath)) {
-        const stats = fs11.statSync(resolvedPath);
+      const resolvedPath = path9.resolve(envConfigDir);
+      if (fs12.existsSync(resolvedPath)) {
+        const stats = fs12.statSync(resolvedPath);
         if (stats.isDirectory()) {
           return resolvedPath;
         }
@@ -68087,24 +68683,24 @@ function getClaudeConfigDir() {
       }
     } catch {}
   }
-  return path8.join(os9.homedir(), ".claude");
+  return path9.join(os10.homedir(), ".claude");
 }
 function getClaudeJsonPath() {
   const configDir = getClaudeConfigDir();
   const envConfigDir = process.env.CLAUDE_CONFIG_DIR;
-  if (envConfigDir && configDir === path8.resolve(envConfigDir)) {
-    return path8.join(configDir, ".claude.json");
+  if (envConfigDir && configDir === path9.resolve(envConfigDir)) {
+    return path9.join(configDir, ".claude.json");
   }
-  return path8.join(path8.dirname(configDir), ".claude.json");
+  return path9.join(path9.dirname(configDir), ".claude.json");
 }
 function getClaudeSettingsPath() {
-  return path8.join(getClaudeConfigDir(), "settings.json");
+  return path9.join(getClaudeConfigDir(), "settings.json");
 }
 async function backupClaudeSettings(suffix = ".bak") {
   const settingsPath2 = getClaudeSettingsPath();
   const backupPath = settingsPath2 + suffix;
   try {
-    if (fs11.existsSync(settingsPath2)) {
+    if (fs12.existsSync(settingsPath2)) {
       const content = await readFile4(settingsPath2, "utf-8");
       await writeFile2(backupPath, content, "utf-8");
       return backupPath;
@@ -68117,11 +68713,11 @@ async function backupClaudeSettings(suffix = ".bak") {
 function loadClaudeSettingsSync(options = {}) {
   const { logErrors = true } = options;
   const settingsPath2 = getClaudeSettingsPath();
-  if (!fs11.existsSync(settingsPath2)) {
+  if (!fs12.existsSync(settingsPath2)) {
     return {};
   }
   try {
-    const content = fs11.readFileSync(settingsPath2, "utf-8");
+    const content = fs12.readFileSync(settingsPath2, "utf-8");
     return JSON.parse(content);
   } catch (error48) {
     if (logErrors) {
@@ -68133,7 +68729,7 @@ function loadClaudeSettingsSync(options = {}) {
 async function loadClaudeSettings(options = {}) {
   const { logErrors = true } = options;
   const settingsPath2 = getClaudeSettingsPath();
-  if (!fs11.existsSync(settingsPath2)) {
+  if (!fs12.existsSync(settingsPath2)) {
     return {};
   }
   try {
@@ -68148,7 +68744,7 @@ async function loadClaudeSettings(options = {}) {
 }
 async function saveClaudeSettings(settings) {
   const settingsPath2 = getClaudeSettingsPath();
-  const dir = path8.dirname(settingsPath2);
+  const dir = path9.dirname(settingsPath2);
   await backupClaudeSettings();
   await ensureDir(dir);
   await writeFile2(settingsPath2, JSON.stringify(settings, null, 2), "utf-8");
@@ -68166,7 +68762,7 @@ async function isInstalled() {
 function isExecutableAvailable(executable) {
   try {
     const command = process.platform === "win32" ? `where ${executable}` : `which ${executable}`;
-    execSync5(command, { stdio: "ignore" });
+    execSync5(command, { stdio: "ignore", windowsHide: true });
     return true;
   } catch {
     return false;
@@ -68194,7 +68790,12 @@ function getPackageCommandAvailability() {
 }
 function getClaudeCodeVersion() {
   try {
-    const output = execSync5("claude --version", { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"], timeout: 5000 }).trim();
+    const output = execSync5("claude --version", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "ignore"],
+      timeout: 5000,
+      windowsHide: true
+    }).trim();
     const match = /^(\d+\.\d+\.\d+)/.exec(output);
     return match?.[1] ?? null;
   } catch {
@@ -68281,7 +68882,7 @@ function classifyInstallation(command, metadata) {
 }
 async function loadSavedSettingsForHookSync() {
   const configPath = getConfigPath();
-  if (!fs11.existsSync(configPath)) {
+  if (!fs12.existsSync(configPath)) {
     return null;
   }
   try {
@@ -68382,19 +68983,19 @@ async function setRefreshInterval(interval) {
 }
 function getVoiceConfigCandidatePathsByPriority(cwd2) {
   const userDir = getClaudeConfigDir();
-  const projectDir = path8.join(cwd2, ".claude");
+  const projectDir = path9.join(cwd2, ".claude");
   const candidates = [
-    path8.join(projectDir, "settings.local.json"),
-    path8.join(projectDir, "settings.json"),
-    path8.join(userDir, "settings.local.json"),
-    path8.join(userDir, "settings.json")
+    path9.join(projectDir, "settings.local.json"),
+    path9.join(projectDir, "settings.json"),
+    path9.join(userDir, "settings.local.json"),
+    path9.join(userDir, "settings.json")
   ];
   return Array.from(new Set(candidates));
 }
 function tryReadVoiceLayer(filePath) {
   let content;
   try {
-    content = fs11.readFileSync(filePath, "utf-8");
+    content = fs12.readFileSync(filePath, "utf-8");
   } catch (error48) {
     const isMissing = error48.code === "ENOENT";
     return { fileExisted: !isMissing, enabled: undefined };
@@ -68424,13 +69025,49 @@ function getVoiceConfig(cwd2 = process.cwd()) {
   }
   return anyFileExisted ? { enabled: false } : null;
 }
-var readFile4, writeFile2, CCSTATUSLINE_COMMANDS, PINNED_INSTALL_COMMANDS, VoiceConfigSchema;
+function getRemoteControlStatus(sessionId) {
+  if (!sessionId) {
+    return null;
+  }
+  const sessionsDir = path9.join(getClaudeConfigDir(), "sessions");
+  let entries;
+  try {
+    entries = fs12.readdirSync(sessionsDir);
+  } catch {
+    return null;
+  }
+  for (const entry of entries) {
+    if (!entry.endsWith(".json")) {
+      continue;
+    }
+    let content;
+    try {
+      content = fs12.readFileSync(path9.join(sessionsDir, entry), "utf-8");
+    } catch {
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(content);
+    } catch {
+      continue;
+    }
+    const result2 = RemoteSessionFileSchema.safeParse(parsed);
+    if (!result2.success || result2.data.sessionId !== sessionId) {
+      continue;
+    }
+    const bridge = result2.data.bridgeSessionId;
+    return { enabled: typeof bridge === "string" && bridge.length > 0 };
+  }
+  return null;
+}
+var readFile4, writeFile2, CCSTATUSLINE_COMMANDS, PINNED_INSTALL_COMMANDS, VoiceConfigSchema, RemoteSessionFileSchema;
 var init_claude_settings = __esm(async () => {
   init_zod();
   init_Settings();
   await init_config();
-  readFile4 = fs11.promises.readFile;
-  writeFile2 = fs11.promises.writeFile;
+  readFile4 = fs12.promises.readFile;
+  writeFile2 = fs12.promises.writeFile;
   CCSTATUSLINE_COMMANDS = {
     AUTO_NPX: "npx -y ccstatusline-usage@latest",
     AUTO_BUNX: "bunx -y ccstatusline-usage@latest",
@@ -68444,6 +69081,10 @@ var init_claude_settings = __esm(async () => {
     BUN: (version2) => `bun add -g ccstatusline-usage@${version2}`
   };
   VoiceConfigSchema = exports_external.object({ enabled: exports_external.boolean().optional() });
+  RemoteSessionFileSchema = exports_external.object({
+    sessionId: exports_external.string().optional(),
+    bridgeSessionId: exports_external.string().nullable().optional()
+  });
 });
 
 // node_modules/pluralize/pluralize.js
@@ -69032,9 +69673,12 @@ await init_config();
 
 // src/utils/global-command-resolution.ts
 import { execFileSync as execFileSync5 } from "child_process";
-import * as path9 from "path";
+import * as path10 from "path";
 
 // src/utils/package-manager-executable.ts
+function getPackageManagerShellOptions(executable, platform2 = process.platform) {
+  return platform2 === "win32" && /\.(?:cmd|bat)$/i.test(executable) ? { shell: true } : {};
+}
 function getPackageManagerExecutable(packageManager, platform2 = process.platform) {
   return packageManager === "npm" && platform2 === "win32" ? "npm.cmd" : packageManager;
 }
@@ -69059,11 +69703,19 @@ function isTransientBunxStatusLinePath(filePath) {
   return /(?:^|\/)bunx-[^/]*ccstatusline-usage@[^/]+\/node_modules\/\.bin\/ccstatusline(?:\.(?:cmd|ps1))?$/i.test(normalized);
 }
 function getPersistentCommandResolutionPaths(paths) {
-  return paths.filter((path10) => !isTransientBunxStatusLinePath(path10));
+  return paths.filter((path11) => !isTransientBunxStatusLinePath(path11));
 }
 function getCommandResolutionPaths(command, { platform: platform2 = process.platform } = {}) {
   try {
-    const output = platform2 === "win32" ? execFileSync5("where", [command], { encoding: "utf-8", timeout: COMMAND_LOOKUP_TIMEOUT_MS }) : execFileSync5("which", ["-a", command], { encoding: "utf-8", timeout: COMMAND_LOOKUP_TIMEOUT_MS });
+    const output = platform2 === "win32" ? execFileSync5("where", [command], {
+      encoding: "utf-8",
+      timeout: COMMAND_LOOKUP_TIMEOUT_MS,
+      windowsHide: true
+    }) : execFileSync5("which", ["-a", command], {
+      encoding: "utf-8",
+      timeout: COMMAND_LOOKUP_TIMEOUT_MS,
+      windowsHide: true
+    });
     return splitCommandOutput(output);
   } catch {
     return [];
@@ -69071,14 +69723,17 @@ function getCommandResolutionPaths(command, { platform: platform2 = process.plat
 }
 function getNpmGlobalBinDir(platform2) {
   try {
-    const prefix = execFileSync5(getPackageManagerExecutable("npm", platform2), ["prefix", "-g"], {
+    const executable = getPackageManagerExecutable("npm", platform2);
+    const prefix = execFileSync5(executable, ["prefix", "-g"], {
       encoding: "utf-8",
-      timeout: COMMAND_LOOKUP_TIMEOUT_MS
+      timeout: COMMAND_LOOKUP_TIMEOUT_MS,
+      windowsHide: true,
+      ...getPackageManagerShellOptions(executable, platform2)
     }).trim();
     if (!prefix) {
       return null;
     }
-    return platform2 === "win32" || /^[a-z]:[\\/]/i.test(prefix) ? prefix : path9.join(prefix, "bin");
+    return platform2 === "win32" || /^[a-z]:[\\/]/i.test(prefix) ? prefix : path10.join(prefix, "bin");
   } catch {
     return null;
   }
@@ -69087,7 +69742,8 @@ function getBunGlobalBinDir() {
   try {
     const binDir = execFileSync5("bun", ["pm", "bin", "-g"], {
       encoding: "utf-8",
-      timeout: COMMAND_LOOKUP_TIMEOUT_MS
+      timeout: COMMAND_LOOKUP_TIMEOUT_MS,
+      windowsHide: true
     }).trim();
     return binDir || null;
   } catch {
@@ -69181,7 +69837,7 @@ import {
   execFile,
   execFileSync as execFileSync6
 } from "child_process";
-import * as fs12 from "fs";
+import * as fs13 from "fs";
 var GLOBAL_PACKAGE_TIMEOUT_MS = 120000;
 var VERSION_LOOKUP_TIMEOUT_MS = 5000;
 var WINDOWS_SHIM_EXTENSIONS = [
@@ -69230,7 +69886,7 @@ function getBinaryPathCandidates(binDir, platform2) {
   return extensions.map((extension) => appendPathSegment(binDir, `ccstatusline${extension}`));
 }
 function hasBinaryOnDisk(binDir, platform2) {
-  return getBinaryPathCandidates(binDir, platform2).some((candidate) => getFilesystemPathVariants(candidate).some((variant) => fs12.existsSync(variant)));
+  return getBinaryPathCandidates(binDir, platform2).some((candidate) => getFilesystemPathVariants(candidate).some((variant) => fs13.existsSync(variant)));
 }
 function hasResolvedBinaryInDir(resolvedPaths, binDir) {
   return resolvedPaths.some((resolvedPath) => isPathInsideDir(resolvedPath, binDir));
@@ -69263,10 +69919,10 @@ function formatPathList2(paths) {
 function readPackageVersion(packageJsonPath) {
   for (const variant of getFilesystemPathVariants(packageJsonPath)) {
     try {
-      if (!fs12.existsSync(variant)) {
+      if (!fs13.existsSync(variant)) {
         continue;
       }
-      const packageJson = JSON.parse(fs12.readFileSync(variant, "utf-8"));
+      const packageJson = JSON.parse(fs13.readFileSync(variant, "utf-8"));
       return typeof packageJson.version === "string" ? packageJson.version : null;
     } catch {
       return null;
@@ -69276,9 +69932,12 @@ function readPackageVersion(packageJsonPath) {
 }
 function getNpmGlobalPackageVersion(platform2) {
   try {
-    const rootDir = execFileSync6(getPackageManagerExecutable("npm", platform2), ["root", "-g"], {
+    const executable = getPackageManagerExecutable("npm", platform2);
+    const rootDir = execFileSync6(executable, ["root", "-g"], {
       encoding: "utf-8",
-      timeout: VERSION_LOOKUP_TIMEOUT_MS
+      timeout: VERSION_LOOKUP_TIMEOUT_MS,
+      windowsHide: true,
+      ...getPackageManagerShellOptions(executable, platform2)
     }).trim();
     return rootDir ? readPackageVersion(appendPathSegment(appendPathSegment(rootDir, "ccstatusline"), "package.json")) : null;
   } catch {
@@ -69384,20 +70043,24 @@ function inspectGlobalPackageInstallations({
 function runGlobalPackageUninstall(packageManager, { platform: platform2 = process.platform } = {}) {
   const executable = getPackageManagerExecutable(packageManager, platform2);
   const args = packageManager === "npm" ? ["uninstall", "-g", "ccstatusline"] : ["remove", "-g", "ccstatusline"];
-  return new Promise((resolve5, reject2) => {
-    execFile(executable, args, { timeout: GLOBAL_PACKAGE_TIMEOUT_MS }, (error48) => {
+  return new Promise((resolve6, reject2) => {
+    execFile(executable, args, {
+      timeout: GLOBAL_PACKAGE_TIMEOUT_MS,
+      windowsHide: true,
+      ...getPackageManagerShellOptions(executable, platform2)
+    }, (error48) => {
       if (error48) {
         reject2(error48 instanceof Error ? error48 : new Error("Global uninstall command failed"));
         return;
       }
-      resolve5();
+      resolve6();
     });
   });
 }
 
 // src/utils/open-url.ts
 import { spawnSync } from "child_process";
-import * as os10 from "os";
+import * as os11 from "os";
 function runOpenCommand(command, args) {
   const result2 = spawnSync(command, args, {
     stdio: "ignore",
@@ -69456,7 +70119,7 @@ function openExternalUrl(url2) {
       error: "Only http(s) URLs are supported"
     };
   }
-  const platform3 = os10.platform();
+  const platform3 = os11.platform();
   const plans = PLATFORM_OPEN_PLANS[platform3];
   if (!plans) {
     return {
@@ -69484,9 +70147,9 @@ function openExternalUrl(url2) {
 
 // src/utils/powerline.ts
 import { execSync as execSync6 } from "child_process";
-import * as fs13 from "fs";
-import * as os11 from "os";
-import * as path10 from "path";
+import * as fs14 from "fs";
+import * as os12 from "os";
+import * as path11 from "path";
 var fontsInstalledThisSession = false;
 function checkPowerlineFonts() {
   if (process.env.DEBUG_FONT_INSTALL === "1" && !fontsInstalledThisSession) {
@@ -69502,24 +70165,24 @@ function checkPowerlineFonts() {
       leftArrow: "",
       leftThinArrow: ""
     };
-    const platform4 = os11.platform();
+    const platform4 = os12.platform();
     let fontPaths = [];
     if (platform4 === "darwin") {
       fontPaths = [
-        path10.join(os11.homedir(), "Library", "Fonts"),
+        path11.join(os12.homedir(), "Library", "Fonts"),
         "/Library/Fonts",
         "/System/Library/Fonts"
       ];
     } else if (platform4 === "linux") {
       fontPaths = [
-        path10.join(os11.homedir(), ".local", "share", "fonts"),
-        path10.join(os11.homedir(), ".fonts"),
+        path11.join(os12.homedir(), ".local", "share", "fonts"),
+        path11.join(os12.homedir(), ".fonts"),
         "/usr/share/fonts",
         "/usr/local/share/fonts"
       ];
     } else if (platform4 === "win32") {
       fontPaths = [
-        path10.join(os11.homedir(), "AppData", "Local", "Microsoft", "Windows", "Fonts"),
+        path11.join(os12.homedir(), "AppData", "Local", "Microsoft", "Windows", "Fonts"),
         "C:\\Windows\\Fonts"
       ];
     }
@@ -69535,9 +70198,9 @@ function checkPowerlineFonts() {
       /fira.*code.*nerd/i
     ];
     for (const fontPath of fontPaths) {
-      if (fs13.existsSync(fontPath)) {
+      if (fs14.existsSync(fontPath)) {
         try {
-          const files = fs13.readdirSync(fontPath);
+          const files = fs14.readdirSync(fontPath);
           for (const file2 of files) {
             for (const pattern of powerlineFontPatterns) {
               if (pattern.test(file2)) {
@@ -69572,13 +70235,16 @@ async function checkPowerlineFontsAsync() {
     if (quickCheck.installed) {
       return quickCheck;
     }
-    const platform4 = os11.platform();
+    const platform4 = os12.platform();
     if (platform4 === "linux" || platform4 === "darwin") {
       try {
         const { exec: exec2 } = await import("child_process");
         const { promisify: promisify2 } = await import("util");
         const execAsync = promisify2(exec2);
-        const { stdout } = await execAsync("fc-list 2>/dev/null | grep -i powerline", { encoding: "utf8" });
+        const { stdout } = await execAsync("fc-list 2>/dev/null | grep -i powerline", {
+          encoding: "utf8",
+          windowsHide: true
+        });
         if (stdout.trim()) {
           return {
             installed: true,
@@ -69595,46 +70261,49 @@ async function checkPowerlineFontsAsync() {
 async function installPowerlineFonts() {
   await Promise.resolve();
   try {
-    const platform4 = os11.platform();
+    const platform4 = os12.platform();
     let fontDir;
     if (platform4 === "darwin") {
-      fontDir = path10.join(os11.homedir(), "Library", "Fonts");
+      fontDir = path11.join(os12.homedir(), "Library", "Fonts");
     } else if (platform4 === "linux") {
-      fontDir = path10.join(os11.homedir(), ".local", "share", "fonts");
+      fontDir = path11.join(os12.homedir(), ".local", "share", "fonts");
     } else if (platform4 === "win32") {
-      fontDir = path10.join(os11.homedir(), "AppData", "Local", "Microsoft", "Windows", "Fonts");
+      fontDir = path11.join(os12.homedir(), "AppData", "Local", "Microsoft", "Windows", "Fonts");
     } else {
       return {
         success: false,
         message: "Unsupported platform for font installation"
       };
     }
-    if (!fs13.existsSync(fontDir)) {
-      fs13.mkdirSync(fontDir, { recursive: true });
+    if (!fs14.existsSync(fontDir)) {
+      fs14.mkdirSync(fontDir, { recursive: true });
     }
-    const tempDir = path10.join(os11.tmpdir(), `ccstatusline-powerline-fonts-${Date.now()}`);
+    const tempDir = path11.join(os12.tmpdir(), `ccstatusline-powerline-fonts-${Date.now()}`);
     try {
-      if (fs13.existsSync(tempDir)) {
-        fs13.rmSync(tempDir, { recursive: true, force: true });
+      if (fs14.existsSync(tempDir)) {
+        fs14.rmSync(tempDir, { recursive: true, force: true });
       }
       execSync6(`git clone --depth=1 https://github.com/powerline/fonts.git "${tempDir}"`, {
         stdio: "pipe",
-        encoding: "utf8"
+        encoding: "utf8",
+        windowsHide: true
       });
       if (platform4 === "darwin" || platform4 === "linux") {
-        const installScript = path10.join(tempDir, "install.sh");
-        if (fs13.existsSync(installScript)) {
-          fs13.chmodSync(installScript, 493);
+        const installScript = path11.join(tempDir, "install.sh");
+        if (fs14.existsSync(installScript)) {
+          fs14.chmodSync(installScript, 493);
           execSync6(`cd "${tempDir}" && ./install.sh`, {
             stdio: "pipe",
             encoding: "utf8",
-            shell: "/bin/bash"
+            shell: "/bin/bash",
+            windowsHide: true
           });
           if (platform4 === "linux") {
             try {
               execSync6("fc-cache -f -v", {
                 stdio: "pipe",
-                encoding: "utf8"
+                encoding: "utf8",
+                windowsHide: true
               });
             } catch {}
           }
@@ -69650,10 +70319,10 @@ async function installPowerlineFonts() {
         }
       } else {
         let findFontFiles = function(dir) {
-          const files = fs13.readdirSync(dir);
+          const files = fs14.readdirSync(dir);
           for (const file2 of files) {
-            const filePath = path10.join(dir, file2);
-            const stat2 = fs13.statSync(filePath);
+            const filePath = path11.join(dir, file2);
+            const stat2 = fs14.statSync(filePath);
             if (stat2.isDirectory() && !file2.startsWith(".")) {
               findFontFiles(filePath);
             } else if (file2.endsWith(".ttf") || file2.endsWith(".otf")) {
@@ -69667,10 +70336,10 @@ async function installPowerlineFonts() {
         findFontFiles(tempDir);
         let installedCount = 0;
         for (const fontFile of fontFiles) {
-          const fileName = path10.basename(fontFile);
-          const destPath = path10.join(fontDir, fileName);
+          const fileName = path11.basename(fontFile);
+          const destPath = path11.join(fontDir, fileName);
           try {
-            fs13.copyFileSync(fontFile, destPath);
+            fs14.copyFileSync(fontFile, destPath);
             installedCount++;
           } catch {}
         }
@@ -69688,9 +70357,9 @@ async function installPowerlineFonts() {
         message: "Platform-specific installation not implemented"
       };
     } finally {
-      if (fs13.existsSync(tempDir)) {
+      if (fs14.existsSync(tempDir)) {
         try {
-          fs13.rmSync(tempDir, { recursive: true, force: true });
+          fs14.rmSync(tempDir, { recursive: true, force: true });
         } catch {}
       }
     }
@@ -69856,7 +70525,7 @@ async function checkForUpdates({
   }
 }
 function fetchLatestNpmVersion(timeoutMs = DEFAULT_REGISTRY_TIMEOUT_MS) {
-  return new Promise((resolve5, reject2) => {
+  return new Promise((resolve6, reject2) => {
     const request3 = https2.request(NPM_REGISTRY_LATEST_URL, {
       headers: {
         Accept: "application/json",
@@ -69880,7 +70549,7 @@ function fetchLatestNpmVersion(timeoutMs = DEFAULT_REGISTRY_TIMEOUT_MS) {
             reject2(new Error("npm registry response did not include a version"));
             return;
           }
-          resolve5(parsed.version);
+          resolve6(parsed.version);
         } catch (error48) {
           reject2(error48 instanceof Error ? error48 : new Error(String(error48)));
         }
@@ -69896,13 +70565,17 @@ function fetchLatestNpmVersion(timeoutMs = DEFAULT_REGISTRY_TIMEOUT_MS) {
 function runGlobalPackageInstall(packageManager, version2, { platform: platform4 = process.platform } = {}) {
   const executable = getPackageManagerExecutable(packageManager, platform4);
   const args = packageManager === "npm" ? ["install", "-g", `ccstatusline-usage@${version2}`] : ["add", "-g", `ccstatusline-usage@${version2}`];
-  return new Promise((resolve5, reject2) => {
-    execFile2(executable, args, { timeout: GLOBAL_UPDATE_TIMEOUT_MS }, (error48) => {
+  return new Promise((resolve6, reject2) => {
+    execFile2(executable, args, {
+      timeout: GLOBAL_UPDATE_TIMEOUT_MS,
+      windowsHide: true,
+      ...getPackageManagerShellOptions(executable, platform4)
+    }, (error48) => {
       if (error48) {
         reject2(error48 instanceof Error ? error48 : new Error("Global update command failed"));
         return;
       }
-      resolve5();
+      resolve6();
     });
   });
 }
@@ -71537,19 +72210,19 @@ var import_react41 = __toESM(require_react(), 1);
 var jsx_dev_runtime14 = __toESM(require_jsx_dev_runtime(), 1);
 var AUTO_UPDATE_DESCRIPTION = "Runs `@latest` through npx/bunx. Stays current automatically, with a small startup cost when the package runner checks or resolves the package. Because it follows the latest published package, pinned install is available if you prefer explicit updates.";
 function getPinnedDescription(currentVersion) {
-  return `Installs \`ccstatusline-usage@${currentVersion}\` globally and Claude Code runs \`ccstatusline\`. Fast per-render and only changes when you update.`;
+  return `Installs \`ccstatusline-usage@${currentVersion}\` globally and Claude Code runs \`ccstatusline\`. Fast on each render because Claude Code runs the installed ccstatusline binary directly. The version changes only when you update the global install.`;
 }
 function getStyleItems(currentVersion) {
   return [
-    {
-      label: "Auto-update",
-      value: "auto-update",
-      description: AUTO_UPDATE_DESCRIPTION
-    },
     {
       label: "Pinned global install",
       value: "pinned",
       description: getPinnedDescription(currentVersion)
+    },
+    {
+      label: "Auto-update",
+      value: "auto-update",
+      description: AUTO_UPDATE_DESCRIPTION
     }
   ];
 }
@@ -71619,7 +72292,7 @@ var InstallMenu = ({
   initialPackageSelection = 0
 }) => {
   const [step, setStep] = import_react41.useState("style");
-  const [updateStyle, setUpdateStyle] = import_react41.useState("auto-update");
+  const [updateStyle, setUpdateStyle] = import_react41.useState("pinned");
   use_input_default((_, key) => {
     if (key.escape) {
       if (step === "manager") {
@@ -73127,7 +73800,7 @@ function buildUninstallItems(installations) {
     items.push({
       label: `Remove Claude settings and ${packageManager} global package`,
       value: { packageManagers: [packageManager] },
-      description: `Runs ${packageManager === "npm" ? "npm uninstall -g ccstatusline" : "bun remove -g ccstatusline"} after removing Claude Code settings`
+      description: `Runs ${packageManager === "npm" ? "npm uninstall -g ccstatusline-usage" : "bun remove -g ccstatusline-usage"} after removing Claude Code settings`
     });
   }
   if (removableManagers.length > 1) {
@@ -73491,7 +74164,7 @@ var OffHoursMenu = ({ settings, onUpdate, onBack }) => {
 // src/tui/components/PowerlineSetup.tsx
 await init_build2();
 var import_react47 = __toESM(require_react(), 1);
-import * as os12 from "os";
+import * as os13 from "os";
 
 // src/utils/powerline-settings.ts
 init_colors();
@@ -74256,7 +74929,7 @@ var PowerlineSetup = ({
                   }, undefined, false, undefined, this)
                 ]
               }, undefined, true, undefined, this),
-              os12.platform() === "darwin" && /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(jsx_dev_runtime22.Fragment, {
+              os13.platform() === "darwin" && /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(jsx_dev_runtime22.Fragment, {
                 children: [
                   /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Text, {
                     dimColor: true,
@@ -74272,7 +74945,7 @@ var PowerlineSetup = ({
                   }, undefined, false, undefined, this)
                 ]
               }, undefined, true, undefined, this),
-              os12.platform() === "linux" && /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(jsx_dev_runtime22.Fragment, {
+              os13.platform() === "linux" && /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(jsx_dev_runtime22.Fragment, {
                 children: [
                   /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Text, {
                     dimColor: true,
@@ -74288,7 +74961,7 @@ var PowerlineSetup = ({
                   }, undefined, false, undefined, this)
                 ]
               }, undefined, true, undefined, this),
-              os12.platform() === "win32" && /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(jsx_dev_runtime22.Fragment, {
+              os13.platform() === "win32" && /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(jsx_dev_runtime22.Fragment, {
                 children: [
                   /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Text, {
                     dimColor: true,
@@ -74565,7 +75238,10 @@ function getRefreshIntervalSublabel(interval, supported) {
   }
   return `(${interval}s)`;
 }
-function buildConfigureStatusLineItems(refreshInterval, supportsRefreshInterval) {
+function getGitCacheTtlSublabel(ttlSeconds) {
+  return ttlSeconds === 0 ? "(mtime only)" : `(${ttlSeconds}s)`;
+}
+function buildConfigureStatusLineItems(refreshInterval, supportsRefreshInterval, gitCacheTtlSeconds) {
   return [
     {
       label: "\uD83D\uDD04 Refresh Interval",
@@ -74573,6 +75249,13 @@ function buildConfigureStatusLineItems(refreshInterval, supportsRefreshInterval)
       value: "refreshInterval",
       disabled: !supportsRefreshInterval,
       description: supportsRefreshInterval ? "How often Claude Code refreshes the status line by re-running the command. Enter value in seconds (1-60), or leave empty to remove." : "This setting requires Claude Code version 2.1.97 or later. Please update Claude Code to use this feature."
+    },
+    {
+      label: "\uD83E\uDDEE Git Cache TTL",
+      sublabel: getGitCacheTtlSublabel(gitCacheTtlSeconds),
+      value: "gitCacheTtl",
+      description: `How long git widget subprocess output can be reused while .git/HEAD and .git/index are unchanged. Enter 0-60 seconds;
+0 disables age-based expiry, so cached output is reused until those git metadata mtimes change.`
     }
   ];
 }
@@ -74592,14 +75275,31 @@ function validateRefreshIntervalInput(value) {
   }
   return null;
 }
+function validateGitCacheTtlInput(value) {
+  const parsed = parseInt(value, 10);
+  if (value === "" || isNaN(parsed)) {
+    return "Please enter a valid number";
+  }
+  if (parsed < 0) {
+    return `Minimum Git cache TTL is 0s (you entered ${parsed}s)`;
+  }
+  if (parsed > 60) {
+    return `Maximum Git cache TTL is 60s (you entered ${parsed}s)`;
+  }
+  return null;
+}
 var RefreshIntervalMenu = ({
   currentInterval,
   supportsRefreshInterval,
+  gitCacheTtlSeconds,
   onUpdate,
+  onGitCacheTtlUpdate,
   onBack
 }) => {
   const [editingRefreshInterval, setEditingRefreshInterval] = import_react48.useState(false);
+  const [editingGitCacheTtl, setEditingGitCacheTtl] = import_react48.useState(false);
   const [refreshInput, setRefreshInput] = import_react48.useState(() => getRefreshInputValue(currentInterval));
+  const [gitCacheTtlInput, setGitCacheTtlInput] = import_react48.useState(() => String(gitCacheTtlSeconds));
   const [validationError, setValidationError] = import_react48.useState(null);
   use_input_default((input, key) => {
     if (editingRefreshInterval) {
@@ -74635,6 +75335,33 @@ var RefreshIntervalMenu = ({
       }
       return;
     }
+    if (editingGitCacheTtl) {
+      if (key.return) {
+        const error48 = validateGitCacheTtlInput(gitCacheTtlInput);
+        if (error48) {
+          setValidationError(error48);
+        } else {
+          const value = parseInt(gitCacheTtlInput, 10);
+          onGitCacheTtlUpdate(value);
+          setEditingGitCacheTtl(false);
+          setValidationError(null);
+        }
+      } else if (key.escape) {
+        setGitCacheTtlInput(String(gitCacheTtlSeconds));
+        setEditingGitCacheTtl(false);
+        setValidationError(null);
+      } else if (key.backspace) {
+        setGitCacheTtlInput(gitCacheTtlInput.slice(0, -1));
+        setValidationError(null);
+      } else if (key.delete) {} else if (shouldInsertInput(input, key) && /\d/.test(input)) {
+        const newValue = gitCacheTtlInput + input;
+        if (newValue.length <= 2) {
+          setGitCacheTtlInput(newValue);
+          setValidationError(null);
+        }
+      }
+      return;
+    }
     if (key.escape) {
       onBack();
     }
@@ -74670,16 +75397,53 @@ var RefreshIntervalMenu = ({
             children: "Press Enter to confirm, ESC to cancel. Leave empty to remove."
           }, undefined, false, undefined, this)
         ]
+      }, undefined, true, undefined, this) : editingGitCacheTtl ? /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
+        marginTop: 1,
+        flexDirection: "column",
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text, {
+            children: [
+              "Enter Git cache TTL in seconds (0-60):",
+              " ",
+              gitCacheTtlInput,
+              gitCacheTtlInput.length > 0 ? "s" : ""
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text, {
+            children: " "
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text, {
+            dimColor: true,
+            wrap: "wrap",
+            children: "This affects how quickly git widgets notice unstaged and untracked working-tree changes."
+          }, undefined, false, undefined, this),
+          validationError ? /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text, {
+            color: "red",
+            children: validationError
+          }, undefined, false, undefined, this) : /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text, {
+            dimColor: true,
+            children: "0 disables age-based expiry; cache validity uses .git/HEAD and .git/index mtimes only."
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text, {
+            dimColor: true,
+            children: "Press Enter to confirm, ESC to cancel."
+          }, undefined, false, undefined, this)
+        ]
       }, undefined, true, undefined, this) : /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(List, {
         marginTop: 1,
-        items: buildConfigureStatusLineItems(currentInterval, supportsRefreshInterval),
+        items: buildConfigureStatusLineItems(currentInterval, supportsRefreshInterval, gitCacheTtlSeconds),
         onSelect: (value) => {
           if (value === "back") {
             onBack();
             return;
           }
-          setRefreshInput(getRefreshInputValue(currentInterval));
-          setEditingRefreshInterval(true);
+          if (value === "refreshInterval") {
+            setRefreshInput(getRefreshInputValue(currentInterval));
+            setEditingRefreshInterval(true);
+            return;
+          }
+          setGitCacheTtlInput(String(gitCacheTtlSeconds));
+          setEditingGitCacheTtl(true);
         },
         showBackButton: true
       }, undefined, false, undefined, this)
@@ -74730,6 +75494,7 @@ var renderSingleLine = (widgets, terminalWidth, settings, lineIndex, globalSepar
     terminalWidth,
     isPreview: true,
     minimalist: settings.minimalistMode,
+    gitCacheTtlSeconds: settings.gitCacheTtlSeconds,
     lineIndex,
     globalSeparatorIndex,
     globalPowerlineThemeIndex
@@ -74746,7 +75511,12 @@ var StatusLinePreview = ({ lines, terminalWidth, settings, onTruncationChange })
   const { renderedLines, anyTruncated } = import_react49.default.useMemo(() => {
     if (!settings)
       return { renderedLines: [], anyTruncated: false };
-    const preRenderedLines = preRenderAllWidgets(lines, settings, { terminalWidth, isPreview: true, minimalist: settings.minimalistMode });
+    const preRenderedLines = preRenderAllWidgets(lines, settings, {
+      terminalWidth,
+      isPreview: true,
+      minimalist: settings.minimalistMode,
+      gitCacheTtlSeconds: settings.gitCacheTtlSeconds
+    });
     const preCalculatedMaxWidths = calculateMaxWidthsFromPreRendered(preRenderedLines, settings);
     let globalSeparatorIndex = 0;
     let globalPowerlineThemeIndex = 0;
@@ -75375,7 +76145,7 @@ var UpdateCheckerMenu = ({
 };
 // src/tui/App.tsx
 var jsx_dev_runtime28 = __toESM(require_jsx_dev_runtime(), 1);
-var GITHUB_REPO_URL = "https://github.com/sirmalloc/ccstatusline";
+var GITHUB_REPO_URL = "https://github.com/pcvelz/ccstatusline-usage";
 var NOTICE_ITEMS = [
   {
     label: "Continue",
@@ -75506,7 +76276,7 @@ var PinnedVersionMismatchScreen = ({
   }, undefined, true, undefined, this);
 };
 function getGlobalUninstallCommand(packageManager) {
-  return packageManager === "npm" ? "npm uninstall -g ccstatusline" : "bun remove -g ccstatusline";
+  return packageManager === "npm" ? "npm uninstall -g ccstatusline-usage" : "bun remove -g ccstatusline-usage";
 }
 function buildUninstallConfirmMessage(selection) {
   if (selection.packageManagers.length === 0) {
@@ -76293,6 +77063,7 @@ ${GITHUB_REPO_URL}`,
           screen === "refreshInterval" && /* @__PURE__ */ jsx_dev_runtime28.jsxDEV(RefreshIntervalMenu, {
             currentInterval: currentRefreshInterval,
             supportsRefreshInterval,
+            gitCacheTtlSeconds: settings.gitCacheTtlSeconds,
             onUpdate: (interval) => {
               const previous = currentRefreshInterval;
               setCurrentRefreshInterval(interval);
@@ -76310,6 +77081,17 @@ ${GITHUB_REPO_URL}`,
               });
               setScreen("main");
             },
+            onGitCacheTtlUpdate: (ttlSeconds) => {
+              setSettings({
+                ...settings,
+                gitCacheTtlSeconds: ttlSeconds
+              });
+              setFlashMessage({
+                text: "✓ Git cache TTL updated",
+                color: "green"
+              });
+              setScreen("main");
+            },
             onBack: () => {
               setScreen("main");
             }
@@ -76494,9 +77276,9 @@ function renderCompactOutput(preRenderedLines, settings, maxWidth) {
 // src/utils/compaction.ts
 init_zod();
 import * as crypto from "crypto";
-import * as fs14 from "fs";
-import * as os13 from "os";
-import * as path11 from "path";
+import * as fs15 from "fs";
+import * as os14 from "os";
+import * as path12 from "path";
 var DEFAULT_DROP_THRESHOLD = 2;
 var FRESH_PREV_CTX_PCT = -1;
 var MAX_CACHE_FILE_BYTES = 4096;
@@ -76540,8 +77322,8 @@ function detectCompaction(currentCtxPct, state, options = DEFAULT_DROP_THRESHOLD
     ...currentWindowSize !== null ? { prevWindowSize: currentWindowSize } : {}
   };
 }
-function getCacheDir2() {
-  return path11.join(os13.homedir(), ".cache", "ccstatusline", "compaction");
+function getCacheDir3() {
+  return path12.join(os14.homedir(), ".cache", "ccstatusline", "compaction");
 }
 function sanitizeSessionId(sessionId) {
   const sanitized = sessionId.replace(/[^a-zA-Z0-9_-]/g, "_");
@@ -76551,18 +77333,18 @@ function sanitizeSessionId(sessionId) {
   return sanitized;
 }
 function getStatePath(sessionId) {
-  return path11.join(getCacheDir2(), `compaction-${sanitizeSessionId(sessionId)}.json`);
+  return path12.join(getCacheDir3(), `compaction-${sanitizeSessionId(sessionId)}.json`);
 }
 function loadCompactionState(sessionId) {
   const statePath = getStatePath(sessionId);
   let fd = null;
   try {
-    fd = fs14.openSync(statePath, fs14.constants.O_RDONLY | fs14.constants.O_NOFOLLOW);
-    const stats = fs14.fstatSync(fd);
+    fd = fs15.openSync(statePath, fs15.constants.O_RDONLY | fs15.constants.O_NOFOLLOW);
+    const stats = fs15.fstatSync(fd);
     if (!stats.isFile() || stats.size > MAX_CACHE_FILE_BYTES) {
       return FRESH;
     }
-    const raw = JSON.parse(fs14.readFileSync(fd, "utf-8"));
+    const raw = JSON.parse(fs15.readFileSync(fd, "utf-8"));
     const result2 = CompactionStateSchema.safeParse(raw);
     return result2.success ? result2.data : FRESH;
   } catch {
@@ -76570,7 +77352,7 @@ function loadCompactionState(sessionId) {
   } finally {
     if (fd !== null) {
       try {
-        fs14.closeSync(fd);
+        fs15.closeSync(fd);
       } catch {}
     }
   }
@@ -76578,20 +77360,20 @@ function loadCompactionState(sessionId) {
 function saveCompactionState(sessionId, state) {
   let tmpPath = null;
   try {
-    const dir = getCacheDir2();
-    if (!fs14.existsSync(dir)) {
-      fs14.mkdirSync(dir, { recursive: true });
+    const dir = getCacheDir3();
+    if (!fs15.existsSync(dir)) {
+      fs15.mkdirSync(dir, { recursive: true });
     }
     const targetPath = getStatePath(sessionId);
     tmpPath = `${targetPath}.tmp.${process.pid}.${crypto.randomBytes(4).toString("hex")}`;
-    fs14.writeFileSync(tmpPath, JSON.stringify(state) + `
+    fs15.writeFileSync(tmpPath, JSON.stringify(state) + `
 `);
-    fs14.renameSync(tmpPath, targetPath);
+    fs15.renameSync(tmpPath, targetPath);
     tmpPath = null;
   } catch {
     if (tmpPath !== null) {
       try {
-        fs14.unlinkSync(tmpPath);
+        fs15.unlinkSync(tmpPath);
       } catch {}
     }
   }
@@ -76602,27 +77384,27 @@ init_context_percentage();
 await init_config();
 
 // src/utils/hook-handler.ts
-import * as fs16 from "fs";
-import * as path13 from "path";
+import * as fs17 from "fs";
+import * as path14 from "path";
 
 // src/utils/skills.ts
-import * as fs15 from "fs";
-import * as os14 from "os";
-import * as path12 from "path";
+import * as fs16 from "fs";
+import * as os15 from "os";
+import * as path13 from "path";
 var EMPTY = { totalInvocations: 0, uniqueSkills: [], lastSkill: null };
 function getSkillsDir() {
-  return path12.join(os14.homedir(), ".cache", "ccstatusline", "skills");
+  return path13.join(os15.homedir(), ".cache", "ccstatusline", "skills");
 }
 function getSkillsFilePath(sessionId) {
-  return path12.join(getSkillsDir(), `skills-${sessionId}.jsonl`);
+  return path13.join(getSkillsDir(), `skills-${sessionId}.jsonl`);
 }
 function getSkillsMetrics(sessionId) {
   const filePath = getSkillsFilePath(sessionId);
-  if (!fs15.existsSync(filePath)) {
+  if (!fs16.existsSync(filePath)) {
     return EMPTY;
   }
   try {
-    const invocations = fs15.readFileSync(filePath, "utf-8").trim().split(`
+    const invocations = fs16.readFileSync(filePath, "utf-8").trim().split(`
 `).filter((line) => line.trim()).map((line) => {
       try {
         return JSON.parse(line);
@@ -76676,14 +77458,14 @@ function handleHookInput(input) {
       return;
     }
     const filePath = getSkillsFilePath(sessionId);
-    fs16.mkdirSync(path13.dirname(filePath), { recursive: true });
+    fs17.mkdirSync(path14.dirname(filePath), { recursive: true });
     const entry = JSON.stringify({
       timestamp: new Date().toISOString(),
       session_id: sessionId,
       skill: skillName,
       source: data.hook_event_name
     });
-    fs16.appendFileSync(filePath, entry + `
+    fs17.appendFileSync(filePath, entry + `
 `);
   } catch {}
 }
@@ -76703,34 +77485,113 @@ var USAGE_WIDGET_TYPES = new Set([
   "block-timer",
   "reset-timer",
   "weekly-reset-timer",
-  "weekly-pace"
-]);
-var PER_MODEL_USAGE_WIDGET_TYPES = new Set([
-  "weekly-sonnet-usage",
-  "weekly-opus-usage"
+  "weekly-pace",
+  "extra-usage-utilization",
+  "extra-usage-remaining"
 ]);
+var USAGE_DATA_FIELDS = [
+  "sessionUsage",
+  "sessionResetAt",
+  "weeklyUsage",
+  "weeklyResetAt",
+  "weeklySonnetUsage",
+  "weeklySonnetResetAt",
+  "weeklyOpusUsage",
+  "weeklyOpusResetAt",
+  "extraUsageEnabled",
+  "extraUsageLimit",
+  "extraUsageUsed",
+  "extraUsageUtilization"
+];
+var EMPTY_USAGE_REQUIREMENTS = [];
+var USAGE_WIDGET_REQUIREMENTS = {
+  "session-usage": [{ field: "sessionUsage" }],
+  "weekly-usage": [{ field: "weeklyUsage" }],
+  "weekly-sonnet-usage": [{ field: "weeklySonnetUsage" }],
+  "weekly-opus-usage": [{ field: "weeklyOpusUsage" }],
+  "block-timer": [{ field: "sessionResetAt" }],
+  "reset-timer": [{ field: "sessionResetAt" }],
+  "weekly-reset-timer": [{ field: "weeklyResetAt" }],
+  "weekly-pace": [{ field: "weeklyUsage" }, { field: "weeklyResetAt" }],
+  "extra-usage-utilization": [
+    { field: "extraUsageEnabled" },
+    { field: "extraUsageUtilization" }
+  ],
+  "extra-usage-remaining": [
+    { field: "extraUsageEnabled" },
+    { field: "extraUsageLimit" },
+    { field: "extraUsageUsed" }
+  ]
+};
+var USAGE_CURSOR_REQUIREMENTS = {
+  "session-usage": { field: "sessionResetAt" },
+  "weekly-usage": { field: "weeklyResetAt" },
+  "weekly-sonnet-usage": { field: "weeklySonnetResetAt", alternatives: ["weeklyResetAt"] },
+  "weekly-opus-usage": { field: "weeklyOpusResetAt", alternatives: ["weeklyResetAt"] }
+};
 function hasUsageDependentWidgets(lines) {
   return lines.some((line) => line.some((item) => USAGE_WIDGET_TYPES.has(item.type)));
 }
-function getPerModelUsageRequirements(lines) {
-  const requirements = {
-    opus: false,
-    sonnet: false
-  };
+function isUsageCursorEnabled2(item) {
+  return item.metadata?.cursor === "true";
+}
+function getUsageFieldRequirements(lines) {
+  const requirements = [];
   for (const line of lines) {
     for (const item of line) {
-      if (!PER_MODEL_USAGE_WIDGET_TYPES.has(item.type)) {
-        continue;
-      }
-      if (item.type === "weekly-sonnet-usage") {
-        requirements.sonnet = true;
-      } else if (item.type === "weekly-opus-usage") {
-        requirements.opus = true;
+      requirements.push(...USAGE_WIDGET_REQUIREMENTS[item.type] ?? EMPTY_USAGE_REQUIREMENTS);
+      const cursorRequirement = USAGE_CURSOR_REQUIREMENTS[item.type];
+      if (cursorRequirement && isUsageCursorEnabled2(item)) {
+        requirements.push(cursorRequirement);
       }
     }
   }
   return requirements;
 }
+function hasUsageDataField(data, field) {
+  return data?.[field] !== undefined;
+}
+function isUsageRequirementSatisfied(data, requirement) {
+  if (hasUsageDataField(data, requirement.field)) {
+    return true;
+  }
+  return requirement.alternatives?.some((field) => hasUsageDataField(data, field)) ?? false;
+}
+function getMissingFetchFields(data, requirements) {
+  const missing = new Set;
+  for (const requirement of requirements) {
+    if (!isUsageRequirementSatisfied(data, requirement)) {
+      missing.add(requirement.field);
+    }
+  }
+  return Array.from(missing);
+}
+function hasAnyUsageDataField(data) {
+  return USAGE_DATA_FIELDS.some((field) => data?.[field] !== undefined);
+}
+function pickDefinedUsageFields(data) {
+  return {
+    ...data?.sessionUsage !== undefined ? { sessionUsage: data.sessionUsage } : {},
+    ...data?.sessionResetAt !== undefined ? { sessionResetAt: data.sessionResetAt } : {},
+    ...data?.weeklyUsage !== undefined ? { weeklyUsage: data.weeklyUsage } : {},
+    ...data?.weeklyResetAt !== undefined ? { weeklyResetAt: data.weeklyResetAt } : {},
+    ...data?.weeklySonnetUsage !== undefined ? { weeklySonnetUsage: data.weeklySonnetUsage } : {},
+    ...data?.weeklySonnetResetAt !== undefined ? { weeklySonnetResetAt: data.weeklySonnetResetAt } : {},
+    ...data?.weeklyOpusUsage !== undefined ? { weeklyOpusUsage: data.weeklyOpusUsage } : {},
+    ...data?.weeklyOpusResetAt !== undefined ? { weeklyOpusResetAt: data.weeklyOpusResetAt } : {},
+    ...data?.extraUsageEnabled !== undefined ? { extraUsageEnabled: data.extraUsageEnabled } : {},
+    ...data?.extraUsageLimit !== undefined ? { extraUsageLimit: data.extraUsageLimit } : {},
+    ...data?.extraUsageUsed !== undefined ? { extraUsageUsed: data.extraUsageUsed } : {},
+    ...data?.extraUsageUtilization !== undefined ? { extraUsageUtilization: data.extraUsageUtilization } : {}
+  };
+}
+function mergeUsageData(rateLimitsData, apiData) {
+  return {
+    ...pickDefinedUsageFields(apiData),
+    ...pickDefinedUsageFields(rateLimitsData),
+    ...apiData.error ? { error: apiData.error } : {}
+  };
+}
 function epochSecondsToIsoString(epochSeconds) {
   if (epochSeconds === null || epochSeconds === undefined || !Number.isFinite(epochSeconds)) {
     return;
@@ -76749,10 +77610,7 @@ function extractUsageDataFromRateLimits(rateLimits) {
   const weeklySonnetResetAt = epochSecondsToIsoString(rateLimits.seven_day_sonnet?.resets_at);
   const weeklyOpusUsage = rateLimits.seven_day_opus === null ? 0 : rateLimits.seven_day_opus?.used_percentage ?? undefined;
   const weeklyOpusResetAt = epochSecondsToIsoString(rateLimits.seven_day_opus?.resets_at);
-  if (sessionUsage === undefined && weeklyUsage === undefined) {
-    return null;
-  }
-  return {
+  const usageData = {
     sessionUsage,
     sessionResetAt,
     weeklyUsage,
@@ -76762,31 +77620,7 @@ function extractUsageDataFromRateLimits(rateLimits) {
     weeklyOpusUsage,
     weeklyOpusResetAt
   };
-}
-function hasCompleteRateLimitsUsageData(usageData, perModelRequirements) {
-  if (usageData?.sessionUsage === undefined || usageData.sessionResetAt === undefined || usageData.weeklyUsage === undefined || usageData.weeklyResetAt === undefined) {
-    return false;
-  }
-  if (perModelRequirements.sonnet && usageData.weeklySonnetUsage === undefined) {
-    return false;
-  }
-  if (perModelRequirements.opus && usageData.weeklyOpusUsage === undefined) {
-    return false;
-  }
-  return true;
-}
-function getRequiredUsageFields(perModelRequirements) {
-  const requiredFields = [];
-  if (perModelRequirements.sonnet) {
-    requiredFields.push("weeklySonnetUsage");
-  }
-  if (perModelRequirements.opus) {
-    requiredFields.push("weeklyOpusUsage");
-  }
-  return requiredFields;
-}
-function hasExtraUsageDependentWidgets(lines) {
-  return lines.some((line) => line.some((item) => item.type === "reset-timer"));
+  return hasAnyUsageDataField(usageData) ? usageData : null;
 }
 async function prefetchUsageDataIfNeeded(lines, data) {
   if (!hasUsageDependentWidgets(lines)) {
@@ -76796,17 +77630,13 @@ async function prefetchUsageDataIfNeeded(lines, data) {
   const modelId = (typeof model === "string" ? model : model?.id) ?? "";
   const provider = resolveProvider(modelId);
   const rateLimitsData = extractUsageDataFromRateLimits(data?.rate_limits);
-  const perModelRequirements = getPerModelUsageRequirements(lines);
-  if (hasCompleteRateLimitsUsageData(rateLimitsData, perModelRequirements)) {
-    if (hasExtraUsageDependentWidgets(lines)) {
-      const apiData = await provider.fetchUsage({ requiredFields: getRequiredUsageFields(perModelRequirements) });
-      if (apiData.error === undefined) {
-        return { ...rateLimitsData, extraUsageEnabled: apiData.extraUsageEnabled, extraUsageLimit: apiData.extraUsageLimit, extraUsageUsed: apiData.extraUsageUsed, extraUsageUtilization: apiData.extraUsageUtilization };
-      }
-    }
+  const requirements = getUsageFieldRequirements(lines);
+  const missingFields = getMissingFetchFields(rateLimitsData, requirements);
+  if (missingFields.length === 0) {
     return rateLimitsData;
   }
-  return provider.fetchUsage({ requiredFields: getRequiredUsageFields(perModelRequirements) });
+  const apiData = await provider.fetchUsage({ requiredFields: missingFields });
+  return mergeUsageData(rateLimitsData, apiData);
 }
 
 // src/ccstatusline.ts
@@ -76851,7 +77681,7 @@ async function ensureWindowsUtf8CodePage() {
   }
   try {
     const { execFileSync: execFileSync7 } = await import("child_process");
-    execFileSync7("chcp.com", ["65001"], { stdio: "ignore" });
+    execFileSync7("chcp.com", ["65001"], { stdio: "ignore", windowsHide: true });
   } catch {}
 }
 async function renderMultipleLines(data) {
@@ -76922,7 +77752,8 @@ async function renderMultipleLines(data) {
     terminalWidth: effectiveWidth,
     compactionData: hasCompactionWidget ? { count: compactionCount } : null,
     isPreview: false,
-    minimalist: settings.minimalistMode
+    minimalist: settings.minimalistMode,
+    gitCacheTtlSeconds: settings.gitCacheTtlSeconds
   };
   const preRenderedLines = preRenderAllWidgets(lines, settings, context);
   if (compact2 && compactWidth) {