ccstatusline 2.2.18 → 2.2.19

package/dist/ccstatusline.js

@@ -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 {
@@ -54563,7 +54749,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 +54761,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 +54794,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 +54827,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 +54860,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 +54906,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
   };
 });
@@ -56715,20 +56905,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 +56926,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 +56955,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 +56974,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 +56987,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 +57010,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 +57027,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.19";
 var init_terminal = () => {};
 
 // src/utils/renderer.ts
@@ -58915,7 +59116,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 +59784,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 +59841,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 +60189,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 +60258,7 @@ function parseProxyResponse(socket) {
       }
       debug("got proxy server response: %o %o", firstLine, headers);
       cleanup();
-      resolve({
+      resolve2({
         connect: {
           statusCode,
           statusText,
@@ -60196,10 +60398,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 +60460,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) {
@@ -60361,7 +60563,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 +60577,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 +60597,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 +60611,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 +60619,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 +60641,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 +60696,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 +60754,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 +60792,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 +60806,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 +60857,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 +60947,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 +60958,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 +61006,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 +61029,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 +61081,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 +61195,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 +61345,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 +61558,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 +63040,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 +63113,10 @@ function buildRelative(cwd2, root) {
     return p[p.length - 1] === "/" && result2 !== "" ? `${result2}/` : result2 || ".";
   };
 }
-function splitPattern(path4) {
+function splitPattern(path5) {
   var _result$parts;
-  const result2 = import_picomatch.default.scan(path4, splitPatternOptions);
-  return ((_result$parts = result2.parts) === null || _result$parts === undefined ? undefined : _result$parts.length) ? result2.parts : [path4];
+  const result2 = import_picomatch.default.scan(path5, splitPatternOptions);
+  return ((_result$parts = result2.parts) === null || _result$parts === undefined ? undefined : _result$parts.length) ? result2.parts : [path5];
 }
 function isDynamicPattern(pattern, options) {
   if ((options === null || options === undefined ? undefined : options.caseSensitiveMatch) === false)
@@ -63029,14 +63232,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);
@@ -63073,7 +63276,7 @@ function getOptions2(options) {
     ...defaultOptions,
     ...options
   };
-  opts.cwd = (opts.cwd instanceof URL ? fileURLToPath(opts.cwd) : resolve2(opts.cwd)).replace(BACKSLASHES, "/");
+  opts.cwd = (opts.cwd instanceof URL ? fileURLToPath(opts.cwd) : resolve3(opts.cwd)).replace(BACKSLASHES, "/");
   opts.ignore = ensureStringArray(opts.ignore);
   opts.fs && (opts.fs = {
     readdir: opts.fs.readdir || readdir,
@@ -63081,7 +63284,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,7 +63303,7 @@ function globSync(globInput, options) {
   const [crawler, relative2] = getCrawler(globInput, options);
   return crawler ? formatPaths(crawler.sync(), relative2) : [];
 }
-var import_picomatch, isReadonlyArray, BACKSLASHES, isWin, ONLY_PARENT_DIRECTORIES, WIN32_ROOT_DIR, isRoot, splitPatternOptions, POSIX_UNESCAPED_GLOB_SYMBOLS, WIN32_UNESCAPED_GLOB_SYMBOLS, escapePosixPath = (path4) => path4.replace(POSIX_UNESCAPED_GLOB_SYMBOLS, "\\$&"), escapeWin32Path = (path4) => path4.replace(WIN32_UNESCAPED_GLOB_SYMBOLS, "\\$&"), escapePath, PARENT_DIRECTORY, ESCAPING_BACKSLASHES, defaultOptions;
+var import_picomatch, isReadonlyArray, BACKSLASHES, isWin, ONLY_PARENT_DIRECTORIES, WIN32_ROOT_DIR, isRoot, splitPatternOptions, POSIX_UNESCAPED_GLOB_SYMBOLS, WIN32_UNESCAPED_GLOB_SYMBOLS, escapePosixPath = (path5) => path5.replace(POSIX_UNESCAPED_GLOB_SYMBOLS, "\\$&"), escapeWin32Path = (path5) => path5.replace(WIN32_UNESCAPED_GLOB_SYMBOLS, "\\$&"), escapePath, PARENT_DIRECTORY, ESCAPING_BACKSLASHES, defaultOptions;
 var init_dist7 = __esm(() => {
   init_dist6();
   import_picomatch = __toESM(require_picomatch2(), 1);
@@ -63127,7 +63330,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 +63341,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 +63351,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 +63373,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 +63381,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 +63499,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 +63527,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 +63553,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 +63584,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 +63630,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 +63680,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 +63894,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 +63919,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 +63936,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
@@ -64148,7 +64351,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 +64496,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 +64648,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 +65286,7 @@ var init_JjRevision = __esm(() => {
 });
 
 // src/widgets/ClaudeAccountEmail.ts
-import * as fs8 from "fs";
+import * as fs9 from "fs";
 
 class ClaudeAccountEmailWidget {
   getDefaultColor() {
@@ -65105,7 +65309,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 +65663,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 +65678,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 +65727,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 +65747,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 +65774,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--) {
@@ -68383,11 +68587,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 +68600,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 +68615,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 +68645,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 +68696,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 +68716,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 +68751,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 +68762,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 +68792,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 +68808,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 +68823,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 +68841,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 +68869,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 +68961,7 @@ function classifyInstallation(command, metadata) {
 }
 async function loadSavedSettingsForHookSync() {
   const configPath = getConfigPath();
-  if (!fs11.existsSync(configPath)) {
+  if (!fs12.existsSync(configPath)) {
     return null;
   }
   try {
@@ -68853,19 +69062,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 };
@@ -68900,9 +69109,9 @@ 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",
@@ -69504,7 +69713,7 @@ 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 getPackageManagerExecutable(packageManager, platform2 = process.platform) {
@@ -69531,11 +69740,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 [];
@@ -69545,12 +69762,13 @@ function getNpmGlobalBinDir(platform2) {
   try {
     const prefix = execFileSync5(getPackageManagerExecutable("npm", platform2), ["prefix", "-g"], {
       encoding: "utf-8",
-      timeout: COMMAND_LOOKUP_TIMEOUT_MS
+      timeout: COMMAND_LOOKUP_TIMEOUT_MS,
+      windowsHide: true
     }).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 +69777,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 +69872,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 +69921,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 +69954,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;
@@ -69750,7 +69969,8 @@ function getNpmGlobalPackageVersion(platform2) {
   try {
     const rootDir = execFileSync6(getPackageManagerExecutable("npm", platform2), ["root", "-g"], {
       encoding: "utf-8",
-      timeout: VERSION_LOOKUP_TIMEOUT_MS
+      timeout: VERSION_LOOKUP_TIMEOUT_MS,
+      windowsHide: true
     }).trim();
     return rootDir ? readPackageVersion(appendPathSegment(appendPathSegment(rootDir, "ccstatusline"), "package.json")) : null;
   } catch {
@@ -69856,20 +70076,20 @@ 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 }, (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 +70148,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 +70176,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 +70194,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 +70227,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 +70264,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 +70290,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 +70348,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 +70365,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 +70386,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 +70554,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 +70578,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 +70594,13 @@ 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 }, (error51) => {
       if (error51) {
         reject2(error51 instanceof Error ? error51 : new Error("Global update command failed"));
         return;
       }
-      resolve5();
+      resolve6();
     });
   });
 }
@@ -72009,19 +72235,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 +72317,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 +73941,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();
@@ -74480,7 +74706,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 +74722,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 +74738,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,
@@ -74789,7 +75015,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 +75026,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 +75052,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 +75112,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 +75174,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 +75271,7 @@ var renderSingleLine = (widgets, terminalWidth, settings, lineIndex, globalSepar
     terminalWidth,
     isPreview: true,
     minimalist: settings.minimalistMode,
+    gitCacheTtlSeconds: settings.gitCacheTtlSeconds,
     lineIndex,
     globalSeparatorIndex,
     globalPowerlineThemeIndex
@@ -74970,7 +75288,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 +76827,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 +76845,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,9 +76978,9 @@ 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 FRESH_PREV_CTX_PCT = -1;
 var MAX_CACHE_FILE_BYTES = 4096;
@@ -76689,8 +77024,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 +77035,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 +77054,7 @@ function loadCompactionState(sessionId) {
   } finally {
     if (fd !== null) {
       try {
-        fs14.closeSync(fd);
+        fs15.closeSync(fd);
       } catch {}
     }
   }
@@ -76727,20 +77062,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 +77086,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 +77160,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 +77367,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 +77433,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);