ccstatusline 2.2.18 → 2.2.20

package/dist/ccstatusline.js

@@ -1355,7 +1355,7 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
     exports.useTransition = function() {
       return resolveDispatcher().useTransition();
     };
-    exports.version = "19.2.6";
+    exports.version = "19.2.7";
     typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
   })();
 });
@@ -53062,6 +53062,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,
@@ -53519,6 +53520,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,
@@ -53539,22 +53709,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;
   }
-  const gitArgs = ["--no-optional-locks", ...args];
   try {
-    const output = execFileSync("git", gitArgs, {
+    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;
   }
 }
@@ -53660,13 +53845,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;
 });
@@ -53784,8 +53969,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, "/");
@@ -53934,7 +54119,7 @@ class GitBranchWidget {
     return displayText;
   }
   getGitBranch(context) {
-    return runGit("branch --show-current", context);
+    return runGit("symbolic-ref --short HEAD", context);
   }
   getCustomKeybinds() {
     return [
@@ -54440,19 +54625,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 {
@@ -54460,14 +54645,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) {
@@ -54481,9 +54667,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 {
@@ -54520,35 +54706,70 @@ function getOriginUrl(cwd2, deps) {
   const url2 = runGitForCache(["remote", "get-url", "--", "origin"], cwd2, deps);
   return url2.length > 0 ? url2 : null;
 }
+function isSshRemoteUrl(url2) {
+  const trimmed = url2.trim().toLowerCase();
+  return trimmed.startsWith("ssh://") || !trimmed.includes("://");
+}
+function resolveSshHostAlias(host, deps) {
+  try {
+    const output = deps.execFileSync("ssh", ["-G", host], {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "ignore"],
+      timeout: CLI_TIMEOUT,
+      windowsHide: true
+    }).trim();
+    for (const line of output.split(/\r?\n/)) {
+      const match = /^hostname\s+(.+)$/i.exec(line.trim());
+      if (match?.[1]) {
+        return match[1].toLowerCase();
+      }
+    }
+  } catch {}
+  return host.toLowerCase();
+}
+function getNamedForgeProvider(host) {
+  if (host.includes("github")) {
+    return "gh";
+  }
+  if (host.includes("gitlab")) {
+    return "glab";
+  }
+  return null;
+}
+function getEffectiveRemoteHost(url2, host, deps) {
+  const normalizedHost = host.toLowerCase();
+  if (!isSshRemoteUrl(url2) || getNamedForgeProvider(normalizedHost)) {
+    return normalizedHost;
+  }
+  return resolveSshHostAlias(normalizedHost, deps);
+}
 function getOriginHost(cwd2, deps) {
   const url2 = getOriginUrl(cwd2, deps);
   if (!url2) {
     return null;
   }
   const parsed = parseRemoteUrl(url2);
-  return parsed ? parsed.host.toLowerCase() : null;
+  return parsed ? getEffectiveRemoteHost(url2, parsed.host, deps) : null;
 }
-function toHttpsRepoRef(url2) {
+function toHttpsRepoRef(url2, deps) {
   const parsed = parseRemoteUrl(url2);
   if (!parsed) {
     return null;
   }
-  return `https://${parsed.host}/${parsed.owner}/${parsed.repo}`;
+  return `https://${getEffectiveRemoteHost(url2, parsed.host, deps)}/${parsed.owner}/${parsed.repo}`;
 }
 function getOriginRepoRef(cwd2, deps) {
   const url2 = getOriginUrl(cwd2, deps);
-  return url2 ? toHttpsRepoRef(url2) : null;
+  return url2 ? toHttpsRepoRef(url2, deps) : null;
 }
 function getProviderCandidates(cwd2, deps) {
   const host = getOriginHost(cwd2, deps);
   if (!host) {
     return ["gh", "glab"];
   }
-  if (host.includes("github")) {
-    return ["gh"];
-  }
-  if (host.includes("gitlab")) {
-    return ["glab"];
+  const namedForgeProvider = getNamedForgeProvider(host);
+  if (namedForgeProvider) {
+    return [namedForgeProvider];
   }
   const authed = [];
   if (isCliAuthedForHost("glab", host, deps)) {
@@ -54563,7 +54784,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 {
@@ -54574,7 +54796,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 {
@@ -54606,7 +54829,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;
@@ -54638,7 +54862,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;
@@ -54670,7 +54895,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;
@@ -54716,11 +54941,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
   };
 });
@@ -55909,6 +56134,278 @@ function getContextWindowSize(data) {
   return getContextWindowMetrics(data).windowSize;
 }
 
+// src/utils/gradient.ts
+function isGradientSpec(value) {
+  return value?.startsWith(GRADIENT_PREFIX) ?? false;
+}
+function parseGradientSpec(value) {
+  if (!value?.startsWith(GRADIENT_PREFIX)) {
+    return null;
+  }
+  const body = value.slice(GRADIENT_PREFIX.length).trim();
+  if (!body) {
+    return null;
+  }
+  const preset = GRADIENT_PRESETS[body.toLowerCase()];
+  const rawStops = preset ?? body.split(body.includes(",") ? "," : "-");
+  const stops = rawStops.map((stop) => stop.trim()).filter((stop) => stop.length > 0).map(resolveStopToRgb).filter((rgb) => rgb !== null);
+  return stops.length >= 2 ? stops : null;
+}
+function hexToRgb(hex3) {
+  if (!HEX_PATTERN.test(hex3)) {
+    return null;
+  }
+  return {
+    r: parseInt(hex3.slice(0, 2), 16),
+    g: parseInt(hex3.slice(2, 4), 16),
+    b: parseInt(hex3.slice(4, 6), 16)
+  };
+}
+function resolveStopToRgb(stop) {
+  if (stop.startsWith("hex:")) {
+    return hexToRgb(stop.slice(4));
+  }
+  if (stop.startsWith("#")) {
+    return hexToRgb(stop.slice(1));
+  }
+  return hexToRgb(stop);
+}
+function srgbToLinear(channel) {
+  const normalized = channel / 255;
+  return normalized <= 0.04045 ? normalized / 12.92 : ((normalized + 0.055) / 1.055) ** 2.4;
+}
+function linearToSrgb(channel) {
+  const value = channel <= 0.0031308 ? 12.92 * channel : 1.055 * channel ** (1 / 2.4) - 0.055;
+  return Math.round(Math.min(1, Math.max(0, value)) * 255);
+}
+function rgbToOklab(rgb) {
+  const lr = srgbToLinear(rgb.r);
+  const lg = srgbToLinear(rgb.g);
+  const lb = srgbToLinear(rgb.b);
+  const l = 0.4122214708 * lr + 0.5363325363 * lg + 0.0514459929 * lb;
+  const m = 0.2119034982 * lr + 0.6806995451 * lg + 0.1073969566 * lb;
+  const s = 0.0883024619 * lr + 0.2817188376 * lg + 0.6299787005 * lb;
+  const lCbrt = Math.cbrt(l);
+  const mCbrt = Math.cbrt(m);
+  const sCbrt = Math.cbrt(s);
+  return {
+    L: 0.2104542553 * lCbrt + 0.793617785 * mCbrt - 0.0040720468 * sCbrt,
+    a: 1.9779984951 * lCbrt - 2.428592205 * mCbrt + 0.4505937099 * sCbrt,
+    b: 0.0259040371 * lCbrt + 0.7827717662 * mCbrt - 0.808675766 * sCbrt
+  };
+}
+function oklabToRgb(lab) {
+  const lCbrt = lab.L + 0.3963377774 * lab.a + 0.2158037573 * lab.b;
+  const mCbrt = lab.L - 0.1055613458 * lab.a - 0.0638541728 * lab.b;
+  const sCbrt = lab.L - 0.0894841775 * lab.a - 1.291485548 * lab.b;
+  const l = lCbrt ** 3;
+  const m = mCbrt ** 3;
+  const s = sCbrt ** 3;
+  return {
+    r: linearToSrgb(4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s),
+    g: linearToSrgb(-1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s),
+    b: linearToSrgb(-0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s)
+  };
+}
+function sampleGradient(stops, t) {
+  const first = stops[0];
+  if (first === undefined) {
+    return { r: 0, g: 0, b: 0 };
+  }
+  if (stops.length === 1) {
+    return first;
+  }
+  const clamped = Math.min(1, Math.max(0, t));
+  const scaled = clamped * (stops.length - 1);
+  const lowerIndex = Math.min(stops.length - 2, Math.floor(scaled));
+  const lower = stops[lowerIndex];
+  const upper = stops[lowerIndex + 1];
+  if (lower === undefined || upper === undefined) {
+    return first;
+  }
+  const fraction = scaled - lowerIndex;
+  const labLower = rgbToOklab(lower);
+  const labUpper = rgbToOklab(upper);
+  return oklabToRgb({
+    L: labLower.L + (labUpper.L - labLower.L) * fraction,
+    a: labLower.a + (labUpper.a - labLower.a) * fraction,
+    b: labLower.b + (labUpper.b - labLower.b) * fraction
+  });
+}
+function rgbToAnsi256(rgb) {
+  if (rgb.r === rgb.g && rgb.g === rgb.b) {
+    if (rgb.r < 8) {
+      return 16;
+    }
+    if (rgb.r > 248) {
+      return 231;
+    }
+    return Math.round((rgb.r - 8) / 247 * 24) + 232;
+  }
+  return 16 + 36 * Math.round(rgb.r / 255 * 5) + 6 * Math.round(rgb.g / 255 * 5) + Math.round(rgb.b / 255 * 5);
+}
+function gradientCodeAt(stops, t, colorLevel) {
+  const rgb = sampleGradient(stops, t);
+  if (colorLevel === "truecolor") {
+    return `\x1B[38;2;${rgb.r};${rgb.g};${rgb.b}m`;
+  }
+  return `\x1B[38;5;${rgbToAnsi256(rgb)}m`;
+}
+function isCsiFinalByte(codePoint) {
+  return codePoint >= 64 && codePoint <= 126;
+}
+function consumeCsi(input, start, bodyStart) {
+  let index = bodyStart;
+  while (index < input.length) {
+    const codePoint = input.charCodeAt(index);
+    if (isCsiFinalByte(codePoint)) {
+      const end = index + 1;
+      return {
+        nextIndex: end,
+        sequence: input.slice(start, end)
+      };
+    }
+    index++;
+  }
+  return {
+    nextIndex: input.length,
+    sequence: input.slice(start)
+  };
+}
+function consumeOsc(input, start, bodyStart) {
+  let index = bodyStart;
+  while (index < input.length) {
+    const current = input[index];
+    if (!current) {
+      break;
+    }
+    if (current === BEL2 || current === ST) {
+      const end = index + 1;
+      return {
+        nextIndex: end,
+        sequence: input.slice(start, end)
+      };
+    }
+    if (current === ESC2 && input[index + 1] === "\\") {
+      const end = index + 2;
+      return {
+        nextIndex: end,
+        sequence: input.slice(start, end)
+      };
+    }
+    index++;
+  }
+  return {
+    nextIndex: input.length,
+    sequence: input.slice(start)
+  };
+}
+function consumeEscapeSequence(input, index) {
+  const current = input[index];
+  if (!current) {
+    return null;
+  }
+  if (current === ESC2) {
+    const next = input[index + 1];
+    if (next === "[") {
+      return consumeCsi(input, index, index + 2);
+    }
+    if (next === "]") {
+      return consumeOsc(input, index, index + 2);
+    }
+    if (next) {
+      return {
+        nextIndex: index + 2,
+        sequence: input.slice(index, index + 2)
+      };
+    }
+    return {
+      nextIndex: input.length,
+      sequence: current
+    };
+  }
+  if (current === C1_CSI) {
+    return consumeCsi(input, index, index + 1);
+  }
+  if (current === C1_OSC) {
+    return consumeOsc(input, index, index + 1);
+  }
+  return null;
+}
+function applyGradientToText(text, stops, colorLevel) {
+  if (colorLevel === "ansi16" || text.length === 0) {
+    return text;
+  }
+  let visibleCount = 0;
+  let scanIndex = 0;
+  while (scanIndex < text.length) {
+    const escape3 = consumeEscapeSequence(text, scanIndex);
+    if (escape3) {
+      scanIndex = escape3.nextIndex;
+      continue;
+    }
+    const codePoint = text.codePointAt(scanIndex);
+    if (codePoint === undefined) {
+      break;
+    }
+    const ch = String.fromCodePoint(codePoint);
+    if (!WHITESPACE.test(ch)) {
+      visibleCount++;
+    }
+    scanIndex += ch.length;
+  }
+  if (visibleCount === 0) {
+    return text;
+  }
+  const denominator = Math.max(1, visibleCount - 1);
+  let result2 = "";
+  let index = 0;
+  let textIndex = 0;
+  while (textIndex < text.length) {
+    const escape3 = consumeEscapeSequence(text, textIndex);
+    if (escape3) {
+      result2 += escape3.sequence;
+      textIndex = escape3.nextIndex;
+      continue;
+    }
+    const codePoint = text.codePointAt(textIndex);
+    if (codePoint === undefined) {
+      break;
+    }
+    const ch = String.fromCodePoint(codePoint);
+    if (WHITESPACE.test(ch)) {
+      result2 += ch;
+      textIndex += ch.length;
+      continue;
+    }
+    result2 += gradientCodeAt(stops, index / denominator, colorLevel) + ch;
+    index++;
+    textIndex += ch.length;
+  }
+  return result2;
+}
+var GRADIENT_PREFIX = "gradient:", HEX_PATTERN, ESC2 = "\x1B", BEL2 = "\x07", C1_CSI = "›", C1_OSC = "", ST = "œ", GRADIENT_PRESETS, GRADIENT_PRESET_NAMES, WHITESPACE;
+var init_gradient = __esm(() => {
+  HEX_PATTERN = /^[0-9A-Fa-f]{6}$/;
+  GRADIENT_PRESETS = {
+    atlas: ["#feac5e", "#c779d0", "#4bc0c8"],
+    cristal: ["#bdfff3", "#4ac29a"],
+    teen: ["#77a1d3", "#79cbca", "#e684ae"],
+    mind: ["#473b7b", "#3584a7", "#30d2be"],
+    morning: ["#ff5f6d", "#ffc371"],
+    vice: ["#5ee7df", "#b490ca"],
+    passion: ["#f43b47", "#453a94"],
+    fruit: ["#ff4e50", "#f9d423"],
+    instagram: ["#833ab4", "#fd1d1d", "#fcb045"],
+    retro: ["#3f51b1", "#5a55ae", "#7b5fac", "#8f6aae", "#a86aa4", "#cc6b8e", "#f18271", "#f3a469", "#f7c978"],
+    summer: ["#fdbb2d", "#22c1c3"],
+    rainbow: ["#ff0000", "#ffff00", "#00ff00", "#00ffff", "#0000ff", "#ff00ff", "#ff0000"],
+    pastel: ["#aee9d8", "#cdeeb0", "#f6f0a8", "#f7c8a8", "#f3aecb", "#c3b6f0", "#aee9d8"]
+  };
+  GRADIENT_PRESET_NAMES = Object.keys(GRADIENT_PRESETS);
+  WHITESPACE = /\s/;
+});
+
 // src/utils/ansi.ts
 function createUnicodePropertyRegex(pattern) {
   try {
@@ -56027,14 +56524,14 @@ function getTextDisplayWidth(text) {
   }
   return width;
 }
-function isCsiFinalByte(codePoint) {
+function isCsiFinalByte2(codePoint) {
   return codePoint >= 64 && codePoint <= 126;
 }
 function parseCsi(input, start, bodyStart) {
   let index = bodyStart;
   while (index < input.length) {
     const codePoint = input.charCodeAt(index);
-    if (isCsiFinalByte(codePoint)) {
+    if (isCsiFinalByte2(codePoint)) {
       const end = index + 1;
       return {
         nextIndex: end,
@@ -56066,7 +56563,7 @@ function parseOsc(input, start, bodyStart) {
     if (!current) {
       break;
     }
-    if (current === BEL2) {
+    if (current === BEL3) {
       const end = index + 1;
       const body = input.slice(bodyStart, index);
       return {
@@ -56076,7 +56573,7 @@ function parseOsc(input, start, bodyStart) {
         osc8Terminator: "bel"
       };
     }
-    if (current === ST) {
+    if (current === ST2) {
       const end = index + 1;
       const body = input.slice(bodyStart, index);
       return {
@@ -56086,7 +56583,7 @@ function parseOsc(input, start, bodyStart) {
         osc8Terminator: "st"
       };
     }
-    if (current === ESC2 && input[index + 1] === "\\") {
+    if (current === ESC3 && input[index + 1] === "\\") {
       const end = index + 2;
       const body = input.slice(bodyStart, index);
       return {
@@ -56108,7 +56605,7 @@ function parseEscapeSequence(input, index) {
   if (!current) {
     return null;
   }
-  if (current === ESC2) {
+  if (current === ESC3) {
     const next = input[index + 1];
     if (next === "[") {
       return parseCsi(input, index, index + 2);
@@ -56127,19 +56624,19 @@ function parseEscapeSequence(input, index) {
       sequence: current
     };
   }
-  if (current === C1_CSI) {
+  if (current === C1_CSI2) {
     return parseCsi(input, index, index + 1);
   }
-  if (current === C1_OSC) {
+  if (current === C1_OSC2) {
     return parseOsc(input, index, index + 1);
   }
   return null;
 }
 function getOsc8CloseSequence(terminator) {
   if (terminator === "bel") {
-    return `${ESC2}]8;;${BEL2}`;
+    return `${ESC3}]8;;${BEL3}`;
   }
-  return `${ESC2}]8;;${ESC2}\\`;
+  return `${ESC3}]8;;${ESC3}\\`;
 }
 function stripSgrCodes(text) {
   return text.replace(SGR_REGEX, "");
@@ -56150,7 +56647,7 @@ function stripOscCodes(text) {
   while (index < text.length) {
     const escape3 = parseEscapeSequence(text, index);
     if (escape3) {
-      const isOsc = escape3.sequence.startsWith(`${ESC2}]`) || escape3.sequence.startsWith(C1_OSC);
+      const isOsc = escape3.sequence.startsWith(`${ESC3}]`) || escape3.sequence.startsWith(C1_OSC2);
       if (!isOsc) {
         result2 += escape3.sequence;
       }
@@ -56250,9 +56747,56 @@ function truncateStyledText(text, maxWidth, options = {}) {
   }
   return output + ellipsis;
 }
-var ESC2 = "\x1B", BEL2 = "\x07", C1_CSI = "›", C1_OSC = "", ST = "œ", ZERO_WIDTH_JOINER = 8205, COMBINING_ENCLOSING_KEYCAP = 8419, VARIATION_SELECTOR_START = 65024, VARIATION_SELECTOR_END = 65039, VARIATION_SELECTOR_SUPPLEMENT_START = 917760, VARIATION_SELECTOR_SUPPLEMENT_END = 917999, REGIONAL_INDICATOR_START = 127462, REGIONAL_INDICATOR_END = 127487, SGR_REGEX, EXTENDED_PICTOGRAPHIC_REGEX, EMOJI_PRESENTATION_REGEX, EMOJI_MODIFIER_REGEX, COMBINING_MARK_REGEX;
+function applyLineGradientSegment(text, stops, colorLevel, startColumn, totalWidth) {
+  const visibleWidth = getVisibleWidth(text);
+  if (stops.length === 0 || colorLevel === "ansi16") {
+    return {
+      text,
+      nextColumn: startColumn + visibleWidth
+    };
+  }
+  if (totalWidth <= 1) {
+    return {
+      text,
+      nextColumn: startColumn + visibleWidth
+    };
+  }
+  const denominator = totalWidth - 1;
+  let output = "";
+  let column = startColumn;
+  let index = 0;
+  while (index < text.length) {
+    const escape3 = parseEscapeSequence(text, index);
+    if (escape3) {
+      output += escape3.sequence;
+      index = escape3.nextIndex;
+      continue;
+    }
+    const cluster = consumeDisplayCluster(text, index);
+    if (!cluster) {
+      break;
+    }
+    output += gradientCodeAt(stops, column / denominator, colorLevel) + cluster.text;
+    column += getClusterWidth(cluster.text);
+    index = cluster.nextIndex;
+  }
+  return {
+    text: output,
+    nextColumn: column
+  };
+}
+function applyLineGradient(text, stops, colorLevel) {
+  const totalWidth = getVisibleWidth(text);
+  const result2 = applyLineGradientSegment(text, stops, colorLevel, 0, totalWidth);
+  if (result2.text === text) {
+    return text;
+  }
+  return `${result2.text}\x1B[39m`;
+}
+var ESC3 = "\x1B", BEL3 = "\x07", C1_CSI2 = "›", C1_OSC2 = "", ST2 = "œ", ZERO_WIDTH_JOINER = 8205, COMBINING_ENCLOSING_KEYCAP = 8419, VARIATION_SELECTOR_START = 65024, VARIATION_SELECTOR_END = 65039, VARIATION_SELECTOR_SUPPLEMENT_START = 917760, VARIATION_SELECTOR_SUPPLEMENT_END = 917999, REGIONAL_INDICATOR_START = 127462, REGIONAL_INDICATOR_END = 127487, SGR_REGEX, EXTENDED_PICTOGRAPHIC_REGEX, EMOJI_PRESENTATION_REGEX, EMOJI_MODIFIER_REGEX, COMBINING_MARK_REGEX;
 var init_ansi = __esm(() => {
   init_string_width();
+  init_gradient();
   SGR_REGEX = /\x1b\[[0-9;]*m/g;
   EXTENDED_PICTOGRAPHIC_REGEX = createUnicodePropertyRegex("\\p{Extended_Pictographic}");
   EMOJI_PRESENTATION_REGEX = createUnicodePropertyRegex("\\p{Emoji_Presentation}");
@@ -56364,6 +56908,10 @@ function applyColors(text, foregroundColor, backgroundColor, bold, colorLevel =
     }
   }
   if (foregroundColor) {
+    const gradientStops = parseGradientSpec(foregroundColor);
+    if (gradientStops && colorLevel !== "ansi16") {
+      return prefix + applyGradientToText(text, gradientStops, colorLevel) + "\x1B[39m" + suffix;
+    }
     const fgCode = getColorAnsiCode(foregroundColor, colorLevel, false);
     if (fgCode) {
       prefix += fgCode;
@@ -56375,6 +56923,20 @@ function applyColors(text, foregroundColor, backgroundColor, bold, colorLevel =
 function getColorAnsiCode(colorName, colorLevel = "ansi16", isBackground = false) {
   if (!colorName)
     return "";
+  if (isGradientSpec(colorName)) {
+    const stops = parseGradientSpec(colorName);
+    const first = stops?.[0];
+    if (!first)
+      return "";
+    if (colorLevel === "ansi16") {
+      return "";
+    }
+    if (colorLevel === "ansi256") {
+      const code = rgbToAnsi256(first);
+      return isBackground ? `\x1B[48;5;${code}m` : `\x1B[38;5;${code}m`;
+    }
+    return isBackground ? `\x1B[48;2;${first.r};${first.g};${first.b}m` : `\x1B[38;2;${first.r};${first.g};${first.b}m`;
+  }
   if (colorName.startsWith("ansi256:")) {
     const code = parseInt(colorName.substring(8), 10);
     if (!isNaN(code) && code >= 0 && code <= 255) {
@@ -56444,6 +57006,7 @@ function getDefaultPowerlineTheme() {
 var COLOR_MAP, POWERLINE_THEMES;
 var init_colors = __esm(() => {
   init_source();
+  init_gradient();
   COLOR_MAP = createColorMap();
   POWERLINE_THEMES = {
     custom: {
@@ -56715,20 +57278,20 @@ var init_context_percentage = () => {};
 
 // 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 {}
@@ -56736,6 +57299,13 @@ function getPackageVersion() {
   return "";
 }
 function probeTerminalWidth() {
+  const overrideRaw = process.env.CCSTATUSLINE_WIDTH;
+  if (overrideRaw) {
+    const override = parsePositiveInteger(overrideRaw);
+    if (override !== null) {
+      return override;
+    }
+  }
   if (process.platform === "win32") {
     return null;
   }
@@ -56758,7 +57328,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 {}
@@ -56776,7 +57347,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 {
@@ -56788,7 +57360,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;
@@ -56810,7 +57383,8 @@ function getWidthForTTY(tty2) {
       const width = execSync(`${cmd} 2>/dev/null | awk '{print $2}'`, {
         encoding: "utf8",
         stdio: ["pipe", "pipe", "ignore"],
-        shell: "/bin/sh"
+        shell: "/bin/sh",
+        windowsHide: true
       }).trim();
       const parsed = parsePositiveInteger(width);
       if (parsed !== null) {
@@ -56826,7 +57400,7 @@ function getTerminalWidth() {
 function canDetectTerminalWidth() {
   return probeTerminalWidth() !== null;
 }
-var __dirname = "/home/runner/work/ccstatusline/ccstatusline/src/utils", PACKAGE_VERSION = "2.2.18";
+var __dirname = "/home/runner/work/ccstatusline/ccstatusline/src/utils", PACKAGE_VERSION = "2.2.20";
 var init_terminal = () => {};
 
 // src/utils/renderer.ts
@@ -56837,6 +57411,10 @@ function formatTokens(count) {
     return `${(count / 1000).toFixed(1)}k`;
   return count.toString();
 }
+function maybeApplyForegroundGradient(line, settings, colorLevel) {
+  const stops = parseGradientSpec(settings.overrideForegroundColor);
+  return stops ? applyLineGradient(line, stops, colorLevel) : line;
+}
 function resolveEffectiveTerminalWidth(detectedWidth, settings, context) {
   if (!detectedWidth) {
     return null;
@@ -56889,6 +57467,7 @@ function renderPowerlineStatusLine(widgets, settings, context, lineIndex = 0, gl
     }
   }
   const colorLevel = getColorLevelString(settings.colorLevel);
+  const overrideForegroundGradientStops = parseGradientSpec(settings.overrideForegroundColor);
   const filteredWidgets = widgets.filter((widget) => widget.type !== "separator" && widget.type !== "flex-separator");
   if (filteredWidgets.length === 0)
     return "";
@@ -56945,7 +57524,7 @@ function renderPowerlineStatusLine(widgets, settings, context, lineIndex = 0, gl
           widgetColorIndex++;
         }
       }
-      if (settings.overrideForegroundColor && settings.overrideForegroundColor !== "none") {
+      if (settings.overrideForegroundColor && settings.overrideForegroundColor !== "none" && !isGradientSpec(settings.overrideForegroundColor)) {
         fgColor = settings.overrideForegroundColor;
       }
       widgetElements.push({
@@ -56992,6 +57571,11 @@ function renderPowerlineStatusLine(widgets, settings, context, lineIndex = 0, gl
       }
     }
   }
+  const powerlineGradientWidth = overrideForegroundGradientStops && colorLevel !== "ansi16" ? widgetElements.reduce((sum2, element) => {
+    const isPreserveColors = element.widget.type === "custom-command" && element.widget.preserveColors;
+    return isPreserveColors ? sum2 : sum2 + getVisibleWidth(element.content);
+  }, 0) : 0;
+  let powerlineGradientColumn = 0;
   let result2 = "";
   if (startCap && widgetElements.length > 0) {
     const firstWidget = widgetElements[0];
@@ -57015,13 +57599,20 @@ function renderPowerlineStatusLine(widgets, settings, context, lineIndex = 0, gl
     if (shouldBold && !isPreserveColors) {
       widgetContent += "\x1B[1m";
     }
-    if (widget.fgColor && !isPreserveColors) {
+    const textGradientStops = !isPreserveColors && powerlineGradientWidth > 1 ? overrideForegroundGradientStops : null;
+    if (widget.fgColor && !isPreserveColors && !textGradientStops) {
       widgetContent += getColorAnsiCode(widget.fgColor, colorLevel, false);
     }
     if (widget.bgColor) {
       widgetContent += getColorAnsiCode(widget.bgColor, colorLevel, true);
     }
-    widgetContent += widget.content;
+    if (textGradientStops) {
+      const gradientResult = applyLineGradientSegment(widget.content, textGradientStops, colorLevel, powerlineGradientColumn, powerlineGradientWidth);
+      widgetContent += gradientResult.text;
+      powerlineGradientColumn = gradientResult.nextColumn;
+    } else {
+      widgetContent += widget.content;
+    }
     if (isPreserveColors) {
       widgetContent += "\x1B[0m";
     } else {
@@ -57198,7 +57789,7 @@ function calculateMaxWidthsFromPreRendered(preRenderedLines, settings) {
 }
 function renderStatusLineWithInfo(widgets, settings, context, preRenderedWidgets, preCalculatedMaxWidths) {
   const line = renderStatusLine(widgets, settings, context, preRenderedWidgets, preCalculatedMaxWidths);
-  const wasTruncated = line.includes("...");
+  const wasTruncated = getVisibleText(line).includes("...");
   return { line, wasTruncated };
 }
 function renderStatusLine(widgets, settings, context, preRenderedWidgets, preCalculatedMaxWidths) {
@@ -57209,8 +57800,13 @@ function renderStatusLine(widgets, settings, context, preRenderedWidgets, preCal
     return renderPowerlineStatusLine(widgets, settings, context, context.lineIndex ?? 0, context.globalSeparatorIndex ?? 0, context.globalPowerlineThemeIndex ?? 0, preRenderedWidgets, preCalculatedMaxWidths);
   const applyColorsWithOverride = (text, foregroundColor, backgroundColor, bold) => {
     let fgColor = foregroundColor;
-    if (settings.overrideForegroundColor && settings.overrideForegroundColor !== "none") {
-      fgColor = settings.overrideForegroundColor;
+    const fgOverride = settings.overrideForegroundColor;
+    if (fgOverride && fgOverride !== "none") {
+      if (!isGradientSpec(fgOverride)) {
+        fgColor = fgOverride;
+      } else if (colorLevel !== "ansi16") {
+        fgColor = undefined;
+      }
     }
     let bgColor = backgroundColor;
     if (settings.overrideBackgroundColor && settings.overrideBackgroundColor !== "none") {
@@ -57399,6 +57995,7 @@ function renderStatusLine(widgets, settings, context, preRenderedWidgets, preCal
       statusLine = truncateStyledText(statusLine, maxWidth, { ellipsis: true });
     }
   }
+  statusLine = maybeApplyForegroundGradient(statusLine, settings, colorLevel);
   return statusLine;
 }
 var init_renderer2 = __esm(async () => {
@@ -57407,6 +58004,7 @@ var init_renderer2 = __esm(async () => {
   init_ansi();
   init_colors();
   init_context_percentage();
+  init_gradient();
   init_terminal();
   await init_widgets2();
 });
@@ -57437,13 +58035,13 @@ class TokensInputWidget {
     if (context.isPreview) {
       return formatRawOrLabeledValue(item, "In: ", "15.2k");
     }
+    if (context.tokenMetrics) {
+      return formatRawOrLabeledValue(item, "In: ", formatTokens(context.tokenMetrics.inputTokens));
+    }
     const inputTotalTokens = getContextWindowInputTotalTokens(context.data);
     if (inputTotalTokens !== null) {
       return formatRawOrLabeledValue(item, "In: ", formatTokens(inputTotalTokens));
     }
-    if (context.tokenMetrics) {
-      return formatRawOrLabeledValue(item, "In: ", formatTokens(context.tokenMetrics.inputTokens));
-    }
     return null;
   }
   supportsRawValue() {
@@ -57478,13 +58076,13 @@ class TokensOutputWidget {
     if (context.isPreview) {
       return formatRawOrLabeledValue(item, "Out: ", "3.4k");
     }
+    if (context.tokenMetrics) {
+      return formatRawOrLabeledValue(item, "Out: ", formatTokens(context.tokenMetrics.outputTokens));
+    }
     const outputTotalTokens = getContextWindowOutputTotalTokens(context.data);
     if (outputTotalTokens !== null) {
       return formatRawOrLabeledValue(item, "Out: ", formatTokens(outputTotalTokens));
     }
-    if (context.tokenMetrics) {
-      return formatRawOrLabeledValue(item, "Out: ", formatTokens(context.tokenMetrics.outputTokens));
-    }
     return null;
   }
   supportsRawValue() {
@@ -57904,6 +58502,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 = [];
@@ -57992,6 +58596,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);
     }
@@ -58001,7 +58608,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" };
@@ -58010,6 +58617,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" };
 });
@@ -58915,7 +59523,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);
@@ -59582,7 +60191,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;
@@ -59639,7 +60248,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;
       }
@@ -59987,7 +60596,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() {
@@ -60056,7 +60665,7 @@ function parseProxyResponse(socket) {
       }
       debug("got proxy server response: %o %o", firstLine, headers);
       cleanup();
-      resolve({
+      resolve2({
         connect: {
           statusCode,
           statusText,
@@ -60196,10 +60805,10 @@ 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;
 }
@@ -60258,8 +60867,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(error51, now2, maxAge = LOCK_MAX_AGE) {
@@ -60279,7 +60888,7 @@ function hasRequiredUsageField(data, field) {
   if (data[field] !== undefined) {
     return true;
   }
-  return data.extraUsageEnabled === false && EXTRA_USAGE_DETAIL_FIELDS.has(field);
+  return data.extraUsageEnabled !== undefined && EXTRA_USAGE_DETAIL_FIELDS.has(field);
 }
 function hasRequiredUsageFields(data, requiredFields = []) {
   return requiredFields.every((field) => hasRequiredUsageField(data, field));
@@ -60361,7 +60970,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;
   }
@@ -60375,7 +60984,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 {
@@ -60394,8 +61004,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;
   }
@@ -60408,7 +61018,7 @@ function getUsageToken() {
 }
 function readStaleUsageCache() {
   try {
-    return parseCachedUsageData(fs3.readFileSync(CACHE_FILE, "utf8"));
+    return parseCachedUsageData(fs4.readFileSync(CACHE_FILE, "utf8"));
   } catch {
     return null;
   }
@@ -60416,13 +61026,13 @@ function readStaleUsageCache() {
 function writeUsageLock(blockedUntil, error51) {
   try {
     ensureCacheDirExists();
-    fs3.writeFileSync(LOCK_FILE, JSON.stringify({ blockedUntil, error: error51 }));
+    fs4.writeFileSync(LOCK_FILE, JSON.stringify({ blockedUntil, error: error51 }));
   } 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) {
@@ -60438,7 +61048,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) {
@@ -60493,14 +61103,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) {
@@ -60551,10 +61161,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);
       }
@@ -60589,7 +61199,7 @@ async function fetchUsageData(options = {}) {
     }
     try {
       ensureCacheDirExists();
-      fs3.writeFileSync(CACHE_FILE, JSON.stringify(usageData));
+      fs4.writeFileSync(CACHE_FILE, JSON.stringify(usageData));
     } catch {}
     return cacheUsageData(usageData, now2);
   } catch {
@@ -60603,9 +61213,9 @@ var init_usage_fetch = __esm(async () => {
   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",
@@ -60654,31 +61264,31 @@ var init_usage_fetch = __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;
@@ -60744,10 +61354,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);
@@ -60755,9 +61365,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) {
@@ -60803,9 +61413,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++;
@@ -60826,28 +61436,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, (error51, resolvedPath) => {
+  fs5.realpath(path5, (error51, resolvedPath) => {
     if (error51)
       return queue.dequeue(suppressErrors ? null : error51, 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) {
@@ -60878,22 +61488,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, (error51, entries = []) => {
+  fs5.readdir(crawlPath || ".", readdirOpts, (error51, entries = []) => {
     callback$1(entries, directoryPath, currentDepth);
     state.queue.dequeue(state.options.suppressErrors ? null : error51, 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;
@@ -60992,23 +61602,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);
           }
@@ -61142,7 +61752,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;
   }
 };
@@ -61355,8 +61965,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];
@@ -62837,8 +63447,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;
@@ -62910,10 +63520,13 @@ function buildRelative(cwd2, root) {
     return p[p.length - 1] === "/" && result2 !== "" ? `${result2}/` : result2 || ".";
   };
 }
-function splitPattern(path4) {
+function ensureNonDriveRelativePath(path5) {
+  return path5.replace(DRIVE_RELATIVE_PATH, (match) => `${match}/`);
+}
+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)
@@ -62949,7 +63562,7 @@ function normalizePattern(pattern, opts, props, isIgnore) {
     }
     const potentialRoot = posix.join(cwd2, parentDir.slice(i * 3));
     if (potentialRoot[0] !== "." && props.root.length > potentialRoot.length) {
-      props.root = potentialRoot;
+      props.root = ensureNonDriveRelativePath(potentialRoot);
       props.depthOffset = -n + i;
     }
   }
@@ -62970,7 +63583,7 @@ function normalizePattern(pattern, opts, props, isIgnore) {
     }
     props.depthOffset = newCommonPath.length;
     props.commonPath = newCommonPath;
-    props.root = newCommonPath.length > 0 ? posix.join(cwd2, ...newCommonPath) : cwd2;
+    props.root = ensureNonDriveRelativePath(newCommonPath.length > 0 ? posix.join(cwd2, ...newCommonPath) : cwd2);
   }
   return result2;
 }
@@ -63029,14 +63642,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);
@@ -63069,11 +63682,11 @@ function formatPaths(paths, mapper) {
   return paths;
 }
 function getOptions2(options) {
-  const opts = {
-    ...defaultOptions,
-    ...options
-  };
-  opts.cwd = (opts.cwd instanceof URL ? fileURLToPath(opts.cwd) : resolve2(opts.cwd)).replace(BACKSLASHES, "/");
+  const opts = Object.assign({}, options);
+  for (const key in defaultOptions)
+    if (opts[key] === undefined)
+      Object.assign(opts, { [key]: defaultOptions[key] });
+  opts.cwd = (opts.cwd instanceof URL ? fileURLToPath(opts.cwd) : resolve3(opts.cwd || process.cwd())).replace(BACKSLASHES, "/");
   opts.ignore = ensureStringArray(opts.ignore);
   opts.fs && (opts.fs = {
     readdir: opts.fs.readdir || readdir,
@@ -63081,7 +63694,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);
@@ -63100,12 +63713,13 @@ 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, DRIVE_RELATIVE_PATH, 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);
   isReadonlyArray = Array.isArray;
   BACKSLASHES = /\\/g;
+  DRIVE_RELATIVE_PATH = /^[A-Za-z]:$/;
   isWin = process.platform === "win32";
   ONLY_PARENT_DIRECTORIES = /^(\/?\.\.)+$/;
   WIN32_ROOT_DIR = /^[A-Z]:\/$/i;
@@ -63118,7 +63732,6 @@ var init_dist7 = __esm(() => {
   ESCAPING_BACKSLASHES = /\\(?=[()[\]{}!*+?@|])/g;
   defaultOptions = {
     caseSensitiveMatch: true,
-    cwd: process.cwd(),
     debug: !!process.env.TINYGLOBBY_DEBUG,
     expandDirectories: true,
     followSymbolicLinks: true,
@@ -63127,7 +63740,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(`
@@ -63138,7 +63751,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) {
@@ -63148,15 +63761,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)
@@ -63170,7 +63783,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
@@ -63178,7 +63791,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());
@@ -63296,26 +63909,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 {
@@ -63324,7 +63937,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;
@@ -63350,15 +63963,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) {
@@ -63381,21 +63994,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;
@@ -63427,7 +64040,7 @@ function getReferencedSubagentIds(lines) {
 }
 async function getSessionDuration(transcriptPath) {
   try {
-    if (!fs7.existsSync(transcriptPath)) {
+    if (!fs8.existsSync(transcriptPath)) {
       return null;
     }
     const lines = await readJsonlLines(transcriptPath);
@@ -63477,7 +64090,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);
@@ -63691,20 +64304,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;
@@ -63716,7 +64329,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;
         }
@@ -63733,7 +64346,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
@@ -63930,44 +64543,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;
     }
@@ -63982,7 +64620,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;
   }
@@ -63994,21 +64632,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(error51) {
   switch (error51) {
@@ -64029,10 +64667,11 @@ function makeUsageProgressBar(percent, width = 15) {
   const empty2 = width - filled;
   return "[" + "█".repeat(filled) + "░".repeat(empty2) + "]";
 }
-var DEFAULT_TZ_LOCALE = "en-US";
+var UTC_WEEKDAY_NAMES, DEFAULT_TZ_LOCALE = "en-US";
 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
@@ -64148,7 +64787,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() {
@@ -64293,27 +64932,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) => {
@@ -64445,6 +65084,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;
@@ -65082,7 +65722,7 @@ var init_JjRevision = __esm(() => {
 });
 
 // src/widgets/ClaudeAccountEmail.ts
-import * as fs8 from "fs";
+import * as fs9 from "fs";
 
 class ClaudeAccountEmailWidget {
   getDefaultColor() {
@@ -65105,7 +65745,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) {
@@ -65459,7 +66099,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;
@@ -65474,7 +66114,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];
@@ -65523,12 +66163,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}`;
@@ -65543,7 +66183,7 @@ class FreeMemoryWidget {
 var init_FreeMemory = () => {};
 
 // src/widgets/SessionName.ts
-import * as fs9 from "fs";
+import * as fs10 from "fs";
 
 class SessionNameWidget {
   getDefaultColor() {
@@ -65570,7 +66210,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--) {
@@ -65895,7 +66535,7 @@ class ExtraUsageUtilizationWidget {
         return getUsageErrorMessage(data.error);
       return null;
     }
-    const percent = Math.max(0, Math.min(100, data.extraUsageUtilization * 100));
+    const percent = Math.max(0, Math.min(100, data.extraUsageUtilization));
     const renderedPercent = inverted ? 100 - percent : percent;
     if (isUsageProgressMode(displayMode)) {
       const width = getUsageProgressBarWidth(displayMode);
@@ -65962,7 +66602,8 @@ class ExtraUsageRemainingWidget {
       return null;
     }
     const limitDollars = data.extraUsageLimit / 100;
-    const remaining = Math.max(0, limitDollars - data.extraUsageUsed);
+    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);
   }
@@ -66797,6 +67438,9 @@ function getWeeklyResetModifierText(item) {
       if (isUsage12HourClock(item)) {
         modifiers.push("12hr");
       }
+      if (isUsageWeekdayEnabled(item)) {
+        modifiers.push("weekday");
+      }
     } else if (isWeeklyResetHoursOnly(item)) {
       modifiers.push("hours only");
     }
@@ -66847,6 +67491,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);
     }
@@ -66871,8 +67518,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));
     }
@@ -66900,7 +67549,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);
       }
@@ -66912,6 +67561,7 @@ class WeeklyResetTimerWidget {
     const keybinds = getUsageTimerCustomKeybinds(item, {
       includeDate: true,
       includeHourFormat: true,
+      includeWeekday: true,
       includeLocale: true,
       includeTimezone: true
     });
@@ -68047,6 +68697,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();
@@ -68117,7 +68898,8 @@ var init_widgets = __esm(async () => {
     init_Link(),
     init_Skills(),
     init_ThinkingEffort(),
-    init_VoiceStatus()
+    init_VoiceStatus(),
+    init_RemoteControlStatus()
   ]);
 });
 
@@ -68199,6 +68981,7 @@ var init_widget_manifest = __esm(async () => {
     { type: "thinking-effort", create: () => new ThinkingEffortWidget },
     { type: "vim-mode", create: () => new VimModeWidget },
     { 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 },
@@ -68383,11 +69166,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;
@@ -68396,13 +69179,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 writeSettingsJson(settings, paths) {
@@ -68411,7 +69194,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}`);
@@ -68441,7 +69224,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;
@@ -68492,7 +69275,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();
@@ -68512,18 +69295,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 execSync4 } 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);
@@ -68547,9 +69330,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;
         }
@@ -68558,24 +69341,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;
@@ -68588,11 +69371,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 (error51) {
     if (logErrors) {
@@ -68604,7 +69387,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 {
@@ -68619,7 +69402,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 mkdir2(dir, { recursive: true });
   await writeFile2(settingsPath2, JSON.stringify(settings, null, 2), "utf-8");
@@ -68637,7 +69420,7 @@ async function isInstalled() {
 function isExecutableAvailable(executable) {
   try {
     const command = process.platform === "win32" ? `where ${executable}` : `which ${executable}`;
-    execSync4(command, { stdio: "ignore" });
+    execSync4(command, { stdio: "ignore", windowsHide: true });
     return true;
   } catch {
     return false;
@@ -68665,7 +69448,12 @@ function getPackageCommandAvailability() {
 }
 function getClaudeCodeVersion() {
   try {
-    const output = execSync4("claude --version", { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"], timeout: 5000 }).trim();
+    const output = execSync4("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 {
@@ -68752,7 +69540,7 @@ function classifyInstallation(command, metadata) {
 }
 async function loadSavedSettingsForHookSync() {
   const configPath = getConfigPath();
-  if (!fs11.existsSync(configPath)) {
+  if (!fs12.existsSync(configPath)) {
     return null;
   }
   try {
@@ -68853,19 +69641,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 (error51) {
     const isMissing = error51.code === "ENOENT";
     return { fileExisted: !isMissing, enabled: undefined };
@@ -68895,14 +69683,50 @@ function getVoiceConfig(cwd2 = process.cwd()) {
   }
   return anyFileExisted ? { enabled: false } : null;
 }
-var readFile4, writeFile2, mkdir2, 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, mkdir2, 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;
-  mkdir2 = fs11.promises.mkdir;
+  readFile4 = fs12.promises.readFile;
+  writeFile2 = fs12.promises.writeFile;
+  mkdir2 = fs12.promises.mkdir;
   CCSTATUSLINE_COMMANDS = {
     AUTO_NPX: "npx -y ccstatusline@latest",
     AUTO_BUNX: "bunx -y ccstatusline@latest",
@@ -68916,6 +69740,10 @@ var init_claude_settings = __esm(async () => {
     BUN: (version2) => `bun add -g ccstatusline@${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
@@ -69504,9 +70332,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;
 }
@@ -69531,11 +70362,19 @@ function isTransientBunxStatusLinePath(filePath) {
   return /(?:^|\/)bunx-[^/]*ccstatusline@[^/]+\/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 [];
@@ -69543,14 +70382,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;
   }
@@ -69559,7 +70401,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 {
@@ -69653,7 +70496,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 = [
@@ -69702,7 +70545,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));
@@ -69735,10 +70578,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;
@@ -69748,9 +70591,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 {
@@ -69856,20 +70702,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 }, (error51) => {
+  return new Promise((resolve6, reject2) => {
+    execFile(executable, args, {
+      timeout: GLOBAL_PACKAGE_TIMEOUT_MS,
+      windowsHide: true,
+      ...getPackageManagerShellOptions(executable, platform2)
+    }, (error51) => {
       if (error51) {
         reject2(error51 instanceof Error ? error51 : 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",
@@ -69928,7 +70778,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 {
@@ -69956,9 +70806,9 @@ function openExternalUrl(url2) {
 
 // src/utils/powerline.ts
 import { execSync as execSync5 } 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) {
@@ -69974,24 +70824,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"
       ];
     }
@@ -70007,9 +70857,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)) {
@@ -70044,13 +70894,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,
@@ -70067,46 +70920,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 });
       }
       execSync5(`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);
           execSync5(`cd "${tempDir}" && ./install.sh`, {
             stdio: "pipe",
             encoding: "utf8",
-            shell: "/bin/bash"
+            shell: "/bin/bash",
+            windowsHide: true
           });
           if (platform4 === "linux") {
             try {
               execSync5("fc-cache -f -v", {
                 stdio: "pipe",
-                encoding: "utf8"
+                encoding: "utf8",
+                windowsHide: true
               });
             } catch {}
           }
@@ -70122,10 +70978,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")) {
@@ -70139,10 +70995,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 {}
         }
@@ -70160,9 +71016,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 {}
       }
     }
@@ -70328,7 +71184,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",
@@ -70352,7 +71208,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 (error51) {
           reject2(error51 instanceof Error ? error51 : new Error(String(error51)));
         }
@@ -70368,13 +71224,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@${version2}`] : ["add", "-g", `ccstatusline@${version2}`];
-  return new Promise((resolve5, reject2) => {
-    execFile2(executable, args, { timeout: GLOBAL_UPDATE_TIMEOUT_MS }, (error51) => {
+  return new Promise((resolve6, reject2) => {
+    execFile2(executable, args, {
+      timeout: GLOBAL_UPDATE_TIMEOUT_MS,
+      windowsHide: true,
+      ...getPackageManagerShellOptions(executable, platform4)
+    }, (error51) => {
       if (error51) {
         reject2(error51 instanceof Error ? error51 : new Error("Global update command failed"));
         return;
       }
-      resolve5();
+      resolve6();
     });
   });
 }
@@ -70808,6 +71668,7 @@ var SelectInput_default = SelectInput;
 // src/tui/components/ColorMenu.tsx
 init_ColorLevel();
 init_colors();
+init_gradient();
 init_input_guards();
 await init_widgets2();
 var import_react39 = __toESM(require_react(), 1);
@@ -71112,6 +71973,11 @@ var ColorMenu = ({ widgets, lineIndex, settings, onUpdate, onBack }) => {
   const [ansi256InputMode, setAnsi256InputMode] = import_react39.useState(false);
   const [ansi256Input, setAnsi256Input] = import_react39.useState("");
   const [showClearConfirm, setShowClearConfirm] = import_react39.useState(false);
+  const [gradientMode, setGradientMode] = import_react39.useState(false);
+  const [gradientIndex, setGradientIndex] = import_react39.useState(0);
+  const [gradientCustomStep, setGradientCustomStep] = import_react39.useState(null);
+  const [gradientStartHex, setGradientStartHex] = import_react39.useState("");
+  const [gradientHexInput, setGradientHexInput] = import_react39.useState("");
   const powerlineEnabled = settings.powerline.enabled;
   const colorableWidgets = widgets.filter((widget) => {
     if (widget.type === "separator") {
@@ -71191,6 +72057,62 @@ var ColorMenu = ({ widgets, lineIndex, settings, onUpdate, onBack }) => {
       }
       return;
     }
+    if (gradientMode) {
+      const exitGradient = () => {
+        setGradientMode(false);
+        setGradientCustomStep(null);
+        setGradientStartHex("");
+        setGradientHexInput("");
+      };
+      const applyGradientValue = (value) => {
+        const selectedWidget2 = colorableWidgets.find((widget) => widget.id === highlightedItemId);
+        if (selectedWidget2) {
+          onUpdate(setWidgetColor(widgets, selectedWidget2.id, value, false));
+        }
+        exitGradient();
+      };
+      if (gradientCustomStep) {
+        if (key.escape) {
+          setGradientCustomStep(null);
+          setGradientHexInput("");
+        } else if (key.return) {
+          if (gradientHexInput.length === 6) {
+            if (gradientCustomStep === "start") {
+              setGradientStartHex(gradientHexInput);
+              setGradientHexInput("");
+              setGradientCustomStep("end");
+            } else {
+              applyGradientValue(`gradient:${gradientStartHex}-${gradientHexInput}`);
+            }
+          }
+        } else if (key.backspace || key.delete) {
+          setGradientHexInput(gradientHexInput.slice(0, -1));
+        } else if (shouldInsertInput(input, key) && gradientHexInput.length < 6) {
+          const upperInput = input.toUpperCase();
+          if (/^[0-9A-F]$/.test(upperInput)) {
+            setGradientHexInput(gradientHexInput + upperInput);
+          }
+        }
+        return;
+      }
+      const total = GRADIENT_PRESET_NAMES.length + 1;
+      if (key.escape) {
+        exitGradient();
+      } else if (key.upArrow) {
+        setGradientIndex((gradientIndex - 1 + total) % total);
+      } else if (key.downArrow) {
+        setGradientIndex((gradientIndex + 1) % total);
+      } else if (key.return) {
+        if (gradientIndex < GRADIENT_PRESET_NAMES.length) {
+          applyGradientValue(`gradient:${GRADIENT_PRESET_NAMES[gradientIndex]}`);
+        } else {
+          setGradientStartHex("");
+          setGradientHexInput("");
+          setGradientCustomStep("start");
+        }
+      }
+      return;
+    }
     if (input && /^[0-9]$/.test(input)) {
       return;
     }
@@ -71210,6 +72132,14 @@ var ColorMenu = ({ widgets, lineIndex, settings, onUpdate, onBack }) => {
         setAnsi256InputMode(true);
         setAnsi256Input("");
       }
+    } else if (input === "g" || input === "G") {
+      if (highlightedItemId && highlightedItemId !== "back" && !editingBackground && settings.colorLevel >= 2) {
+        setGradientMode(true);
+        setGradientIndex(0);
+        setGradientCustomStep(null);
+        setGradientStartHex("");
+        setGradientHexInput("");
+      }
     } else if ((input === "s" || input === "S") && !key.ctrl) {
       if (!settings.powerline.enabled && !settings.defaultSeparator) {
         setShowSeparators(!showSeparators);
@@ -71361,6 +72291,13 @@ var ColorMenu = ({ widgets, lineIndex, settings, onUpdate, onBack }) => {
         displayName = `ANSI ${currentColor.substring(8)}`;
       } else if (currentColor.startsWith("hex:")) {
         displayName = `#${currentColor.substring(4)}`;
+      } else if (currentColor.startsWith("gradient:")) {
+        const body = currentColor.substring(9);
+        if (GRADIENT_PRESET_NAMES.includes(body.toLowerCase())) {
+          displayName = `Gradient: ${body.toLowerCase()}`;
+        } else {
+          displayName = `Gradient: ${body}`;
+        }
       } else {
         const colorOption = colorOptions.find((c) => c.value === currentColor);
         displayName = colorOption ? colorOption.name : currentColor;
@@ -71369,6 +72306,94 @@ var ColorMenu = ({ widgets, lineIndex, settings, onUpdate, onBack }) => {
       colorDisplay = applyColors(displayName, currentColor, undefined, false, level);
     }
   }
+  if (gradientMode) {
+    const level = getColorLevelString(settings.colorLevel);
+    const widgetName = selectedWidget ? getItemLabel(selectedWidget) : "";
+    if (gradientCustomStep) {
+      return /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Box_default, {
+        flexDirection: "column",
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Text, {
+            bold: true,
+            children: [
+              "Custom Gradient",
+              widgetName ? ` - ${widgetName}` : ""
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Box_default, {
+            marginTop: 1,
+            flexDirection: "column",
+            children: [
+              /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Text, {
+                children: gradientCustomStep === "start" ? "Enter START hex color (without #):" : "Enter END hex color (without #):"
+              }, undefined, false, undefined, this),
+              gradientCustomStep === "end" && /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Text, {
+                dimColor: true,
+                children: [
+                  "Start: #",
+                  gradientStartHex
+                ]
+              }, undefined, true, undefined, this),
+              /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Text, {
+                children: [
+                  "#",
+                  gradientHexInput,
+                  /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Text, {
+                    dimColor: true,
+                    children: gradientHexInput.length < 6 ? "_".repeat(6 - gradientHexInput.length) : ""
+                  }, undefined, false, undefined, this)
+                ]
+              }, undefined, true, undefined, this),
+              /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Text, {
+                children: " "
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Text, {
+                dimColor: true,
+                children: "Press Enter when done, ESC to go back"
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this);
+    }
+    return /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Box_default, {
+      flexDirection: "column",
+      children: [
+        /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Text, {
+          bold: true,
+          children: [
+            "Select Gradient",
+            widgetName ? ` - ${widgetName}` : ""
+          ]
+        }, undefined, true, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Box_default, {
+          marginTop: 1,
+          children: /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Text, {
+            dimColor: true,
+            children: "↑↓ to select, Enter to apply, ESC to cancel"
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Box_default, {
+          marginTop: 1,
+          flexDirection: "column",
+          children: [
+            GRADIENT_PRESET_NAMES.map((name, idx) => /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Text, {
+              children: [
+                idx === gradientIndex ? "▶ " : "  ",
+                applyColors(name, `gradient:${name}`, undefined, idx === gradientIndex, level)
+              ]
+            }, name, true, undefined, this)),
+            /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Text, {
+              children: [
+                gradientIndex === GRADIENT_PRESET_NAMES.length ? "▶ " : "  ",
+                "Custom (enter two hex stops)"
+              ]
+            }, "custom", true, undefined, this)
+          ]
+        }, undefined, true, undefined, this)
+      ]
+    }, undefined, true, undefined, this);
+  }
   if (showClearConfirm) {
     return /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Box_default, {
       flexDirection: "column",
@@ -71497,6 +72522,7 @@ var ColorMenu = ({ widgets, lineIndex, settings, onUpdate, onBack }) => {
               editingBackground ? "background" : "foreground",
               ", (f) to toggle bg/fg, (b)old,",
               settings.colorLevel === 3 ? " (h)ex," : settings.colorLevel === 2 ? " (a)nsi256," : "",
+              !editingBackground && settings.colorLevel >= 2 ? " (g)radient," : "",
               " ",
               "(r)eset, (c)lear all, ESC to go back"
             ]
@@ -71576,7 +72602,9 @@ var ColorMenu = ({ widgets, lineIndex, settings, onUpdate, onBack }) => {
   }, undefined, true, undefined, this);
 };
 // src/tui/components/GlobalOverridesMenu.tsx
+init_ColorLevel();
 init_colors();
+init_gradient();
 init_input_guards();
 await init_build2();
 var import_react40 = __toESM(require_react(), 1);
@@ -71590,6 +72618,11 @@ var GlobalOverridesMenu = ({ settings, onUpdate, onBack }) => {
   const [inheritColors, setInheritColors] = import_react40.useState(settings.inheritSeparatorColors);
   const [globalBold, setGlobalBold] = import_react40.useState(settings.globalBold);
   const [minimalistMode, setMinimalistMode] = import_react40.useState(settings.minimalistMode);
+  const [gradientMode, setGradientMode] = import_react40.useState(false);
+  const [gradientIndex, setGradientIndex] = import_react40.useState(0);
+  const [gradientCustomStep, setGradientCustomStep] = import_react40.useState(null);
+  const [gradientStartHex, setGradientStartHex] = import_react40.useState("");
+  const [gradientHexInput, setGradientHexInput] = import_react40.useState("");
   const isPowerlineEnabled = settings.powerline.enabled;
   const hasManualSeparators = settings.lines.some((line) => line.some((item) => item.type === "separator"));
   const bgColors = ["none", ...COLOR_MAP.filter((c) => c.isBackground).map((c) => c.name)];
@@ -71637,6 +72670,60 @@ var GlobalOverridesMenu = ({ settings, onUpdate, onBack }) => {
       }
     } else if (confirmingSeparator) {
       return;
+    } else if (gradientMode) {
+      const exitGradient = () => {
+        setGradientMode(false);
+        setGradientCustomStep(null);
+        setGradientStartHex("");
+        setGradientHexInput("");
+      };
+      const applyGradientValue = (value) => {
+        onUpdate({
+          ...settings,
+          overrideForegroundColor: value
+        });
+        exitGradient();
+      };
+      if (gradientCustomStep) {
+        if (key.escape) {
+          setGradientCustomStep(null);
+          setGradientHexInput("");
+        } else if (key.return) {
+          if (gradientHexInput.length === 6) {
+            if (gradientCustomStep === "start") {
+              setGradientStartHex(gradientHexInput);
+              setGradientHexInput("");
+              setGradientCustomStep("end");
+            } else {
+              applyGradientValue(`gradient:${gradientStartHex}-${gradientHexInput}`);
+            }
+          }
+        } else if (key.backspace || key.delete) {
+          setGradientHexInput(gradientHexInput.slice(0, -1));
+        } else if (shouldInsertInput(input, key) && gradientHexInput.length < 6) {
+          const upperInput = input.toUpperCase();
+          if (/^[0-9A-F]$/.test(upperInput)) {
+            setGradientHexInput(gradientHexInput + upperInput);
+          }
+        }
+        return;
+      }
+      const total = GRADIENT_PRESET_NAMES.length + 1;
+      if (key.escape) {
+        exitGradient();
+      } else if (key.upArrow) {
+        setGradientIndex((gradientIndex - 1 + total) % total);
+      } else if (key.downArrow) {
+        setGradientIndex((gradientIndex + 1) % total);
+      } else if (key.return) {
+        if (gradientIndex < GRADIENT_PRESET_NAMES.length) {
+          applyGradientValue(`gradient:${GRADIENT_PRESET_NAMES[gradientIndex]}`);
+        } else {
+          setGradientStartHex("");
+          setGradientHexInput("");
+          setGradientCustomStep("start");
+        }
+      }
     } else {
       if (key.escape) {
         onBack();
@@ -71691,6 +72778,12 @@ var GlobalOverridesMenu = ({ settings, onUpdate, onBack }) => {
         };
         onUpdate(updatedSettings);
       } else if (input === "g" || input === "G") {
+        setGradientMode(true);
+        setGradientIndex(0);
+        setGradientCustomStep(null);
+        setGradientStartHex("");
+        setGradientHexInput("");
+      } else if (input === "x" || input === "X") {
         const updatedSettings = {
           ...settings,
           overrideForegroundColor: undefined
@@ -71699,6 +72792,87 @@ var GlobalOverridesMenu = ({ settings, onUpdate, onBack }) => {
       }
     }
   });
+  if (gradientMode) {
+    const level = getColorLevelString(settings.colorLevel);
+    if (gradientCustomStep) {
+      return /* @__PURE__ */ jsx_dev_runtime13.jsxDEV(Box_default, {
+        flexDirection: "column",
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime13.jsxDEV(Text, {
+            bold: true,
+            children: "Custom Gradient - Override FG Color"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime13.jsxDEV(Box_default, {
+            marginTop: 1,
+            flexDirection: "column",
+            children: [
+              /* @__PURE__ */ jsx_dev_runtime13.jsxDEV(Text, {
+                children: gradientCustomStep === "start" ? "Enter START hex color (without #):" : "Enter END hex color (without #):"
+              }, undefined, false, undefined, this),
+              gradientCustomStep === "end" && /* @__PURE__ */ jsx_dev_runtime13.jsxDEV(Text, {
+                dimColor: true,
+                children: [
+                  "Start: #",
+                  gradientStartHex
+                ]
+              }, undefined, true, undefined, this),
+              /* @__PURE__ */ jsx_dev_runtime13.jsxDEV(Text, {
+                children: [
+                  "#",
+                  gradientHexInput,
+                  /* @__PURE__ */ jsx_dev_runtime13.jsxDEV(Text, {
+                    dimColor: true,
+                    children: gradientHexInput.length < 6 ? "_".repeat(6 - gradientHexInput.length) : ""
+                  }, undefined, false, undefined, this)
+                ]
+              }, undefined, true, undefined, this),
+              /* @__PURE__ */ jsx_dev_runtime13.jsxDEV(Text, {
+                children: " "
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsx_dev_runtime13.jsxDEV(Text, {
+                dimColor: true,
+                children: "Press Enter when done, ESC to go back"
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this);
+    }
+    return /* @__PURE__ */ jsx_dev_runtime13.jsxDEV(Box_default, {
+      flexDirection: "column",
+      children: [
+        /* @__PURE__ */ jsx_dev_runtime13.jsxDEV(Text, {
+          bold: true,
+          children: "Select Gradient - Override FG Color"
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime13.jsxDEV(Box_default, {
+          marginTop: 1,
+          children: /* @__PURE__ */ jsx_dev_runtime13.jsxDEV(Text, {
+            dimColor: true,
+            children: "↑↓ to select, Enter to apply, ESC to cancel"
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime13.jsxDEV(Box_default, {
+          marginTop: 1,
+          flexDirection: "column",
+          children: [
+            GRADIENT_PRESET_NAMES.map((name, idx) => /* @__PURE__ */ jsx_dev_runtime13.jsxDEV(Text, {
+              children: [
+                idx === gradientIndex ? "▶ " : "  ",
+                applyColors(name, `gradient:${name}`, undefined, idx === gradientIndex, level)
+              ]
+            }, name, true, undefined, this)),
+            /* @__PURE__ */ jsx_dev_runtime13.jsxDEV(Text, {
+              children: [
+                gradientIndex === GRADIENT_PRESET_NAMES.length ? "▶ " : "  ",
+                "Custom (enter two hex stops)"
+              ]
+            }, "custom", true, undefined, this)
+          ]
+        }, undefined, true, undefined, this)
+      ]
+    }, undefined, true, undefined, this);
+  }
   return /* @__PURE__ */ jsx_dev_runtime13.jsxDEV(Box_default, {
     flexDirection: "column",
     children: [
@@ -71864,6 +73038,13 @@ var GlobalOverridesMenu = ({ settings, onUpdate, onBack }) => {
                     color: "gray",
                     children: "(none)"
                   }, undefined, false, undefined, this);
+                } else if (fgColor.startsWith("gradient:")) {
+                  const body = fgColor.substring(9);
+                  const displayName = GRADIENT_PRESET_NAMES.includes(body.toLowerCase()) ? `Gradient: ${body.toLowerCase()}` : `Gradient: ${body}`;
+                  const level = getColorLevelString(settings.colorLevel);
+                  return /* @__PURE__ */ jsx_dev_runtime13.jsxDEV(Text, {
+                    children: applyColors(displayName, fgColor, undefined, false, level)
+                  }, undefined, false, undefined, this);
                 } else {
                   const displayName = getColorDisplayName(fgColor);
                   const fgChalk = getChalkColor(fgColor, "ansi16", false);
@@ -71875,7 +73056,7 @@ var GlobalOverridesMenu = ({ settings, onUpdate, onBack }) => {
               })(),
               /* @__PURE__ */ jsx_dev_runtime13.jsxDEV(Text, {
                 dimColor: true,
-                children: " - (f) cycle, (g) clear"
+                children: " - (f) cycle, (g) gradient, (x) clear"
               }, undefined, false, undefined, this)
             ]
           }, undefined, true, undefined, this),
@@ -72009,19 +73190,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@${currentVersion}\` globally and Claude Code runs \`ccstatusline\`. Fast per-render and only changes when you update.`;
+  return `Installs \`ccstatusline@${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
     }
   ];
 }
@@ -72091,7 +73272,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") {
@@ -73715,7 +74896,7 @@ var UninstallMenu = ({
 // src/tui/components/PowerlineSetup.tsx
 await init_build2();
 var import_react46 = __toESM(require_react(), 1);
-import * as os12 from "os";
+import * as os13 from "os";
 
 // src/utils/powerline-settings.ts
 init_colors();
@@ -74353,6 +75534,8 @@ var PowerlineSetup = ({
   const [confirmingEnable, setConfirmingEnable] = import_react46.useState(false);
   const [confirmingFontInstall, setConfirmingFontInstall] = import_react46.useState(false);
   const hasSeparatorItems = settings.lines.some((line) => line.some((item) => item.type === "separator" || item.type === "flex-separator"));
+  const hasGlobalFgOverride = Boolean(settings.overrideForegroundColor && settings.overrideForegroundColor !== "none");
+  const globalOverrideMessage = hasGlobalFgOverride ? "⚠ Global override for FG active" : null;
   use_input_default((input, key) => {
     if (fontInstallMessage || installingFonts) {
       if (fontInstallMessage && !key.escape) {
@@ -74445,10 +75628,22 @@ var PowerlineSetup = ({
   return /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Box_default, {
     flexDirection: "column",
     children: [
-      !confirmingFontInstall && !installingFonts && !fontInstallMessage && /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
-        bold: true,
-        children: "Powerline Setup"
-      }, undefined, false, undefined, this),
+      !confirmingFontInstall && !installingFonts && !fontInstallMessage && /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Box_default, {
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
+            bold: true,
+            children: "Powerline Setup"
+          }, undefined, false, undefined, this),
+          globalOverrideMessage && /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
+            color: "yellow",
+            dimColor: true,
+            children: [
+              ".  ",
+              globalOverrideMessage
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
       confirmingFontInstall ? /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Box_default, {
         flexDirection: "column",
         children: [
@@ -74480,7 +75675,7 @@ var PowerlineSetup = ({
                   }, undefined, false, undefined, this)
                 ]
               }, undefined, true, undefined, this),
-              os12.platform() === "darwin" && /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(jsx_dev_runtime21.Fragment, {
+              os13.platform() === "darwin" && /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(jsx_dev_runtime21.Fragment, {
                 children: [
                   /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                     dimColor: true,
@@ -74496,7 +75691,7 @@ var PowerlineSetup = ({
                   }, undefined, false, undefined, this)
                 ]
               }, undefined, true, undefined, this),
-              os12.platform() === "linux" && /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(jsx_dev_runtime21.Fragment, {
+              os13.platform() === "linux" && /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(jsx_dev_runtime21.Fragment, {
                 children: [
                   /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                     dimColor: true,
@@ -74512,7 +75707,7 @@ var PowerlineSetup = ({
                   }, undefined, false, undefined, this)
                 ]
               }, undefined, true, undefined, this),
-              os12.platform() === "win32" && /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(jsx_dev_runtime21.Fragment, {
+              os13.platform() === "win32" && /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(jsx_dev_runtime21.Fragment, {
                 children: [
                   /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                     dimColor: true,
@@ -74734,7 +75929,7 @@ var PowerlineSetup = ({
                 children: [
                   /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                     dimColor: true,
-                    children: "When enabled, global overrides are disabled and powerline separators are used"
+                    children: "Powerline mode uses its own separator system"
                   }, undefined, false, undefined, this),
                   /* @__PURE__ */ jsx_dev_runtime21.jsxDEV(Text, {
                     dimColor: true,
@@ -74789,7 +75984,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",
@@ -74797,6 +75995,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.`
     }
   ];
 }
@@ -74816,14 +76021,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_react47.useState(false);
+  const [editingGitCacheTtl, setEditingGitCacheTtl] = import_react47.useState(false);
   const [refreshInput, setRefreshInput] = import_react47.useState(() => getRefreshInputValue(currentInterval));
+  const [gitCacheTtlInput, setGitCacheTtlInput] = import_react47.useState(() => String(gitCacheTtlSeconds));
   const [validationError, setValidationError] = import_react47.useState(null);
   use_input_default((input, key) => {
     if (editingRefreshInterval) {
@@ -74859,6 +76081,33 @@ var RefreshIntervalMenu = ({
       }
       return;
     }
+    if (editingGitCacheTtl) {
+      if (key.return) {
+        const error51 = validateGitCacheTtlInput(gitCacheTtlInput);
+        if (error51) {
+          setValidationError(error51);
+        } 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();
     }
@@ -74894,16 +76143,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_runtime22.jsxDEV(Box_default, {
+        marginTop: 1,
+        flexDirection: "column",
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Text, {
+            children: [
+              "Enter Git cache TTL in seconds (0-60):",
+              " ",
+              gitCacheTtlInput,
+              gitCacheTtlInput.length > 0 ? "s" : ""
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Text, {
+            children: " "
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime22.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_runtime22.jsxDEV(Text, {
+            color: "red",
+            children: validationError
+          }, undefined, false, undefined, this) : /* @__PURE__ */ jsx_dev_runtime22.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_runtime22.jsxDEV(Text, {
+            dimColor: true,
+            children: "Press Enter to confirm, ESC to cancel."
+          }, undefined, false, undefined, this)
+        ]
       }, undefined, true, undefined, this) : /* @__PURE__ */ jsx_dev_runtime22.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)
@@ -74954,6 +76240,7 @@ var renderSingleLine = (widgets, terminalWidth, settings, lineIndex, globalSepar
     terminalWidth,
     isPreview: true,
     minimalist: settings.minimalistMode,
+    gitCacheTtlSeconds: settings.gitCacheTtlSeconds,
     lineIndex,
     globalSeparatorIndex,
     globalPowerlineThemeIndex
@@ -74970,7 +76257,12 @@ var StatusLinePreview = ({ lines, terminalWidth, settings, onTruncationChange })
   const { renderedLines, anyTruncated } = import_react48.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;
@@ -76504,6 +77796,7 @@ ${GITHUB_REPO_URL}`,
           screen === "refreshInterval" && /* @__PURE__ */ jsx_dev_runtime27.jsxDEV(RefreshIntervalMenu, {
             currentInterval: currentRefreshInterval,
             supportsRefreshInterval,
+            gitCacheTtlSeconds: settings.gitCacheTtlSeconds,
             onUpdate: (interval) => {
               const previous = currentRefreshInterval;
               setCurrentRefreshInterval(interval);
@@ -76521,6 +77814,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");
             }
@@ -76643,10 +77947,11 @@ init_colors();
 // 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 MIN_CTX_PCT = 1;
 var FRESH_PREV_CTX_PCT = -1;
 var MAX_CACHE_FILE_BYTES = 4096;
 var SESSION_ID_HASH_HEX_LEN = 32;
@@ -76670,7 +77975,7 @@ function normalizeOptions(options) {
   return { dropThreshold, windowSize: options.windowSize ?? null };
 }
 function detectCompaction(currentCtxPct, state, options = DEFAULT_DROP_THRESHOLD) {
-  if (!Number.isFinite(currentCtxPct) || currentCtxPct < 0) {
+  if (!Number.isFinite(currentCtxPct) || currentCtxPct < MIN_CTX_PCT) {
     return state;
   }
   const { dropThreshold, windowSize } = normalizeOptions(options);
@@ -76689,8 +77994,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, "_");
@@ -76700,18 +78005,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 {
@@ -76719,7 +78024,7 @@ function loadCompactionState(sessionId) {
   } finally {
     if (fd !== null) {
       try {
-        fs14.closeSync(fd);
+        fs15.closeSync(fd);
       } catch {}
     }
   }
@@ -76727,20 +78032,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 {}
     }
   }
@@ -76751,27 +78056,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);
@@ -76825,14 +78130,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 {}
 }
@@ -77032,7 +78337,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) {
@@ -77098,7 +78403,8 @@ async function renderMultipleLines(data) {
     skillsMetrics,
     compactionData: hasCompactionWidget ? { count: compactionCount } : null,
     isPreview: false,
-    minimalist: settings.minimalistMode
+    minimalist: settings.minimalistMode,
+    gitCacheTtlSeconds: settings.gitCacheTtlSeconds
   };
   const preRenderedLines = preRenderAllWidgets(lines, settings, context);
   const preCalculatedMaxWidths = calculateMaxWidthsFromPreRendered(preRenderedLines, settings);