ccstatusline 2.2.23 → 2.2.25

package/dist/ccstatusline.js

@@ -53003,13 +53003,14 @@ var init_Widget = __esm(() => {
 });
 
 // src/types/Settings.ts
-var CURRENT_VERSION = 3, InstallationMetadataSchema, SettingsSchema_v1, SettingsSchema, DEFAULT_SETTINGS;
+var CURRENT_VERSION = 3, DefaultPaddingSideSchema, InstallationMetadataSchema, SettingsSchema_v1, SettingsSchema, DEFAULT_SETTINGS;
 var init_Settings = __esm(() => {
   init_zod();
   init_ColorLevel();
   init_FlexMode();
   init_PowerlineConfig();
   init_Widget();
+  DefaultPaddingSideSchema = exports_external.enum(["both", "left", "right"]);
   InstallationMetadataSchema = exports_external.discriminatedUnion("method", [
     exports_external.object({
       method: exports_external.literal("auto-update"),
@@ -53060,6 +53061,7 @@ var init_Settings = __esm(() => {
     colorLevel: ColorLevelSchema.default(2),
     defaultSeparator: exports_external.string().optional(),
     defaultPadding: exports_external.string().optional(),
+    defaultPaddingSide: DefaultPaddingSideSchema.default("both"),
     inheritSeparatorColors: exports_external.boolean().default(false),
     overrideBackgroundColor: exports_external.string().optional(),
     overrideForegroundColor: exports_external.string().optional(),
@@ -55591,199 +55593,70 @@ var init_GitUntrackedFiles = __esm(() => {
   init_git_no_git();
 });
 
-// src/widgets/GitCleanStatus.ts
-class GitCleanStatusWidget {
-  getDefaultColor() {
-    return "green";
-  }
-  getDescription() {
-    return "Shows ✓ when the working tree is clean and ✗ when it is dirty";
-  }
-  getDisplayName() {
-    return "Git Clean Status";
-  }
-  getCategory() {
-    return "Git";
-  }
-  getEditorDisplay(item) {
-    return {
-      displayText: this.getDisplayName(),
-      modifierText: getHideNoGitModifierText(item)
-    };
-  }
-  handleEditorAction(action, item) {
-    return handleToggleNoGitAction(action, item);
-  }
-  render(item, context, _settings) {
-    const hideNoGit = isHideNoGitEnabled(item);
-    if (context.isPreview) {
-      return item.rawValue ? "clean" : "✓";
-    }
-    if (!isInsideGitWorkTree(context)) {
-      return hideNoGit ? null : "(no git)";
-    }
-    const clean = this.isClean(context);
-    if (item.rawValue) {
-      return clean ? "clean" : "dirty";
-    }
-    return clean ? "✓" : "✗";
-  }
-  isClean(context) {
-    const status = getGitStatus(context);
-    return !status.staged && !status.unstaged && !status.untracked && !status.conflicts;
-  }
-  getCustomKeybinds() {
-    return getHideNoGitKeybinds();
-  }
-  supportsRawValue() {
-    return true;
-  }
-  supportsColors(_item) {
-    return true;
-  }
-}
-var init_GitCleanStatus = __esm(() => {
-  init_git();
-  init_git_no_git();
-});
-
-// src/widgets/GitRootDir.ts
-class GitRootDirWidget {
-  getDefaultColor() {
-    return "cyan";
-  }
-  getDescription() {
-    return "Shows the git repository root directory name";
-  }
-  getDisplayName() {
-    return "Git Root Dir";
-  }
-  getCategory() {
-    return "Git";
-  }
-  getEditorDisplay(item) {
-    const ideLinkMode = this.getIdeLinkMode(item);
-    const modifiers = [];
-    const noGitText = getHideNoGitModifierText(item);
-    if (noGitText)
-      modifiers.push("hide 'no git'");
-    if (ideLinkMode)
-      modifiers.push(IDE_LINK_LABELS[ideLinkMode]);
-    const maxWidthText = getMaxWidthModifier(item);
-    if (maxWidthText)
-      modifiers.push(maxWidthText);
-    return {
-      displayText: this.getDisplayName(),
-      modifierText: makeModifierText(modifiers)
-    };
-  }
-  handleEditorAction(action, item) {
-    if (action === TOGGLE_LINK_ACTION2) {
-      return this.cycleIdeLinkMode(item);
-    }
-    return handleToggleNoGitAction(action, item);
-  }
-  render(item, context, _settings) {
-    const hideNoGit = isHideNoGitEnabled(item);
-    const ideLinkMode = this.getIdeLinkMode(item);
-    if (context.isPreview) {
-      const name2 = "my-repo";
-      return ideLinkMode ? renderOsc8Link(buildIdeFileUrl("/Users/example/my-repo", ideLinkMode), name2) : name2;
-    }
-    if (!isInsideGitWorkTree(context)) {
-      return hideNoGit ? null : "no git";
-    }
-    const rootDir = this.getGitRootDir(context);
-    if (!rootDir) {
-      return hideNoGit ? null : "no git";
-    }
-    const name = applyMaxWidth(this.getRootDirName(rootDir), item.maxWidth);
-    if (ideLinkMode) {
-      return renderOsc8Link(buildIdeFileUrl(rootDir, ideLinkMode), name);
-    }
-    return name;
-  }
-  getGitRootDir(context) {
-    return runGit("rev-parse --show-toplevel", context);
-  }
-  getRootDirName(rootDir) {
-    const trimmedRootDir = rootDir.replace(/[\\/]+$/, "");
-    const normalizedRootDir = trimmedRootDir.length > 0 ? trimmedRootDir : rootDir;
-    const parts = normalizedRootDir.split(/[\\/]/).filter(Boolean);
-    const lastPart = parts[parts.length - 1];
-    return lastPart && lastPart.length > 0 ? lastPart : normalizedRootDir;
-  }
-  getCustomKeybinds() {
-    return [
-      ...getHideNoGitKeybinds(),
-      { key: "l", label: "(l)ink to IDE", action: TOGGLE_LINK_ACTION2 },
-      getMaxWidthKeybind()
-    ];
-  }
-  renderEditor(props) {
-    if (props.action === MAX_WIDTH_ACTION) {
-      return renderMaxWidthEditor(props);
-    }
-    return null;
-  }
-  supportsRawValue() {
-    return false;
-  }
-  supportsColors(item) {
-    return true;
-  }
-  getIdeLinkMode(item) {
-    const configuredMode = item.metadata?.[IDE_LINK_KEY];
-    if (configuredMode && IDE_LINK_MODES.includes(configuredMode)) {
-      return configuredMode;
-    }
-    if (isMetadataFlagEnabled(item, LEGACY_CURSOR_LINK_KEY)) {
-      return "cursor";
-    }
-    return null;
-  }
-  cycleIdeLinkMode(item) {
-    const currentMode = this.getIdeLinkMode(item);
-    const currentIndex = currentMode ? IDE_LINK_MODES.indexOf(currentMode) : -1;
-    const nextMode = currentIndex === IDE_LINK_MODES.length - 1 ? null : IDE_LINK_MODES[currentIndex + 1] ?? null;
-    const {
-      [IDE_LINK_KEY]: removedIdeLink,
-      [LEGACY_CURSOR_LINK_KEY]: removedLegacyLink,
-      ...restMetadata
-    } = item.metadata ?? {};
-    return {
-      ...item,
-      metadata: nextMode ? {
-        ...restMetadata,
-        [IDE_LINK_KEY]: nextMode
-      } : Object.keys(restMetadata).length > 0 ? restMetadata : undefined
-    };
-  }
-}
-var IDE_LINK_KEY = "linkToIDE", LEGACY_CURSOR_LINK_KEY = "linkToCursor", TOGGLE_LINK_ACTION2 = "toggle-link", IDE_LINK_LABELS;
-var init_GitRootDir = __esm(async () => {
-  init_git();
-  init_hyperlink();
-  init_git_no_git();
-  await init_max_width();
-  IDE_LINK_LABELS = {
-    vscode: "link-vscode",
-    cursor: "link-cursor"
-  };
-});
-
 // src/utils/git-review-cache.ts
-import { execFileSync as execFileSync2 } from "child_process";
 import {
+  execFileSync as execFileSync2,
+  spawn
+} from "child_process";
+import {
+  closeSync,
   existsSync as existsSync2,
   mkdirSync as mkdirSync2,
+  openSync,
   readFileSync as readFileSync3,
   statSync as statSync2,
+  unlinkSync,
   writeFileSync as writeFileSync2
 } from "fs";
 import { createHash as createHash2 } from "node:crypto";
 import os4 from "node:os";
 import path2 from "node:path";
+function readField(entry, key) {
+  const value = entry[key];
+  return typeof value === "string" ? value.toUpperCase() : "";
+}
+function classifyCheck(entry) {
+  if (typeof entry.status === "string") {
+    if (entry.status.toUpperCase() !== "COMPLETED")
+      return "pending";
+    const conclusion = readField(entry, "conclusion");
+    if (conclusion === "SUCCESS")
+      return "success";
+    if (conclusion === "NEUTRAL" || conclusion === "SKIPPED")
+      return "ignored";
+    return "failed";
+  }
+  const state = readField(entry, "state");
+  if (state === "SUCCESS")
+    return "success";
+  if (state === "PENDING" || state === "EXPECTED")
+    return "pending";
+  return "failed";
+}
+function computeCiRollup(rollup) {
+  if (!Array.isArray(rollup) || rollup.length === 0)
+    return null;
+  let failing = 0;
+  let pending = 0;
+  let success2 = 0;
+  let seen = 0;
+  for (const entry of rollup) {
+    if (typeof entry !== "object" || entry === null)
+      continue;
+    seen++;
+    const kind = classifyCheck(entry);
+    if (kind === "failed")
+      failing++;
+    else if (kind === "pending")
+      pending++;
+    else if (kind === "success")
+      success2++;
+  }
+  if (seen === 0)
+    return null;
+  const state = failing > 0 ? "failing" : pending > 0 ? "pending" : "passing";
+  return { state, failing, pending, success: success2 };
+}
 function getCacheDir2(deps) {
   return path2.join(deps.getHomedir(), ".cache", "ccstatusline");
 }
@@ -55822,35 +55695,66 @@ 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 isGitReviewData(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.number === "number" && typeof candidate.url === "string";
+}
+function decodeCache(content) {
+  if (content.length === 0) {
+    return { data: null, checksQueried: true };
+  }
+  const parsed = JSON.parse(content);
+  if (typeof parsed === "object" && parsed !== null) {
+    const stored = parsed;
+    if (stored.version === 1 && typeof stored.checksQueried === "boolean" && (stored.data === null || isGitReviewData(stored.data))) {
+      return {
+        data: stored.data,
+        checksQueried: stored.data === null || stored.checksQueried
+      };
+    }
+  }
+  if (isGitReviewData(parsed)) {
+    return {
+      data: parsed,
+      checksQueried: parsed.checks !== undefined
+    };
+  }
+  return "miss";
+}
 function readCache(cachePath, deps) {
   try {
     if (!deps.existsSync(cachePath)) {
       return "miss";
     }
     const age = deps.now() - deps.statSync(cachePath).mtimeMs;
-    if (age > GIT_REVIEW_CACHE_TTL) {
-      return "miss";
-    }
     const content = deps.readFileSync(cachePath, "utf-8").trim();
-    if (content.length === 0) {
-      return null;
-    }
-    const data = JSON.parse(content);
-    if (typeof data.number !== "number" || typeof data.url !== "string") {
+    const decoded = decodeCache(content);
+    if (decoded === "miss") {
       return "miss";
     }
-    return data;
+    return {
+      ...decoded,
+      stale: age > GIT_REVIEW_CACHE_TTL
+    };
   } catch {
     return "miss";
   }
 }
-function writeCache(cachePath, data, deps) {
+function writeCache(cachePath, data, checksQueried, deps) {
   try {
     const cacheDir = getGitReviewCacheDir(deps);
     if (!deps.existsSync(cacheDir)) {
       deps.mkdirSync(cacheDir, { recursive: true });
     }
-    deps.writeFileSync(cachePath, data ? JSON.stringify(data) : "", "utf-8");
+    const stored = {
+      version: 1,
+      data,
+      checksQueried: data === null || checksQueried
+    };
+    deps.writeFileSync(cachePath, JSON.stringify(stored), "utf-8");
   } catch {}
 }
 function getOriginUrl(cwd2, deps) {
@@ -55931,11 +55835,18 @@ function getProviderCandidates(cwd2, deps) {
   }
   return authed;
 }
-function isCliAvailable(cli, deps) {
+function getRemainingTimeout(deadline, deps) {
+  const remaining = deadline - deps.now();
+  if (remaining <= 0) {
+    throw new GitReviewDeadlineError("Git review lookup deadline exceeded");
+  }
+  return Math.max(1, Math.min(CLI_TIMEOUT, remaining));
+}
+function isCliAvailable(cli, deadline, deps) {
   try {
     deps.execFileSync(cli, ["--version"], {
       stdio: ["pipe", "pipe", "ignore"],
-      timeout: CLI_TIMEOUT,
+      timeout: getRemainingTimeout(deadline, deps),
       windowsHide: true
     });
     return true;
@@ -55966,7 +55877,33 @@ function mapGlabState(state) {
     return "LOCKED";
   return state.toUpperCase();
 }
-function fetchFromGh(cwd2, repoRef, deps) {
+function errorText(error51) {
+  if (!(error51 instanceof Error)) {
+    return "";
+  }
+  const stderr = "stderr" in error51 ? error51.stderr : undefined;
+  const stderrText = Buffer.isBuffer(stderr) ? stderr.toString("utf8") : stderr ?? "";
+  return `${error51.message}
+${stderrText}`.toLowerCase();
+}
+function isCiFieldUnavailableError(error51) {
+  const text = errorText(error51);
+  return text.includes("statuscheckrollup") || text.includes("resource not accessible by integration");
+}
+function queryGhPr(cwd2, args, fields, deadline, deps) {
+  const output = deps.execFileSync("gh", [...args, "--json", fields], {
+    encoding: "utf8",
+    stdio: ["pipe", "pipe", "pipe"],
+    cwd: cwd2,
+    timeout: getRemainingTimeout(deadline, deps),
+    windowsHide: true
+  }).trim();
+  if (output.length === 0) {
+    return null;
+  }
+  return JSON.parse(output);
+}
+function fetchFromGh(cwd2, repoRef, includeChecks, deadline, deps) {
   const args = ["pr", "view"];
   if (repoRef) {
     const branch = getCurrentBranch(cwd2, deps);
@@ -55975,18 +55912,22 @@ function fetchFromGh(cwd2, repoRef, deps) {
     }
     args.push(branch, "--repo", repoRef);
   }
-  args.push("--json", "url,number,title,state,reviewDecision");
-  const output = deps.execFileSync("gh", args, {
-    encoding: "utf8",
-    stdio: ["pipe", "pipe", "ignore"],
-    cwd: cwd2,
-    timeout: CLI_TIMEOUT,
-    windowsHide: true
-  }).trim();
-  if (output.length === 0) {
+  let parsed;
+  if (includeChecks) {
+    try {
+      parsed = queryGhPr(cwd2, args, GH_PR_WITH_CHECKS_FIELDS, deadline, deps);
+    } catch (error51) {
+      if (!isCiFieldUnavailableError(error51)) {
+        throw error51;
+      }
+      parsed = queryGhPr(cwd2, args, GH_PR_METADATA_FIELDS, deadline, deps);
+    }
+  } else {
+    parsed = queryGhPr(cwd2, args, GH_PR_METADATA_FIELDS, deadline, deps);
+  }
+  if (!parsed) {
     return null;
   }
-  const parsed = JSON.parse(output);
   if (typeof parsed.number !== "number" || typeof parsed.url !== "string") {
     return null;
   }
@@ -55996,10 +55937,11 @@ function fetchFromGh(cwd2, repoRef, deps) {
     title: typeof parsed.title === "string" ? parsed.title : "",
     state: typeof parsed.state === "string" ? parsed.state : "",
     reviewDecision: typeof parsed.reviewDecision === "string" ? parsed.reviewDecision : "",
-    provider: "gh"
+    provider: "gh",
+    checks: computeCiRollup(parsed.statusCheckRollup) ?? undefined
   };
 }
-function fetchFromGlab(cwd2, repoRef, deps) {
+function fetchFromGlab(cwd2, repoRef, deadline, deps) {
   const args = ["mr", "view"];
   if (repoRef) {
     const branch = getCurrentBranch(cwd2, deps);
@@ -56013,7 +55955,7 @@ function fetchFromGlab(cwd2, repoRef, deps) {
     encoding: "utf8",
     stdio: ["pipe", "pipe", "ignore"],
     cwd: cwd2,
-    timeout: CLI_TIMEOUT,
+    timeout: getRemainingTimeout(deadline, deps),
     windowsHide: true
   }).trim();
   if (output.length === 0) {
@@ -56032,72 +55974,440 @@ function fetchFromGlab(cwd2, repoRef, deps) {
     provider: "glab"
   };
 }
-function fetchFromProvider(provider, cwd2, repoRef, deps) {
-  const fetchFn = provider === "gh" ? fetchFromGh : fetchFromGlab;
+function fetchFromProvider(provider, cwd2, repoRef, includeChecks, deadline, deps) {
+  const fetch2 = (targetRepoRef) => provider === "gh" ? fetchFromGh(cwd2, targetRepoRef, includeChecks, deadline, deps) : fetchFromGlab(cwd2, targetRepoRef, deadline, deps);
   try {
-    const unpinned = fetchFn(cwd2, null, deps);
+    const unpinned = fetch2(null);
     if (unpinned) {
       return unpinned;
     }
   } catch {}
   if (repoRef) {
-    return fetchFn(cwd2, repoRef, deps);
+    return fetch2(repoRef);
+  }
+  return null;
+}
+function fetchGitReviewData(cwd2, deps = DEFAULT_GIT_REVIEW_CACHE_DEPS, options = {}) {
+  const includeChecks = options.includeChecks ?? false;
+  const cachePath = getCachePath2(cwd2, getCacheRef(cwd2, deps), deps);
+  const cached2 = readCache(cachePath, deps);
+  if (cached2 !== "miss" && !cached2.stale && (!includeChecks || cached2.checksQueried)) {
+    return cached2.data;
+  }
+  const repoRef = getOriginRepoRef(cwd2, deps);
+  const deadline = deps.now() + CLI_TIMEOUT;
+  for (const provider of getProviderCandidates(cwd2, deps)) {
+    if (!isCliAvailable(provider, deadline, deps)) {
+      continue;
+    }
+    try {
+      const data = fetchFromProvider(provider, cwd2, repoRef, includeChecks, deadline, deps);
+      if (data) {
+        writeCache(cachePath, data, includeChecks, deps);
+        return data;
+      }
+    } catch {}
+  }
+  if (cached2 !== "miss" && cached2.data !== null) {
+    return cached2.data;
+  }
+  writeCache(cachePath, null, true, deps);
+  return null;
+}
+function getRefreshLockPath(cachePath) {
+  return `${cachePath}.lock`;
+}
+function releaseRefreshLock(lockPath, deps) {
+  try {
+    deps.unlinkSync(lockPath);
+  } catch {}
+}
+function createRefreshLock(cachePath, deps) {
+  const cacheDir = getGitReviewCacheDir(deps);
+  try {
+    if (!deps.existsSync(cacheDir)) {
+      deps.mkdirSync(cacheDir, { recursive: true });
+    }
+  } catch {
+    return null;
+  }
+  const lockPath = getRefreshLockPath(cachePath);
+  for (let attempt2 = 0;attempt2 < 2; attempt2++) {
+    try {
+      const descriptor = deps.openSync(lockPath, "wx");
+      deps.closeSync(descriptor);
+      return lockPath;
+    } catch {
+      try {
+        const age = deps.now() - deps.statSync(lockPath).mtimeMs;
+        if (age <= REFRESH_LOCK_STALE_MS) {
+          return null;
+        }
+        deps.unlinkSync(lockPath);
+      } catch {
+        return null;
+      }
+    }
+  }
+  return null;
+}
+function scheduleRefresh(cwd2, cachePath, includeChecks, deps) {
+  const scriptPath = deps.getScriptPath();
+  if (!scriptPath) {
+    return;
+  }
+  const lockPath = createRefreshLock(cachePath, deps);
+  if (!lockPath) {
+    return;
+  }
+  try {
+    const child = deps.spawn(deps.getExecPath(), [
+      scriptPath,
+      GIT_REVIEW_REFRESH_FLAG,
+      cwd2,
+      includeChecks ? "checks" : "metadata",
+      lockPath
+    ], {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true
+    });
+    child.unref();
+  } catch {
+    releaseRefreshLock(lockPath, deps);
+  }
+}
+function getCachedGitReviewData(cwd2, options = {}, deps = DEFAULT_GIT_REVIEW_CACHE_DEPS) {
+  const includeChecks = options.includeChecks ?? false;
+  const cachePath = getCachePath2(cwd2, getCacheRef(cwd2, deps), deps);
+  const cached2 = readCache(cachePath, deps);
+  const needsRefresh = cached2 === "miss" || cached2.stale || includeChecks && !cached2.checksQueried;
+  if (needsRefresh) {
+    scheduleRefresh(cwd2, cachePath, includeChecks, deps);
+  }
+  return cached2 === "miss" ? null : cached2.data;
+}
+function refreshGitReviewCacheFromCli(cwd2, options, lockPath, deps = DEFAULT_GIT_REVIEW_CACHE_DEPS) {
+  const expectedLockPath = getRefreshLockPath(getCachePath2(cwd2, getCacheRef(cwd2, deps), deps));
+  try {
+    fetchGitReviewData(cwd2, deps, options);
+  } finally {
+    if (lockPath === expectedLockPath) {
+      releaseRefreshLock(lockPath, deps);
+    }
+  }
+}
+function getGitReviewStatusLabel(state, reviewDecision) {
+  if (state === "MERGED")
+    return "MERGED";
+  if (state === "CLOSED")
+    return "CLOSED";
+  if (reviewDecision === "APPROVED")
+    return "APPROVED";
+  if (reviewDecision === "CHANGES_REQUESTED")
+    return "CHANGES_REQ";
+  if (state === "OPEN")
+    return "OPEN";
+  return state;
+}
+function truncateTitle(title, maxWidth) {
+  const limit = maxWidth ?? DEFAULT_TITLE_MAX_WIDTH;
+  if (title.length <= limit)
+    return title;
+  return `${title.slice(0, limit - 1)}…`;
+}
+var GIT_REVIEW_CACHE_TTL = 30000, CLI_TIMEOUT = 5000, REFRESH_LOCK_STALE_MS = 30000, DEFAULT_TITLE_MAX_WIDTH = 30, GH_PR_METADATA_FIELDS = "url,number,title,state,reviewDecision", GH_PR_WITH_CHECKS_FIELDS, GIT_REVIEW_REFRESH_FLAG = "--internal-refresh-git-review-cache", DEFAULT_GIT_REVIEW_CACHE_DEPS, GitReviewDeadlineError;
+var init_git_review_cache = __esm(() => {
+  init_git_remote();
+  GH_PR_WITH_CHECKS_FIELDS = `${GH_PR_METADATA_FIELDS},statusCheckRollup`;
+  DEFAULT_GIT_REVIEW_CACHE_DEPS = {
+    closeSync,
+    execFileSync: execFileSync2,
+    existsSync: existsSync2,
+    getExecPath: () => process.execPath,
+    mkdirSync: mkdirSync2,
+    openSync,
+    readFileSync: readFileSync3,
+    getScriptPath: () => process.argv[1],
+    spawn,
+    statSync: statSync2,
+    unlinkSync,
+    writeFileSync: writeFileSync2,
+    getHomedir: os4.homedir,
+    now: Date.now
+  };
+  GitReviewDeadlineError = class GitReviewDeadlineError extends Error {
+  };
+});
+
+// src/widgets/GitCiStatus.ts
+function buildDisplay(checks3, rawValue) {
+  if (rawValue)
+    return checks3.state;
+  const parts = [];
+  if (checks3.failing > 0)
+    parts.push(`${SYMBOLS.failing}${checks3.failing}`);
+  if (checks3.pending > 0)
+    parts.push(`${SYMBOLS.pending}${checks3.pending}`);
+  if (checks3.success > 0)
+    parts.push(`${SYMBOLS.success}${checks3.success}`);
+  return parts.length > 0 ? parts.join(" ") : `${SYMBOLS[checks3.state]}0`;
+}
+
+class GitCiStatusWidget {
+  deps;
+  constructor(deps = DEFAULT_DEPS) {
+    this.deps = deps;
+  }
+  getDefaultColor() {
+    return "green";
+  }
+  getDescription() {
+    return "Shows CI check status for the current branch's PR (GitHub only)";
+  }
+  getDisplayName() {
+    return "Git CI Status";
+  }
+  getCategory() {
+    return "Git";
+  }
+  getEditorDisplay(item) {
+    return {
+      displayText: this.getDisplayName(),
+      modifierText: getHideNoGitModifierText(item)
+    };
+  }
+  handleEditorAction(action, item) {
+    return handleToggleNoGitAction(action, item);
+  }
+  render(item, context, _settings) {
+    const rawValue = item.rawValue ?? false;
+    if (context.isPreview) {
+      return buildDisplay(PREVIEW_CHECKS, rawValue);
+    }
+    if (!this.deps.isInsideGitWorkTree(context)) {
+      return isHideNoGitEnabled(item) ? null : "(no git)";
+    }
+    const cwd2 = this.deps.resolveGitCwd(context) ?? this.deps.getProcessCwd();
+    const checks3 = this.deps.getCachedGitReviewData(cwd2, { includeChecks: true })?.checks;
+    if (!checks3) {
+      return NO_CHECKS;
+    }
+    return buildDisplay(checks3, rawValue);
+  }
+  getCustomKeybinds() {
+    return getHideNoGitKeybinds();
+  }
+  supportsRawValue() {
+    return true;
+  }
+  supportsColors(_item) {
+    return true;
+  }
+}
+var NO_CHECKS = "-", SYMBOLS, DEFAULT_DEPS, PREVIEW_CHECKS;
+var init_GitCiStatus = __esm(() => {
+  init_git();
+  init_git_review_cache();
+  init_git_no_git();
+  SYMBOLS = {
+    success: "✓",
+    passing: "✓",
+    failing: "✗",
+    pending: "●"
+  };
+  DEFAULT_DEPS = {
+    getCachedGitReviewData,
+    getProcessCwd: () => process.cwd(),
+    isInsideGitWorkTree,
+    resolveGitCwd
+  };
+  PREVIEW_CHECKS = {
+    state: "failing",
+    failing: 1,
+    pending: 1,
+    success: 5
+  };
+});
+
+// src/widgets/GitCleanStatus.ts
+class GitCleanStatusWidget {
+  getDefaultColor() {
+    return "green";
+  }
+  getDescription() {
+    return "Shows ✓ when the working tree is clean and ✗ when it is dirty";
+  }
+  getDisplayName() {
+    return "Git Clean Status";
+  }
+  getCategory() {
+    return "Git";
+  }
+  getEditorDisplay(item) {
+    return {
+      displayText: this.getDisplayName(),
+      modifierText: getHideNoGitModifierText(item)
+    };
+  }
+  handleEditorAction(action, item) {
+    return handleToggleNoGitAction(action, item);
+  }
+  render(item, context, _settings) {
+    const hideNoGit = isHideNoGitEnabled(item);
+    if (context.isPreview) {
+      return item.rawValue ? "clean" : "✓";
+    }
+    if (!isInsideGitWorkTree(context)) {
+      return hideNoGit ? null : "(no git)";
+    }
+    const clean = this.isClean(context);
+    if (item.rawValue) {
+      return clean ? "clean" : "dirty";
+    }
+    return clean ? "✓" : "✗";
+  }
+  isClean(context) {
+    const status = getGitStatus(context);
+    return !status.staged && !status.unstaged && !status.untracked && !status.conflicts;
+  }
+  getCustomKeybinds() {
+    return getHideNoGitKeybinds();
+  }
+  supportsRawValue() {
+    return true;
+  }
+  supportsColors(_item) {
+    return true;
+  }
+}
+var init_GitCleanStatus = __esm(() => {
+  init_git();
+  init_git_no_git();
+});
+
+// src/widgets/GitRootDir.ts
+class GitRootDirWidget {
+  getDefaultColor() {
+    return "cyan";
+  }
+  getDescription() {
+    return "Shows the git repository root directory name";
+  }
+  getDisplayName() {
+    return "Git Root Dir";
+  }
+  getCategory() {
+    return "Git";
+  }
+  getEditorDisplay(item) {
+    const ideLinkMode = this.getIdeLinkMode(item);
+    const modifiers = [];
+    const noGitText = getHideNoGitModifierText(item);
+    if (noGitText)
+      modifiers.push("hide 'no git'");
+    if (ideLinkMode)
+      modifiers.push(IDE_LINK_LABELS[ideLinkMode]);
+    const maxWidthText = getMaxWidthModifier(item);
+    if (maxWidthText)
+      modifiers.push(maxWidthText);
+    return {
+      displayText: this.getDisplayName(),
+      modifierText: makeModifierText(modifiers)
+    };
+  }
+  handleEditorAction(action, item) {
+    if (action === TOGGLE_LINK_ACTION2) {
+      return this.cycleIdeLinkMode(item);
+    }
+    return handleToggleNoGitAction(action, item);
+  }
+  render(item, context, _settings) {
+    const hideNoGit = isHideNoGitEnabled(item);
+    const ideLinkMode = this.getIdeLinkMode(item);
+    if (context.isPreview) {
+      const name2 = "my-repo";
+      return ideLinkMode ? renderOsc8Link(buildIdeFileUrl("/Users/example/my-repo", ideLinkMode), name2) : name2;
+    }
+    if (!isInsideGitWorkTree(context)) {
+      return hideNoGit ? null : "no git";
+    }
+    const rootDir = this.getGitRootDir(context);
+    if (!rootDir) {
+      return hideNoGit ? null : "no git";
+    }
+    const name = applyMaxWidth(this.getRootDirName(rootDir), item.maxWidth);
+    if (ideLinkMode) {
+      return renderOsc8Link(buildIdeFileUrl(rootDir, ideLinkMode), name);
+    }
+    return name;
+  }
+  getGitRootDir(context) {
+    return runGit("rev-parse --show-toplevel", context);
+  }
+  getRootDirName(rootDir) {
+    const trimmedRootDir = rootDir.replace(/[\\/]+$/, "");
+    const normalizedRootDir = trimmedRootDir.length > 0 ? trimmedRootDir : rootDir;
+    const parts = normalizedRootDir.split(/[\\/]/).filter(Boolean);
+    const lastPart = parts[parts.length - 1];
+    return lastPart && lastPart.length > 0 ? lastPart : normalizedRootDir;
+  }
+  getCustomKeybinds() {
+    return [
+      ...getHideNoGitKeybinds(),
+      { key: "l", label: "(l)ink to IDE", action: TOGGLE_LINK_ACTION2 },
+      getMaxWidthKeybind()
+    ];
+  }
+  renderEditor(props) {
+    if (props.action === MAX_WIDTH_ACTION) {
+      return renderMaxWidthEditor(props);
+    }
+    return null;
   }
-  return null;
-}
-function fetchGitReviewData(cwd2, deps = DEFAULT_GIT_REVIEW_CACHE_DEPS) {
-  const cachePath = getCachePath2(cwd2, getCacheRef(cwd2, deps), deps);
-  const cached2 = readCache(cachePath, deps);
-  if (cached2 !== "miss") {
-    return cached2;
+  supportsRawValue() {
+    return false;
   }
-  const repoRef = getOriginRepoRef(cwd2, deps);
-  for (const provider of getProviderCandidates(cwd2, deps)) {
-    if (!isCliAvailable(provider, deps)) {
-      continue;
+  supportsColors(item) {
+    return true;
+  }
+  getIdeLinkMode(item) {
+    const configuredMode = item.metadata?.[IDE_LINK_KEY];
+    if (configuredMode && IDE_LINK_MODES.includes(configuredMode)) {
+      return configuredMode;
     }
-    try {
-      const data = fetchFromProvider(provider, cwd2, repoRef, deps);
-      if (data) {
-        writeCache(cachePath, data, deps);
-        return data;
-      }
-    } catch {}
+    if (isMetadataFlagEnabled(item, LEGACY_CURSOR_LINK_KEY)) {
+      return "cursor";
+    }
+    return null;
+  }
+  cycleIdeLinkMode(item) {
+    const currentMode = this.getIdeLinkMode(item);
+    const currentIndex = currentMode ? IDE_LINK_MODES.indexOf(currentMode) : -1;
+    const nextMode = currentIndex === IDE_LINK_MODES.length - 1 ? null : IDE_LINK_MODES[currentIndex + 1] ?? null;
+    const {
+      [IDE_LINK_KEY]: removedIdeLink,
+      [LEGACY_CURSOR_LINK_KEY]: removedLegacyLink,
+      ...restMetadata
+    } = item.metadata ?? {};
+    return {
+      ...item,
+      metadata: nextMode ? {
+        ...restMetadata,
+        [IDE_LINK_KEY]: nextMode
+      } : Object.keys(restMetadata).length > 0 ? restMetadata : undefined
+    };
   }
-  writeCache(cachePath, null, deps);
-  return null;
-}
-function getGitReviewStatusLabel(state, reviewDecision) {
-  if (state === "MERGED")
-    return "MERGED";
-  if (state === "CLOSED")
-    return "CLOSED";
-  if (reviewDecision === "APPROVED")
-    return "APPROVED";
-  if (reviewDecision === "CHANGES_REQUESTED")
-    return "CHANGES_REQ";
-  if (state === "OPEN")
-    return "OPEN";
-  return state;
-}
-function truncateTitle(title, maxWidth) {
-  const limit = maxWidth ?? DEFAULT_TITLE_MAX_WIDTH;
-  if (title.length <= limit)
-    return title;
-  return `${title.slice(0, limit - 1)}…`;
 }
-var GIT_REVIEW_CACHE_TTL = 30000, CLI_TIMEOUT = 5000, DEFAULT_TITLE_MAX_WIDTH = 30, DEFAULT_GIT_REVIEW_CACHE_DEPS;
-var init_git_review_cache = __esm(() => {
-  init_git_remote();
-  DEFAULT_GIT_REVIEW_CACHE_DEPS = {
-    execFileSync: execFileSync2,
-    existsSync: existsSync2,
-    mkdirSync: mkdirSync2,
-    readFileSync: readFileSync3,
-    statSync: statSync2,
-    writeFileSync: writeFileSync2,
-    getHomedir: os4.homedir,
-    now: Date.now
+var IDE_LINK_KEY = "linkToIDE", LEGACY_CURSOR_LINK_KEY = "linkToCursor", TOGGLE_LINK_ACTION2 = "toggle-link", IDE_LINK_LABELS;
+var init_GitRootDir = __esm(async () => {
+  init_git();
+  init_hyperlink();
+  init_git_no_git();
+  await init_max_width();
+  IDE_LINK_LABELS = {
+    vscode: "link-vscode",
+    cursor: "link-cursor"
   };
 });
 
@@ -56118,7 +56428,7 @@ function resolvePrNoun(pr, context, deps) {
   }
   return "PR";
 }
-function buildDisplay(item, pr, showStatus, showTitle, noun) {
+function buildDisplay2(item, pr, showStatus, showTitle, noun) {
   const linkText = item.rawValue ? `#${pr.number}` : `${noun} #${pr.number}`;
   const parts = [renderOsc8Link(pr.url, linkText)];
   if (showStatus) {
@@ -56178,17 +56488,17 @@ class GitPrWidget {
     const showStatus = !isMetadataFlagEnabled(item, HIDE_STATUS_KEY);
     const showTitle = !isMetadataFlagEnabled(item, HIDE_TITLE_KEY);
     if (context.isPreview) {
-      return buildDisplay(item, PREVIEW_PR, showStatus, showTitle, resolvePrNoun(PREVIEW_PR, context, this.deps));
+      return buildDisplay2(item, PREVIEW_PR, showStatus, showTitle, resolvePrNoun(PREVIEW_PR, context, this.deps));
     }
     if (!this.deps.isInsideGitWorkTree(context)) {
       return hideNoGit ? null : `(no ${resolvePrNoun(null, context, this.deps)})`;
     }
     const cwd2 = this.deps.resolveGitCwd(context) ?? this.deps.getProcessCwd();
-    const prData = this.deps.fetchGitReviewData(cwd2);
+    const prData = this.deps.getCachedGitReviewData(cwd2, { includeChecks: context.gitReviewNeedsChecks ?? false });
     if (!prData) {
       return hideNoGit ? null : `(no ${resolvePrNoun(null, context, this.deps)})`;
     }
-    return buildDisplay(item, prData, showStatus, showTitle, resolvePrNoun(prData, context, this.deps));
+    return buildDisplay2(item, prData, showStatus, showTitle, resolvePrNoun(prData, context, this.deps));
   }
   getCustomKeybinds() {
     return [
@@ -56212,7 +56522,7 @@ var init_GitPr = __esm(() => {
   init_hyperlink();
   init_git_no_git();
   DEFAULT_GIT_PR_WIDGET_DEPS = {
-    fetchGitReviewData,
+    getCachedGitReviewData,
     getProcessCwd: () => process.cwd(),
     getRemoteInfo,
     isInsideGitWorkTree,
@@ -57977,7 +58287,7 @@ function getTerminalWidth() {
 function canDetectTerminalWidth() {
   return probeTerminalWidth() !== null;
 }
-var __dirname = "/home/runner/work/ccstatusline/ccstatusline/src/utils", PACKAGE_VERSION = "2.2.23";
+var __dirname = "/home/runner/work/ccstatusline/ccstatusline/src/utils", PACKAGE_VERSION = "2.2.25";
 var init_terminal = () => {};
 
 // src/utils/format-tokens.ts
@@ -57997,6 +58307,13 @@ function maybeApplyForegroundGradient(line, settings, colorLevel) {
   const stops = parseGradientSpec(settings.overrideForegroundColor);
   return stops ? applyLineGradient(line, stops, colorLevel) : line;
 }
+function resolvePaddingSides(padding, side) {
+  if (side === "left")
+    return { leading: padding, trailing: "" };
+  if (side === "right")
+    return { leading: "", trailing: padding };
+  return { leading: padding, trailing: padding };
+}
 function resolveEffectiveTerminalWidth(detectedWidth, settings, context) {
   if (!detectedWidth) {
     return null;
@@ -58117,6 +58434,7 @@ function renderPowerlineStatusLine(widgets, settings, context, lineIndex = 0, gl
     }
     if (widgetText) {
       const padding = settings.defaultPadding ?? "";
+      const { leading: sideLeadingPadding, trailing: sideTrailingPadding } = resolvePaddingSides(padding, settings.defaultPaddingSide);
       if (settings.overrideForegroundColor && settings.overrideForegroundColor !== "none" && widget.type === "custom-command" && widget.preserveColors) {
         widgetText = stripSgrCodes(widgetText);
       }
@@ -58125,8 +58443,8 @@ function renderPowerlineStatusLine(widgets, settings, context, lineIndex = 0, gl
       const mergesWithNext = canMergeWithNextRenderedWidget(actualPreRenderedIndex);
       const omitLeadingPadding = previousRenderedWidget?.merge === "no-padding" && canMergeWithNextRenderedWidget(previousRenderedIndex ?? undefined);
       const omitTrailingPadding = widget.merge === "no-padding" && mergesWithNext;
-      const leadingPadding = omitLeadingPadding ? "" : padding;
-      const trailingPadding = omitTrailingPadding ? "" : padding;
+      const leadingPadding = omitLeadingPadding ? "" : sideLeadingPadding;
+      const trailingPadding = omitTrailingPadding ? "" : sideTrailingPadding;
       const paddedText = `${leadingPadding}${widgetText}${trailingPadding}`;
       let fgColor = widget.color ?? defaultColor;
       let bgColor = widget.backgroundColor;
@@ -58507,7 +58825,8 @@ function preRenderAllWidgets(allLinesWidgets, settings, context) {
 function calculateMaxWidthsFromPreRendered(preRenderedLines, settings) {
   const maxWidths = [];
   const defaultPadding = settings.defaultPadding ?? "";
-  const paddingLength = defaultPadding.length;
+  const { leading: sideLeadingPadding, trailing: sideTrailingPadding } = resolvePaddingSides(defaultPadding, settings.defaultPaddingSide);
+  const paddingPairLength = sideLeadingPadding.length + sideTrailingPadding.length;
   for (const preRenderedLine of preRenderedLines) {
     const isSeparatorBoundary = (entry) => entry?.widget.type === "separator" || entry?.widget.type === "flex-separator";
     const hasNextRenderedWidgetBeforeSeparator = (originalIndex) => {
@@ -58533,7 +58852,7 @@ function calculateMaxWidthsFromPreRendered(preRenderedLines, settings) {
         continue;
       if (widget.widget.excludeFromAutoAlign)
         break;
-      let totalWidth = widget.plainLength + paddingLength * 2;
+      let totalWidth = widget.plainLength + paddingPairLength;
       let j = i;
       while (j < renderedWidgets.length - 1 && renderedWidgets[j]?.mergesWithNext) {
         j++;
@@ -58542,7 +58861,7 @@ function calculateMaxWidthsFromPreRendered(preRenderedLines, settings) {
           if (renderedWidgets[j - 1]?.widget.merge === "no-padding") {
             totalWidth += nextWidget.plainLength;
           } else {
-            totalWidth += nextWidget.plainLength + paddingLength * 2;
+            totalWidth += nextWidget.plainLength + paddingPairLength;
           }
         }
       }
@@ -58675,6 +58994,7 @@ function renderStatusLine(widgets, settings, context, preRenderedWidgets, preCal
   }
   const finalElements = [];
   const padding = settings.defaultPadding ?? "";
+  const { leading: sideLeadingPadding, trailing: sideTrailingPadding } = resolvePaddingSides(padding, settings.defaultPaddingSide);
   const defaultSep = settings.defaultSeparator ? formatSeparator(settings.defaultSeparator) : "";
   elements.forEach((elem, index) => {
     const prevElem = index > 0 ? elements[index - 1] : null;
@@ -58708,14 +59028,13 @@ function renderStatusLine(widgets, settings, context, preRenderedWidgets, preCal
       const omitTrailingPadding = elem.widget?.merge === "no-padding" && nextElem && nextElem.type !== "separator" && nextElem.type !== "flex-separator";
       const hasColorOverride = Boolean(settings.overrideBackgroundColor && settings.overrideBackgroundColor !== "none") || Boolean(settings.overrideForegroundColor && settings.overrideForegroundColor !== "none");
       if (padding && (elem.widget?.backgroundColor || hasColorOverride)) {
-        const leadingPadding = omitLeadingPadding ? "" : applyColorsWithOverride(padding, undefined, elem.widget?.backgroundColor);
-        const trailingPadding = omitTrailingPadding ? "" : applyColorsWithOverride(padding, undefined, elem.widget?.backgroundColor);
+        const leadingPadding = omitLeadingPadding || !sideLeadingPadding ? "" : applyColorsWithOverride(sideLeadingPadding, undefined, elem.widget?.backgroundColor);
+        const trailingPadding = omitTrailingPadding || !sideTrailingPadding ? "" : applyColorsWithOverride(sideTrailingPadding, undefined, elem.widget?.backgroundColor);
         const paddedContent = leadingPadding + elem.content + trailingPadding;
         finalElements.push(paddedContent);
       } else if (padding) {
-        const protectedPadding = source_default.reset(padding);
-        const leadingPadding = omitLeadingPadding ? "" : protectedPadding;
-        const trailingPadding = omitTrailingPadding ? "" : protectedPadding;
+        const leadingPadding = omitLeadingPadding || !sideLeadingPadding ? "" : source_default.reset(sideLeadingPadding);
+        const trailingPadding = omitTrailingPadding || !sideTrailingPadding ? "" : source_default.reset(sideTrailingPadding);
         finalElements.push(leadingPadding + elem.content + trailingPadding);
       } else {
         finalElements.push(elem.content);
@@ -69084,26 +69403,43 @@ function getFormat(item) {
   const f = item.metadata?.format;
   return FORMATS.includes(f ?? "") ? f : DEFAULT_FORMAT;
 }
+function canUseNerdFont(item) {
+  const format = getFormat(item);
+  return format === "icon-dash-letter" || format === "icon-letter" || format === "icon";
+}
+function removeNerdFont(item) {
+  const { [NERD_FONT_METADATA_KEY]: removedNerdFont, ...restMetadata } = item.metadata ?? {};
+  return {
+    ...item,
+    metadata: Object.keys(restMetadata).length > 0 ? restMetadata : undefined
+  };
+}
 function setFormat(item, format) {
+  let updatedItem;
   if (format === DEFAULT_FORMAT) {
     const { format: removedFormat, ...restMetadata } = item.metadata ?? {};
-    return {
+    updatedItem = {
       ...item,
       metadata: Object.keys(restMetadata).length > 0 ? restMetadata : undefined
     };
+  } else {
+    updatedItem = {
+      ...item,
+      metadata: {
+        ...item.metadata ?? {},
+        format
+      }
+    };
   }
-  return {
-    ...item,
-    metadata: {
-      ...item.metadata ?? {},
-      format
-    }
-  };
+  return canUseNerdFont(updatedItem) ? updatedItem : removeNerdFont(updatedItem);
 }
 function isNerdFontEnabled(item) {
-  return item.metadata?.[NERD_FONT_METADATA_KEY] === "true";
+  return canUseNerdFont(item) && item.metadata?.[NERD_FONT_METADATA_KEY] === "true";
 }
 function toggleNerdFont(item) {
+  if (!canUseNerdFont(item)) {
+    return removeNerdFont(item);
+  }
   if (!isNerdFontEnabled(item)) {
     return {
       ...item,
@@ -69113,11 +69449,7 @@ function toggleNerdFont(item) {
       }
     };
   }
-  const { [NERD_FONT_METADATA_KEY]: removedNerdFont, ...restMetadata } = item.metadata ?? {};
-  return {
-    ...item,
-    metadata: Object.keys(restMetadata).length > 0 ? restMetadata : undefined
-  };
+  return removeNerdFont(item);
 }
 function formatMode(mode, format, icon) {
   const letter = mode === "NORMAL" ? "N" : mode === "INSERT" ? "I" : mode[0] ?? mode;
@@ -69179,11 +69511,14 @@ class VimModeWidget {
       return null;
     return formatMode(mode, format, icon);
   }
-  getCustomKeybinds() {
-    return [
-      { key: "f", label: "(f)ormat", action: CYCLE_FORMAT_ACTION },
-      { key: "n", label: "(n)erd font", action: TOGGLE_NERD_FONT_ACTION }
+  getCustomKeybinds(item) {
+    const keybinds = [
+      { key: "f", label: "(f)ormat", action: CYCLE_FORMAT_ACTION }
     ];
+    if (item === undefined || canUseNerdFont(item)) {
+      keybinds.push({ key: "n", label: "(n)erd font", action: TOGGLE_NERD_FONT_ACTION });
+    }
+    return keybinds;
   }
   supportsRawValue() {
     return false;
@@ -69408,7 +69743,7 @@ function getFormat2(item) {
   const format = item.metadata?.format;
   return FORMATS2.includes(format ?? "") ? format : DEFAULT_FORMAT2;
 }
-function removeNerdFont(item) {
+function removeNerdFont2(item) {
   const { [NERD_FONT_METADATA_KEY2]: removedNerdFont, ...restMetadata } = item.metadata ?? {};
   return {
     ...item,
@@ -69513,7 +69848,7 @@ function formatStats(data, item, icon) {
 }
 function toggleNerdFont2(item) {
   if (getFormat2(item) !== DEFAULT_FORMAT2) {
-    return removeNerdFont(item);
+    return removeNerdFont2(item);
   }
   if (!isNerdFontEnabled2(item)) {
     return {
@@ -69524,7 +69859,7 @@ function toggleNerdFont2(item) {
       }
     };
   }
-  return removeNerdFont(item);
+  return removeNerdFont2(item);
 }
 function formatCount(count, format, icon) {
   switch (format) {
@@ -69658,31 +69993,47 @@ var init_CompactionCounter = __esm(async () => {
   });
 });
 
-// src/widgets/VoiceStatus.ts
+// src/widgets/SandboxStatus.ts
 function getFormat3(item) {
   const f = item.metadata?.format;
   return FORMATS3.includes(f ?? "") ? f : DEFAULT_FORMAT3;
 }
+function canUseNerdFont2(item) {
+  return getFormat3(item) === "glyph";
+}
+function removeNerdFont3(item) {
+  const { [NERD_FONT_METADATA_KEY3]: removedNerdFont, ...restMetadata } = item.metadata ?? {};
+  return {
+    ...item,
+    metadata: Object.keys(restMetadata).length > 0 ? restMetadata : undefined
+  };
+}
 function setFormat3(item, format) {
+  let updatedItem;
   if (format === DEFAULT_FORMAT3) {
     const { format: removedFormat, ...restMetadata } = item.metadata ?? {};
-    return {
+    updatedItem = {
       ...item,
       metadata: Object.keys(restMetadata).length > 0 ? restMetadata : undefined
     };
+  } else {
+    updatedItem = {
+      ...item,
+      metadata: {
+        ...item.metadata ?? {},
+        format
+      }
+    };
   }
-  return {
-    ...item,
-    metadata: {
-      ...item.metadata ?? {},
-      format
-    }
-  };
+  return canUseNerdFont2(updatedItem) ? updatedItem : removeNerdFont3(updatedItem);
 }
 function isNerdFontEnabled3(item) {
-  return item.metadata?.[NERD_FONT_METADATA_KEY3] === "true";
+  return canUseNerdFont2(item) && item.metadata?.[NERD_FONT_METADATA_KEY3] === "true";
 }
 function toggleNerdFont3(item) {
+  if (!canUseNerdFont2(item)) {
+    return removeNerdFont3(item);
+  }
   if (!isNerdFontEnabled3(item)) {
     return {
       ...item,
@@ -69692,25 +70043,167 @@ function toggleNerdFont3(item) {
       }
     };
   }
-  const { [NERD_FONT_METADATA_KEY3]: removedNerdFont, ...restMetadata } = item.metadata ?? {};
-  return {
-    ...item,
-    metadata: Object.keys(restMetadata).length > 0 ? restMetadata : undefined
-  };
+  return removeNerdFont3(item);
+}
+function formatStatus(enabled, format, nerdFont, rawValue) {
+  const stateText = enabled ? "ON" : "OFF";
+  const glyph = nerdFont ? enabled ? LOCK_NERD_FONT : UNLOCK_NERD_FONT : enabled ? DOT_ON : DOT_OFF;
+  switch (format) {
+    case "glyph":
+      return rawValue ? glyph : `SB: ${glyph}`;
+    case "text":
+      return rawValue ? stateText : `SB: ${stateText}`;
+    case "word":
+      return rawValue ? stateText : `Sandbox: ${stateText}`;
+  }
+}
+function resolveSandboxConfigCwd(context) {
+  const candidates = [
+    context.data?.workspace?.project_dir,
+    context.data?.cwd,
+    context.data?.workspace?.current_dir
+  ];
+  return candidates.find((candidate) => typeof candidate === "string" && candidate.trim().length > 0);
+}
+
+class SandboxStatusWidget {
+  getDefaultColor() {
+    return "green";
+  }
+  getDescription() {
+    return [
+      "Shows whether Claude Code bash sandbox mode is enabled",
+      "Best effort: may not reflect active sandboxing when managed or CLI settings override it, or when sandbox initialization fails."
+    ].join(`
+`);
+  }
+  getDisplayName() {
+    return "Sandbox Status";
+  }
+  getCategory() {
+    return "Core";
+  }
+  getEditorDisplay(item) {
+    const modifiers = [getFormat3(item)];
+    if (isNerdFontEnabled3(item)) {
+      modifiers.push("nerd font");
+    }
+    return {
+      displayText: this.getDisplayName(),
+      modifierText: `(${modifiers.join(", ")})`
+    };
+  }
+  handleEditorAction(action, item) {
+    if (action === CYCLE_FORMAT_ACTION3) {
+      const currentFormat = getFormat3(item);
+      const nextFormat = FORMATS3[(FORMATS3.indexOf(currentFormat) + 1) % FORMATS3.length] ?? DEFAULT_FORMAT3;
+      return setFormat3(item, nextFormat);
+    }
+    if (action === TOGGLE_NERD_FONT_ACTION3) {
+      return toggleNerdFont3(item);
+    }
+    return null;
+  }
+  render(item, context, _settings) {
+    const format = getFormat3(item);
+    const nerdFont = isNerdFontEnabled3(item);
+    if (context.isPreview) {
+      return formatStatus(true, format, nerdFont, item.rawValue ?? false);
+    }
+    const config2 = getSandboxConfig(resolveSandboxConfigCwd(context));
+    if (config2 === null) {
+      return null;
+    }
+    return formatStatus(config2.enabled, format, nerdFont, item.rawValue ?? false);
+  }
+  getCustomKeybinds(item) {
+    const keybinds = [
+      { key: "f", label: "(f)ormat", action: CYCLE_FORMAT_ACTION3 }
+    ];
+    if (item === undefined || canUseNerdFont2(item)) {
+      keybinds.push({ key: "n", label: "(n)erd font", action: TOGGLE_NERD_FONT_ACTION3 });
+    }
+    return keybinds;
+  }
+  supportsRawValue() {
+    return true;
+  }
+  supportsColors(_item) {
+    return true;
+  }
+}
+var DOT_ON = "●", DOT_OFF = "○", LOCK_NERD_FONT = "", UNLOCK_NERD_FONT = "", FORMATS3, DEFAULT_FORMAT3 = "glyph", CYCLE_FORMAT_ACTION3 = "cycle-format", TOGGLE_NERD_FONT_ACTION3 = "toggle-nerd-font", NERD_FONT_METADATA_KEY3 = "nerdFont";
+var init_SandboxStatus = __esm(async () => {
+  await init_claude_settings();
+  FORMATS3 = ["glyph", "text", "word"];
+});
+
+// src/widgets/VoiceStatus.ts
+function getFormat4(item) {
+  const f = item.metadata?.format;
+  return FORMATS4.includes(f ?? "") ? f : DEFAULT_FORMAT4;
+}
+function canUseNerdFont3(item) {
+  const format = getFormat4(item);
+  return format === "icon" || format === "icon-text" && !item.rawValue;
+}
+function removeNerdFont4(item) {
+  const { [NERD_FONT_METADATA_KEY4]: removedNerdFont, ...restMetadata } = item.metadata ?? {};
+  return {
+    ...item,
+    metadata: Object.keys(restMetadata).length > 0 ? restMetadata : undefined
+  };
+}
+function setFormat4(item, format) {
+  let updatedItem;
+  if (format === DEFAULT_FORMAT4) {
+    const { format: removedFormat, ...restMetadata } = item.metadata ?? {};
+    updatedItem = {
+      ...item,
+      metadata: Object.keys(restMetadata).length > 0 ? restMetadata : undefined
+    };
+  } else {
+    updatedItem = {
+      ...item,
+      metadata: {
+        ...item.metadata ?? {},
+        format
+      }
+    };
+  }
+  return canUseNerdFont3(updatedItem) ? updatedItem : removeNerdFont4(updatedItem);
+}
+function isNerdFontEnabled4(item) {
+  return canUseNerdFont3(item) && item.metadata?.[NERD_FONT_METADATA_KEY4] === "true";
+}
+function toggleNerdFont4(item) {
+  if (!canUseNerdFont3(item)) {
+    return removeNerdFont4(item);
+  }
+  if (!isNerdFontEnabled4(item)) {
+    return {
+      ...item,
+      metadata: {
+        ...item.metadata ?? {},
+        [NERD_FONT_METADATA_KEY4]: "true"
+      }
+    };
+  }
+  return removeNerdFont4(item);
 }
-function formatStatus(enabled, format, nerdFont) {
+function formatStatus2(enabled, format, nerdFont, rawValue) {
   const stateText = enabled ? "on" : "off";
   const stateDot = enabled ? STATE_DOT_ON : STATE_DOT_OFF;
   const icon = nerdFont ? enabled ? MIC_NERD_FONT : MIC_SLASH_NERD_FONT : MIC_EMOJI;
   switch (format) {
     case "icon":
-      return nerdFont ? icon : `${icon} ${stateDot}`;
+      return nerdFont ? icon : rawValue ? stateDot : `${icon} ${stateDot}`;
     case "icon-text":
-      return `${icon} ${stateText}`;
+      return rawValue ? stateText : `${icon} ${stateText}`;
     case "text":
       return stateText;
     case "word":
-      return `voice ${stateText}`;
+      return rawValue ? stateText : `voice ${stateText}`;
   }
 }
 function resolveVoiceConfigCwd(context) {
@@ -69736,8 +70229,8 @@ class VoiceStatusWidget {
     return "Core";
   }
   getEditorDisplay(item) {
-    const modifiers = [getFormat3(item)];
-    if (isNerdFontEnabled3(item)) {
+    const modifiers = [getFormat4(item)];
+    if (isNerdFontEnabled4(item)) {
       modifiers.push("nerd font");
     }
     return {
@@ -69746,39 +70239,36 @@ class VoiceStatusWidget {
     };
   }
   handleEditorAction(action, item) {
-    if (action === CYCLE_FORMAT_ACTION3) {
-      const currentFormat = getFormat3(item);
-      const nextFormat = FORMATS3[(FORMATS3.indexOf(currentFormat) + 1) % FORMATS3.length] ?? DEFAULT_FORMAT3;
-      return setFormat3(item, nextFormat);
+    if (action === CYCLE_FORMAT_ACTION4) {
+      const currentFormat = getFormat4(item);
+      const nextFormat = FORMATS4[(FORMATS4.indexOf(currentFormat) + 1) % FORMATS4.length] ?? DEFAULT_FORMAT4;
+      return setFormat4(item, nextFormat);
     }
-    if (action === TOGGLE_NERD_FONT_ACTION3) {
-      return toggleNerdFont3(item);
+    if (action === TOGGLE_NERD_FONT_ACTION4) {
+      return toggleNerdFont4(item);
     }
     return null;
   }
   render(item, context, _settings) {
-    const format = getFormat3(item);
-    const nerdFont = isNerdFontEnabled3(item);
+    const format = getFormat4(item);
+    const nerdFont = isNerdFontEnabled4(item);
     if (context.isPreview) {
-      if (item.rawValue) {
-        return "on";
-      }
-      return formatStatus(true, format, nerdFont);
+      return formatStatus2(true, format, nerdFont, item.rawValue ?? false);
     }
     const config2 = getVoiceConfig(resolveVoiceConfigCwd(context));
     if (config2 === null) {
       return null;
     }
-    if (item.rawValue) {
-      return config2.enabled ? "on" : "off";
-    }
-    return formatStatus(config2.enabled, format, nerdFont);
+    return formatStatus2(config2.enabled, format, nerdFont, item.rawValue ?? false);
   }
-  getCustomKeybinds() {
-    return [
-      { key: "f", label: "(f)ormat", action: CYCLE_FORMAT_ACTION3 },
-      { key: "n", label: "(n)erd font", action: TOGGLE_NERD_FONT_ACTION3 }
+  getCustomKeybinds(item) {
+    const keybinds = [
+      { key: "f", label: "(f)ormat", action: CYCLE_FORMAT_ACTION4 }
     ];
+    if (item === undefined || canUseNerdFont3(item)) {
+      keybinds.push({ key: "n", label: "(n)erd font", action: TOGGLE_NERD_FONT_ACTION4 });
+    }
+    return keybinds;
   }
   supportsRawValue() {
     return true;
@@ -69787,69 +70277,82 @@ class VoiceStatusWidget {
     return true;
   }
 }
-var MIC_EMOJI = "\uD83C\uDFA4", MIC_NERD_FONT = "", MIC_SLASH_NERD_FONT = "", STATE_DOT_OFF = "○", STATE_DOT_ON = "◉", FORMATS3, DEFAULT_FORMAT3 = "icon", CYCLE_FORMAT_ACTION3 = "cycle-format", TOGGLE_NERD_FONT_ACTION3 = "toggle-nerd-font", NERD_FONT_METADATA_KEY3 = "nerdFont";
+var MIC_EMOJI = "\uD83C\uDFA4", MIC_NERD_FONT = "", MIC_SLASH_NERD_FONT = "", STATE_DOT_OFF = "○", STATE_DOT_ON = "◉", FORMATS4, DEFAULT_FORMAT4 = "icon", CYCLE_FORMAT_ACTION4 = "cycle-format", TOGGLE_NERD_FONT_ACTION4 = "toggle-nerd-font", NERD_FONT_METADATA_KEY4 = "nerdFont";
 var init_VoiceStatus = __esm(async () => {
   await init_claude_settings();
-  FORMATS3 = ["icon", "icon-text", "text", "word"];
+  FORMATS4 = ["icon", "icon-text", "text", "word"];
 });
 
 // src/widgets/RemoteControlStatus.ts
-function getFormat4(item) {
+function getFormat5(item) {
   const f = item.metadata?.format;
-  return FORMATS4.includes(f ?? "") ? f : DEFAULT_FORMAT4;
+  return FORMATS5.includes(f ?? "") ? f : DEFAULT_FORMAT5;
 }
-function setFormat4(item, format) {
-  if (format === DEFAULT_FORMAT4) {
+function canUseNerdFont4(item) {
+  const format = getFormat5(item);
+  return format === "icon" || format === "icon-text" && !item.rawValue;
+}
+function removeNerdFont5(item) {
+  const { [NERD_FONT_METADATA_KEY5]: removedNerdFont, ...restMetadata } = item.metadata ?? {};
+  return {
+    ...item,
+    metadata: Object.keys(restMetadata).length > 0 ? restMetadata : undefined
+  };
+}
+function setFormat5(item, format) {
+  let updatedItem;
+  if (format === DEFAULT_FORMAT5) {
     const { format: removedFormat, ...restMetadata } = item.metadata ?? {};
-    return {
+    updatedItem = {
       ...item,
       metadata: Object.keys(restMetadata).length > 0 ? restMetadata : undefined
     };
+  } else {
+    updatedItem = {
+      ...item,
+      metadata: {
+        ...item.metadata ?? {},
+        format
+      }
+    };
   }
-  return {
-    ...item,
-    metadata: {
-      ...item.metadata ?? {},
-      format
-    }
-  };
+  return canUseNerdFont4(updatedItem) ? updatedItem : removeNerdFont5(updatedItem);
 }
-function isNerdFontEnabled4(item) {
-  return item.metadata?.[NERD_FONT_METADATA_KEY4] === "true";
+function isNerdFontEnabled5(item) {
+  return canUseNerdFont4(item) && item.metadata?.[NERD_FONT_METADATA_KEY5] === "true";
 }
-function toggleNerdFont4(item) {
-  if (!isNerdFontEnabled4(item)) {
+function toggleNerdFont5(item) {
+  if (!canUseNerdFont4(item)) {
+    return removeNerdFont5(item);
+  }
+  if (!isNerdFontEnabled5(item)) {
     return {
       ...item,
       metadata: {
         ...item.metadata ?? {},
-        [NERD_FONT_METADATA_KEY4]: "true"
+        [NERD_FONT_METADATA_KEY5]: "true"
       }
     };
   }
-  const { [NERD_FONT_METADATA_KEY4]: removedNerdFont, ...restMetadata } = item.metadata ?? {};
-  return {
-    ...item,
-    metadata: Object.keys(restMetadata).length > 0 ? restMetadata : undefined
-  };
+  return removeNerdFont5(item);
 }
-function formatStatus2(enabled, format, nerdFont) {
+function formatStatus3(enabled, format, nerdFont, rawValue) {
   const stateText = enabled ? "on" : "off";
   const stateDot = enabled ? STATE_DOT_ON2 : STATE_DOT_OFF2;
   const icon = nerdFont ? enabled ? SATELLITE_NERD_FONT : SATELLITE_SLASH_NERD_FONT : SATELLITE_EMOJI;
   switch (format) {
     case "icon":
-      return nerdFont ? icon : `${icon} ${stateDot}`;
+      return nerdFont ? icon : rawValue ? stateDot : `${icon} ${stateDot}`;
     case "icon-text":
-      return `${icon} ${stateText}`;
+      return rawValue ? stateText : `${icon} ${stateText}`;
     case "text":
       return stateText;
     case "word":
-      return `remote ${stateText}`;
+      return rawValue ? stateText : `remote ${stateText}`;
     case "label-check":
-      return `remote ${enabled ? CHECK_EMOJI : CROSS_EMOJI}`;
+      return rawValue ? enabled ? CHECK_EMOJI : CROSS_EMOJI : `remote ${enabled ? CHECK_EMOJI : CROSS_EMOJI}`;
     case "label-mark":
-      return `remote ${enabled ? CHECK_MARK : CROSS_MARK}`;
+      return rawValue ? enabled ? CHECK_MARK : CROSS_MARK : `remote ${enabled ? CHECK_MARK : CROSS_MARK}`;
   }
 }
 
@@ -69867,8 +70370,8 @@ class RemoteControlStatusWidget {
     return "Core";
   }
   getEditorDisplay(item) {
-    const modifiers = [getFormat4(item)];
-    if (isNerdFontEnabled4(item)) {
+    const modifiers = [getFormat5(item)];
+    if (isNerdFontEnabled5(item)) {
       modifiers.push("nerd font");
     }
     return {
@@ -69877,40 +70380,246 @@ class RemoteControlStatusWidget {
     };
   }
   handleEditorAction(action, item) {
-    if (action === CYCLE_FORMAT_ACTION4) {
-      const currentFormat = getFormat4(item);
-      const nextFormat = FORMATS4[(FORMATS4.indexOf(currentFormat) + 1) % FORMATS4.length] ?? DEFAULT_FORMAT4;
-      return setFormat4(item, nextFormat);
+    if (action === CYCLE_FORMAT_ACTION5) {
+      const currentFormat = getFormat5(item);
+      const nextFormat = FORMATS5[(FORMATS5.indexOf(currentFormat) + 1) % FORMATS5.length] ?? DEFAULT_FORMAT5;
+      return setFormat5(item, nextFormat);
     }
-    if (action === TOGGLE_NERD_FONT_ACTION4) {
-      return toggleNerdFont4(item);
+    if (action === TOGGLE_NERD_FONT_ACTION5) {
+      return toggleNerdFont5(item);
     }
     return null;
   }
   render(item, context, _settings) {
-    const format = getFormat4(item);
-    const nerdFont = isNerdFontEnabled4(item);
+    const format = getFormat5(item);
+    const nerdFont = isNerdFontEnabled5(item);
     if (context.isPreview) {
-      if (item.rawValue) {
-        return "on";
-      }
-      return formatStatus2(true, format, nerdFont);
+      return formatStatus3(true, format, nerdFont, item.rawValue ?? false);
     }
     const status = getRemoteControlStatus(context.data?.session_id);
     if (status === null) {
       return null;
     }
-    if (item.rawValue) {
-      return status.enabled ? "on" : "off";
+    return formatStatus3(status.enabled, format, nerdFont, item.rawValue ?? false);
+  }
+  getCustomKeybinds(item) {
+    const keybinds = [
+      { key: "f", label: "(f)ormat", action: CYCLE_FORMAT_ACTION5 }
+    ];
+    if (item === undefined || canUseNerdFont4(item)) {
+      keybinds.push({ key: "n", label: "(n)erd font", action: TOGGLE_NERD_FONT_ACTION5 });
+    }
+    return keybinds;
+  }
+  supportsRawValue() {
+    return true;
+  }
+  supportsColors(_item) {
+    return true;
+  }
+}
+var SATELLITE_EMOJI = "\uD83D\uDCE1", SATELLITE_NERD_FONT = "", SATELLITE_SLASH_NERD_FONT = "", STATE_DOT_OFF2 = "○", STATE_DOT_ON2 = "◉", FORMATS5, CHECK_EMOJI = "✅", CROSS_EMOJI = "❌", CHECK_MARK = "✓", CROSS_MARK = "✗", DEFAULT_FORMAT5 = "icon", CYCLE_FORMAT_ACTION5 = "cycle-format", TOGGLE_NERD_FONT_ACTION5 = "toggle-nerd-font", NERD_FONT_METADATA_KEY5 = "nerdFont";
+var init_RemoteControlStatus = __esm(async () => {
+  await init_claude_settings();
+  FORMATS5 = ["icon", "icon-text", "text", "word", "label-check", "label-mark"];
+});
+
+// src/widgets/CacheTimer.ts
+import * as fs12 from "fs";
+function hasCacheActivity(entry) {
+  const usage = entry.message?.usage;
+  if (!usage) {
+    return true;
+  }
+  return (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0) > 0;
+}
+function readFileTail(filePath, bytes) {
+  try {
+    const fd = fs12.openSync(filePath, "r");
+    try {
+      const size2 = fs12.fstatSync(fd).size;
+      const readSize = Math.min(bytes, size2);
+      const buf = Buffer.alloc(readSize);
+      fs12.readSync(fd, buf, 0, readSize, size2 - readSize);
+      return { text: buf.toString("utf-8"), isComplete: readSize === size2 };
+    } finally {
+      fs12.closeSync(fd);
+    }
+  } catch {
+    return null;
+  }
+}
+function getTranscriptState(transcriptPath) {
+  for (let bytes = INITIAL_TAIL_BYTES;; bytes *= 2) {
+    const tail2 = readFileTail(transcriptPath, bytes);
+    if (!tail2 || tail2.text.length === 0) {
+      return { isWorking: false, lastAssistant: null };
+    }
+    const state = scanTailForState(tail2.text);
+    if (state) {
+      return state;
+    }
+    if (tail2.isComplete) {
+      return { isWorking: false, lastAssistant: null };
+    }
+  }
+}
+function scanTailForState(tail2) {
+  const lines = tail2.split(`
+`).reverse();
+  let turnFinished = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    try {
+      const entry = JSON.parse(trimmed);
+      if (entry.isSidechain === true) {
+        continue;
+      }
+      if (entry.type === "assistant") {
+        turnFinished = true;
+        if (entry.isApiErrorMessage !== true && hasCacheActivity(entry) && entry.timestamp) {
+          const parsed = new Date(entry.timestamp);
+          if (!Number.isNaN(parsed.getTime())) {
+            return { isWorking: false, lastAssistant: parsed };
+          }
+        }
+        continue;
+      }
+      if (entry.type === "user" && !turnFinished) {
+        return { isWorking: true };
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function getTtlSeconds(item) {
+  const raw = item.metadata?.[TTL_METADATA_KEY];
+  if (raw === undefined) {
+    return DEFAULT_TTL_SECONDS;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > SAFETY_MARGIN ? parsed : DEFAULT_TTL_SECONDS;
+}
+function cycleTtl(item) {
+  const current = getTtlSeconds(item);
+  const index = TTL_OPTIONS.indexOf(current);
+  const next = TTL_OPTIONS[(index + 1) % TTL_OPTIONS.length] ?? DEFAULT_TTL_SECONDS;
+  if (next === DEFAULT_TTL_SECONDS) {
+    return removeMetadataKeys(item, [TTL_METADATA_KEY]);
+  }
+  return {
+    ...item,
+    metadata: {
+      ...item.metadata,
+      [TTL_METADATA_KEY]: String(next)
+    }
+  };
+}
+function formatTtlLabel(ttlSeconds) {
+  return ttlSeconds % 3600 === 0 ? `${ttlSeconds / 3600}h` : `${Math.round(ttlSeconds / 60)}m`;
+}
+function getRemainingSeconds(lastAssistant, ttlSeconds) {
+  const elapsedSeconds = (Date.now() - lastAssistant.getTime()) / 1000;
+  return ttlSeconds - SAFETY_MARGIN - elapsedSeconds;
+}
+function formatCountdown(remaining) {
+  if (remaining <= 0) {
+    return "COLD";
+  }
+  const m = Math.floor(remaining / 60);
+  const s = Math.floor(remaining % 60);
+  return `${m}:${s.toString().padStart(2, "0")}`;
+}
+function getStateSymbol(item, remaining, ttlSeconds) {
+  if (remaining <= 0) {
+    return getSlotSymbol(item, COLD_SLOT);
+  }
+  const pct = remaining / (ttlSeconds - SAFETY_MARGIN);
+  if (pct > 0.5) {
+    return getSlotSymbol(item, FRESH_SLOT);
+  }
+  if (pct > 0.2) {
+    return getSlotSymbol(item, DRAINING_SLOT);
+  }
+  return getSlotSymbol(item, URGENT_SLOT);
+}
+function withGlyph(symbol2, text) {
+  return symbol2.length > 0 ? `${symbol2} ${text}` : text;
+}
+
+class CacheTimerWidget {
+  getDefaultColor() {
+    return "brightCyan";
+  }
+  getDescription() {
+    return "Shows time remaining on the prompt cache TTL (5m by default, 1h configurable)";
+  }
+  getDisplayName() {
+    return "Cache Timer";
+  }
+  getCategory() {
+    return "Session";
+  }
+  getEditorDisplay(item) {
+    const modifiers = [];
+    const ttlSeconds = getTtlSeconds(item);
+    if (ttlSeconds !== DEFAULT_TTL_SECONDS) {
+      modifiers.push(`ttl ${formatTtlLabel(ttlSeconds)}`);
+    }
+    if (isMetadataFlagEnabled(item, HIDE_WHEN_EMPTY_KEY3)) {
+      modifiers.push("hide when empty");
+    }
+    return {
+      displayText: this.getDisplayName(),
+      modifierText: makeModifierText(modifiers)
+    };
+  }
+  handleEditorAction(action, item) {
+    if (action === TOGGLE_HIDE_ACTION2) {
+      return toggleMetadataFlag(item, HIDE_WHEN_EMPTY_KEY3);
+    }
+    if (action === TOGGLE_TTL_ACTION) {
+      return cycleTtl(item);
+    }
+    return null;
+  }
+  render(item, context, _settings) {
+    const hideWhenEmpty = isMetadataFlagEnabled(item, HIDE_WHEN_EMPTY_KEY3);
+    if (context.isPreview) {
+      return formatRawOrLabeledValue(item, "Cache: ", withGlyph(getSlotSymbol(item, FRESH_SLOT), "4:52"));
+    }
+    const transcriptPath = context.data?.transcript_path;
+    if (!transcriptPath) {
+      return hideWhenEmpty ? null : formatRawOrLabeledValue(item, "Cache: ", "n/a");
+    }
+    const state = getTranscriptState(transcriptPath);
+    if (state.isWorking) {
+      return formatRawOrLabeledValue(item, "Cache: ", withGlyph(getSlotSymbol(item, HOT_SLOT), "HOT"));
     }
-    return formatStatus2(status.enabled, format, nerdFont);
+    const { lastAssistant } = state;
+    if (!lastAssistant) {
+      return hideWhenEmpty ? null : formatRawOrLabeledValue(item, "Cache: ", "n/a");
+    }
+    const ttlSeconds = getTtlSeconds(item);
+    const remaining = getRemainingSeconds(lastAssistant, ttlSeconds);
+    const glyph = getStateSymbol(item, remaining, ttlSeconds);
+    return formatRawOrLabeledValue(item, "Cache: ", withGlyph(glyph, formatCountdown(remaining)));
   }
   getCustomKeybinds() {
     return [
-      { key: "f", label: "(f)ormat", action: CYCLE_FORMAT_ACTION4 },
-      { key: "n", label: "(n)erd font", action: TOGGLE_NERD_FONT_ACTION4 }
+      { key: "t", label: "(t)tl", action: TOGGLE_TTL_ACTION },
+      { key: "h", label: "(h)ide when empty", action: TOGGLE_HIDE_ACTION2 },
+      getSymbolKeybind()
     ];
   }
+  renderEditor(props) {
+    return renderSymbolSlotsEditor(props, SYMBOL_SLOTS);
+  }
   supportsRawValue() {
     return true;
   }
@@ -69918,10 +70627,16 @@ class RemoteControlStatusWidget {
     return true;
   }
 }
-var SATELLITE_EMOJI = "\uD83D\uDCE1", SATELLITE_NERD_FONT = "", SATELLITE_SLASH_NERD_FONT = "", STATE_DOT_OFF2 = "○", STATE_DOT_ON2 = "◉", FORMATS4, CHECK_EMOJI = "✅", CROSS_EMOJI = "❌", CHECK_MARK = "✓", CROSS_MARK = "✗", DEFAULT_FORMAT4 = "icon", CYCLE_FORMAT_ACTION4 = "cycle-format", TOGGLE_NERD_FONT_ACTION4 = "toggle-nerd-font", NERD_FONT_METADATA_KEY4 = "nerdFont";
-var init_RemoteControlStatus = __esm(async () => {
-  await init_claude_settings();
-  FORMATS4 = ["icon", "icon-text", "text", "word", "label-check", "label-mark"];
+var HIDE_WHEN_EMPTY_KEY3 = "hideWhenEmpty", TOGGLE_HIDE_ACTION2 = "toggle-hide", TTL_METADATA_KEY = "ttlSeconds", DEFAULT_TTL_SECONDS = 300, TTL_OPTIONS, TOGGLE_TTL_ACTION = "toggle-ttl", SAFETY_MARGIN = 5, HOT_SLOT, FRESH_SLOT, DRAINING_SLOT, URGENT_SLOT, COLD_SLOT, SYMBOL_SLOTS, INITIAL_TAIL_BYTES = 32768;
+var init_CacheTimer = __esm(async () => {
+  await init_symbol_override();
+  TTL_OPTIONS = [300, 3600];
+  HOT_SLOT = { id: "symbolHot", label: "Working", defaultSymbol: "\uD83D\uDD25" };
+  FRESH_SLOT = { id: "symbolFresh", label: "Fresh", defaultSymbol: "\uD83D\uDFE2" };
+  DRAINING_SLOT = { id: "symbolDraining", label: "Draining", defaultSymbol: "\uD83D\uDFE1" };
+  URGENT_SLOT = { id: "symbolUrgent", label: "Urgent", defaultSymbol: "\uD83D\uDD34" };
+  COLD_SLOT = { id: "symbolCold", label: "Cold", defaultSymbol: "❄️" };
+  SYMBOL_SLOTS = [HOT_SLOT, FRESH_SLOT, DRAINING_SLOT, URGENT_SLOT, COLD_SLOT];
 });
 
 // src/widgets/index.ts
@@ -69932,6 +70647,7 @@ var init_widgets = __esm(async () => {
   init_GitStagedFiles();
   init_GitUnstagedFiles();
   init_GitUntrackedFiles();
+  init_GitCiStatus();
   init_GitCleanStatus();
   init_GitPr();
   init_GitSha();
@@ -69999,8 +70715,10 @@ var init_widgets = __esm(async () => {
     init_ThinkingEffort(),
     init_GitWorktreeMode(),
     init_CompactionCounter(),
+    init_SandboxStatus(),
     init_VoiceStatus(),
-    init_RemoteControlStatus()
+    init_RemoteControlStatus(),
+    init_CacheTimer()
   ]);
 });
 
@@ -70021,6 +70739,7 @@ var init_widget_manifest = __esm(async () => {
     { type: "git-clean-status", create: () => new GitCleanStatusWidget },
     { type: "git-root-dir", create: () => new GitRootDirWidget },
     { type: "git-review", create: () => new GitPrWidget },
+    { type: "git-ci-status", create: () => new GitCiStatusWidget },
     { type: "git-worktree", create: () => new GitWorktreeWidget },
     { type: "git-status", create: () => new GitStatusWidget },
     { type: "git-staged", create: () => new GitStagedWidget },
@@ -70070,6 +70789,7 @@ var init_widget_manifest = __esm(async () => {
     { type: "link", create: () => new LinkWidget },
     { type: "claude-session-id", create: () => new ClaudeSessionIdWidget },
     { type: "claude-account-email", create: () => new ClaudeAccountEmailWidget },
+    { type: "sandbox-status", create: () => new SandboxStatusWidget },
     { type: "session-name", create: () => new SessionNameWidget },
     { type: "free-memory", create: () => new FreeMemoryWidget },
     { type: "session-usage", create: () => new SessionUsageWidget },
@@ -70091,7 +70811,8 @@ var init_widget_manifest = __esm(async () => {
     { type: "worktree-name", create: () => new GitWorktreeNameWidget },
     { type: "worktree-branch", create: () => new GitWorktreeBranchWidget },
     { type: "worktree-original-branch", create: () => new GitWorktreeOriginalBranchWidget },
-    { type: "compaction-counter", create: () => new CompactionCounterWidget }
+    { type: "compaction-counter", create: () => new CompactionCounterWidget },
+    { type: "cache-timer", create: () => new CacheTimerWidget }
   ];
   LAYOUT_WIDGET_MANIFEST = [
     {
@@ -70295,7 +71016,7 @@ var init_hooks = __esm(async () => {
 });
 
 // src/utils/config.ts
-import * as fs12 from "fs";
+import * as fs13 from "fs";
 import * as os9 from "os";
 import * as path8 from "path";
 function getConfigLoadError() {
@@ -70385,7 +71106,7 @@ async function loadSettings() {
   lastLoadError = null;
   const paths = getSettingsPaths();
   try {
-    if (!fs12.existsSync(paths.settingsPath))
+    if (!fs13.existsSync(paths.settingsPath))
       return await writeDefaultSettings(paths);
     const content = await readFile3(paths.settingsPath, "utf-8");
     let rawData;
@@ -70444,7 +71165,7 @@ async function saveSettings(settings) {
 }
 async function saveInstallationMetadata(metadata) {
   const paths = getSettingsPaths();
-  if (!metadata && !fs12.existsSync(paths.settingsPath)) {
+  if (!metadata && !fs13.existsSync(paths.settingsPath)) {
     return;
   }
   const settings = await loadSettings();
@@ -70468,21 +71189,21 @@ var init_config = __esm(async () => {
   init_Settings();
   init_migrations();
   await init_widgets2();
-  readFile3 = fs12.promises.readFile;
-  writeFile = fs12.promises.writeFile;
-  mkdir = fs12.promises.mkdir;
-  rename = fs12.promises.rename;
-  unlink = fs12.promises.unlink;
-  lstat = fs12.promises.lstat;
-  readlink = fs12.promises.readlink;
-  realpath2 = fs12.promises.realpath;
+  readFile3 = fs13.promises.readFile;
+  writeFile = fs13.promises.writeFile;
+  mkdir = fs13.promises.mkdir;
+  rename = fs13.promises.rename;
+  unlink = fs13.promises.unlink;
+  lstat = fs13.promises.lstat;
+  readlink = fs13.promises.readlink;
+  realpath2 = fs13.promises.realpath;
   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 fs13 from "fs";
+import * as fs14 from "fs";
 import * as os10 from "os";
 import * as path9 from "path";
 function isKnownCommand(command) {
@@ -70509,8 +71230,8 @@ function getClaudeConfigDir() {
   if (envConfigDir) {
     try {
       const resolvedPath = path9.resolve(envConfigDir);
-      if (fs13.existsSync(resolvedPath)) {
-        const stats = fs13.statSync(resolvedPath);
+      if (fs14.existsSync(resolvedPath)) {
+        const stats = fs14.statSync(resolvedPath);
         if (stats.isDirectory()) {
           return resolvedPath;
         }
@@ -70536,7 +71257,7 @@ async function backupClaudeSettings(suffix = ".bak") {
   const settingsPath2 = getClaudeSettingsPath();
   const backupPath = settingsPath2 + suffix;
   try {
-    if (fs13.existsSync(settingsPath2)) {
+    if (fs14.existsSync(settingsPath2)) {
       const content = await readFile4(settingsPath2, "utf-8");
       await writeFile2(backupPath, content, "utf-8");
       return backupPath;
@@ -70549,11 +71270,11 @@ async function backupClaudeSettings(suffix = ".bak") {
 function loadClaudeSettingsSync(options = {}) {
   const { logErrors = true } = options;
   const settingsPath2 = getClaudeSettingsPath();
-  if (!fs13.existsSync(settingsPath2)) {
+  if (!fs14.existsSync(settingsPath2)) {
     return {};
   }
   try {
-    const content = fs13.readFileSync(settingsPath2, "utf-8");
+    const content = fs14.readFileSync(settingsPath2, "utf-8");
     return JSON.parse(content);
   } catch (error51) {
     if (logErrors) {
@@ -70565,7 +71286,7 @@ function loadClaudeSettingsSync(options = {}) {
 async function loadClaudeSettings(options = {}) {
   const { logErrors = true } = options;
   const settingsPath2 = getClaudeSettingsPath();
-  if (!fs13.existsSync(settingsPath2)) {
+  if (!fs14.existsSync(settingsPath2)) {
     return {};
   }
   try {
@@ -70718,7 +71439,7 @@ function classifyInstallation(command, metadata) {
 }
 async function loadSavedSettingsForHookSync() {
   const configPath = getConfigPath();
-  if (!fs13.existsSync(configPath)) {
+  if (!fs14.existsSync(configPath)) {
     return null;
   }
   try {
@@ -70817,7 +71538,7 @@ async function setRefreshInterval(interval) {
   }
   await saveClaudeSettings(settings);
 }
-function getVoiceConfigCandidatePathsByPriority(cwd2) {
+function getLayeredSettingsCandidatePathsByPriority(cwd2) {
   const userDir = getClaudeConfigDir();
   const projectDir = path9.join(cwd2, ".claude");
   const candidates = [
@@ -70831,7 +71552,7 @@ function getVoiceConfigCandidatePathsByPriority(cwd2) {
 function tryReadVoiceLayer(filePath) {
   let content;
   try {
-    content = fs13.readFileSync(filePath, "utf-8");
+    content = fs14.readFileSync(filePath, "utf-8");
   } catch (error51) {
     const isMissing = error51.code === "ENOENT";
     return { fileExisted: !isMissing, enabled: undefined };
@@ -70850,7 +71571,7 @@ function tryReadVoiceLayer(filePath) {
 }
 function getVoiceConfig(cwd2 = process.cwd()) {
   let anyFileExisted = false;
-  for (const filePath of getVoiceConfigCandidatePathsByPriority(cwd2)) {
+  for (const filePath of getLayeredSettingsCandidatePathsByPriority(cwd2)) {
     const layer = tryReadVoiceLayer(filePath);
     if (layer.fileExisted) {
       anyFileExisted = true;
@@ -70861,6 +71582,39 @@ function getVoiceConfig(cwd2 = process.cwd()) {
   }
   return anyFileExisted ? { enabled: false } : null;
 }
+function tryReadSandboxLayer(filePath) {
+  let content;
+  try {
+    content = fs14.readFileSync(filePath, "utf-8");
+  } catch (error51) {
+    const isMissing = error51.code === "ENOENT";
+    return { fileExisted: !isMissing, enabled: undefined };
+  }
+  try {
+    const parsed = JSON.parse(content);
+    const sandbox = parsed.sandbox;
+    if (sandbox === undefined || sandbox === null) {
+      return { fileExisted: true, enabled: undefined };
+    }
+    const result2 = SandboxConfigSchema.safeParse(sandbox);
+    return { fileExisted: true, enabled: result2.success ? result2.data.enabled : undefined };
+  } catch {
+    return { fileExisted: true, enabled: undefined };
+  }
+}
+function getSandboxConfig(cwd2 = process.cwd()) {
+  let anyFileExisted = false;
+  for (const filePath of getLayeredSettingsCandidatePathsByPriority(cwd2)) {
+    const layer = tryReadSandboxLayer(filePath);
+    if (layer.fileExisted) {
+      anyFileExisted = true;
+    }
+    if (layer.enabled !== undefined) {
+      return { enabled: layer.enabled };
+    }
+  }
+  return anyFileExisted ? { enabled: false } : null;
+}
 function getRemoteControlStatus(sessionId) {
   if (!sessionId) {
     return null;
@@ -70868,7 +71622,7 @@ function getRemoteControlStatus(sessionId) {
   const sessionsDir = path9.join(getClaudeConfigDir(), "sessions");
   let entries;
   try {
-    entries = fs13.readdirSync(sessionsDir);
+    entries = fs14.readdirSync(sessionsDir);
   } catch {
     return null;
   }
@@ -70878,7 +71632,7 @@ function getRemoteControlStatus(sessionId) {
     }
     let content;
     try {
-      content = fs13.readFileSync(path9.join(sessionsDir, entry), "utf-8");
+      content = fs14.readFileSync(path9.join(sessionsDir, entry), "utf-8");
     } catch {
       continue;
     }
@@ -70897,14 +71651,14 @@ function getRemoteControlStatus(sessionId) {
   }
   return null;
 }
-var readFile4, writeFile2, mkdir2, CCSTATUSLINE_COMMANDS, PINNED_INSTALL_COMMANDS, VoiceConfigSchema, RemoteSessionFileSchema;
+var readFile4, writeFile2, mkdir2, CCSTATUSLINE_COMMANDS, PINNED_INSTALL_COMMANDS, VoiceConfigSchema, SandboxConfigSchema, RemoteSessionFileSchema;
 var init_claude_settings = __esm(async () => {
   init_zod();
   init_Settings();
   await init_config();
-  readFile4 = fs13.promises.readFile;
-  writeFile2 = fs13.promises.writeFile;
-  mkdir2 = fs13.promises.mkdir;
+  readFile4 = fs14.promises.readFile;
+  writeFile2 = fs14.promises.writeFile;
+  mkdir2 = fs14.promises.mkdir;
   CCSTATUSLINE_COMMANDS = {
     AUTO_NPX: "npx -y ccstatusline@latest",
     AUTO_BUNX: "bunx -y ccstatusline@latest",
@@ -70918,6 +71672,7 @@ var init_claude_settings = __esm(async () => {
     BUN: (version2) => `bun add -g ccstatusline@${version2}`
   };
   VoiceConfigSchema = exports_external.object({ enabled: exports_external.boolean().optional() });
+  SandboxConfigSchema = exports_external.object({ enabled: exports_external.boolean().optional() });
   RemoteSessionFileSchema = exports_external.object({
     sessionId: exports_external.string().optional(),
     bridgeSessionId: exports_external.string().nullable().optional()
@@ -71678,7 +72433,7 @@ import {
   execFile,
   execFileSync as execFileSync6
 } from "child_process";
-import * as fs14 from "fs";
+import * as fs15 from "fs";
 var GLOBAL_PACKAGE_TIMEOUT_MS = 120000;
 var VERSION_LOOKUP_TIMEOUT_MS = 5000;
 var WINDOWS_SHIM_EXTENSIONS = [
@@ -71727,7 +72482,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) => fs14.existsSync(variant)));
+  return getBinaryPathCandidates(binDir, platform2).some((candidate) => getFilesystemPathVariants(candidate).some((variant) => fs15.existsSync(variant)));
 }
 function hasResolvedBinaryInDir(resolvedPaths, binDir) {
   return resolvedPaths.some((resolvedPath) => isPathInsideDir(resolvedPath, binDir));
@@ -71760,10 +72515,10 @@ function formatPathList2(paths) {
 function readPackageVersion(packageJsonPath) {
   for (const variant of getFilesystemPathVariants(packageJsonPath)) {
     try {
-      if (!fs14.existsSync(variant)) {
+      if (!fs15.existsSync(variant)) {
         continue;
       }
-      const packageJson = JSON.parse(fs14.readFileSync(variant, "utf-8"));
+      const packageJson = JSON.parse(fs15.readFileSync(variant, "utf-8"));
       return typeof packageJson.version === "string" ? packageJson.version : null;
     } catch {
       return null;
@@ -71989,7 +72744,7 @@ function openExternalUrl(url2) {
 
 // src/utils/powerline.ts
 import { execSync as execSync5 } from "child_process";
-import * as fs15 from "fs";
+import * as fs16 from "fs";
 import * as os12 from "os";
 import * as path11 from "path";
 var fontsInstalledThisSession = false;
@@ -72040,9 +72795,9 @@ function checkPowerlineFonts() {
       /fira.*code.*nerd/i
     ];
     for (const fontPath of fontPaths) {
-      if (fs15.existsSync(fontPath)) {
+      if (fs16.existsSync(fontPath)) {
         try {
-          const files = fs15.readdirSync(fontPath);
+          const files = fs16.readdirSync(fontPath);
           for (const file2 of files) {
             for (const pattern of powerlineFontPatterns) {
               if (pattern.test(file2)) {
@@ -72117,13 +72872,13 @@ async function installPowerlineFonts() {
         message: "Unsupported platform for font installation"
       };
     }
-    if (!fs15.existsSync(fontDir)) {
-      fs15.mkdirSync(fontDir, { recursive: true });
+    if (!fs16.existsSync(fontDir)) {
+      fs16.mkdirSync(fontDir, { recursive: true });
     }
     const tempDir = path11.join(os12.tmpdir(), `ccstatusline-powerline-fonts-${Date.now()}`);
     try {
-      if (fs15.existsSync(tempDir)) {
-        fs15.rmSync(tempDir, { recursive: true, force: true });
+      if (fs16.existsSync(tempDir)) {
+        fs16.rmSync(tempDir, { recursive: true, force: true });
       }
       execSync5(`git clone --depth=1 https://github.com/powerline/fonts.git "${tempDir}"`, {
         stdio: "pipe",
@@ -72132,8 +72887,8 @@ async function installPowerlineFonts() {
       });
       if (platform4 === "darwin" || platform4 === "linux") {
         const installScript = path11.join(tempDir, "install.sh");
-        if (fs15.existsSync(installScript)) {
-          fs15.chmodSync(installScript, 493);
+        if (fs16.existsSync(installScript)) {
+          fs16.chmodSync(installScript, 493);
           execSync5(`cd "${tempDir}" && ./install.sh`, {
             stdio: "pipe",
             encoding: "utf8",
@@ -72161,10 +72916,10 @@ async function installPowerlineFonts() {
         }
       } else {
         let findFontFiles = function(dir) {
-          const files = fs15.readdirSync(dir);
+          const files = fs16.readdirSync(dir);
           for (const file2 of files) {
             const filePath = path11.join(dir, file2);
-            const stat2 = fs15.statSync(filePath);
+            const stat2 = fs16.statSync(filePath);
             if (stat2.isDirectory() && !file2.startsWith(".")) {
               findFontFiles(filePath);
             } else if (file2.endsWith(".ttf") || file2.endsWith(".otf")) {
@@ -72181,7 +72936,7 @@ async function installPowerlineFonts() {
           const fileName = path11.basename(fontFile);
           const destPath = path11.join(fontDir, fileName);
           try {
-            fs15.copyFileSync(fontFile, destPath);
+            fs16.copyFileSync(fontFile, destPath);
             installedCount++;
           } catch {}
         }
@@ -72199,9 +72954,9 @@ async function installPowerlineFonts() {
         message: "Platform-specific installation not implemented"
       };
     } finally {
-      if (fs15.existsSync(tempDir)) {
+      if (fs16.existsSync(tempDir)) {
         try {
-          fs15.rmSync(tempDir, { recursive: true, force: true });
+          fs16.rmSync(tempDir, { recursive: true, force: true });
         } catch {}
       }
     }
@@ -73819,6 +74574,7 @@ var ColorMenu = ({ widgets, lineIndex, settings, onUpdate, onBack }) => {
 };
 // src/tui/components/GlobalOverridesMenu.tsx
 init_ColorLevel();
+init_Settings();
 init_colors();
 init_gradient();
 init_input_guards();
@@ -74005,6 +74761,15 @@ var GlobalOverridesMenu = ({ settings, onUpdate, onBack }) => {
           overrideForegroundColor: undefined
         };
         onUpdate(updatedSettings);
+      } else if (input === "d" || input === "D") {
+        const paddingSides = DefaultPaddingSideSchema.options;
+        const currentIndex = paddingSides.indexOf(settings.defaultPaddingSide);
+        const nextSide = paddingSides[(currentIndex + 1) % paddingSides.length] ?? "both";
+        const updatedSettings = {
+          ...settings,
+          defaultPaddingSide: nextSide
+        };
+        onUpdate(updatedSettings);
       }
     }
   });
@@ -74116,7 +74881,7 @@ var GlobalOverridesMenu = ({ settings, onUpdate, onBack }) => {
           /* @__PURE__ */ jsx_dev_runtime15.jsxDEV(Box_default, {
             children: [
               /* @__PURE__ */ jsx_dev_runtime15.jsxDEV(Text, {
-                children: "Enter default padding (applied to left and right of each widget): "
+                children: "Enter default padding (applied per the Padding Side setting): "
               }, undefined, false, undefined, this),
               /* @__PURE__ */ jsx_dev_runtime15.jsxDEV(Text, {
                 color: "cyan",
@@ -74242,6 +75007,21 @@ var GlobalOverridesMenu = ({ settings, onUpdate, onBack }) => {
               }, undefined, false, undefined, this)
             ]
           }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime15.jsxDEV(Box_default, {
+            children: [
+              /* @__PURE__ */ jsx_dev_runtime15.jsxDEV(Text, {
+                children: "     Padding Side: "
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsx_dev_runtime15.jsxDEV(Text, {
+                color: "cyan",
+                children: settings.defaultPaddingSide === "left" ? "Left only" : settings.defaultPaddingSide === "right" ? "Right only" : "Both"
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsx_dev_runtime15.jsxDEV(Text, {
+                dimColor: true,
+                children: " - Press (d) to cycle"
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this),
           /* @__PURE__ */ jsx_dev_runtime15.jsxDEV(Box_default, {
             children: [
               /* @__PURE__ */ jsx_dev_runtime15.jsxDEV(Text, {
@@ -74370,6 +75150,11 @@ var GlobalOverridesMenu = ({ settings, onUpdate, onBack }) => {
                 wrap: "wrap",
                 children: "Note: These settings are applied during rendering and don't add widgets to your widget list."
               }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsx_dev_runtime15.jsxDEV(Text, {
+                dimColor: true,
+                wrap: "wrap",
+                children: "• Padding Side: Choose whether default padding applies to both sides, left only, or right only"
+              }, undefined, false, undefined, this),
               /* @__PURE__ */ jsx_dev_runtime15.jsxDEV(Text, {
                 dimColor: true,
                 wrap: "wrap",
@@ -79300,14 +80085,15 @@ var StatusJSONSchema = exports_external.looseObject({
 init_ansi();
 init_colors();
 init_compaction();
+init_git_review_cache();
 await init_config();
 
 // src/utils/hook-handler.ts
-import * as fs17 from "fs";
+import * as fs18 from "fs";
 import * as path13 from "path";
 
 // src/utils/skills.ts
-import * as fs16 from "fs";
+import * as fs17 from "fs";
 import * as os14 from "os";
 import * as path12 from "path";
 var EMPTY = { totalInvocations: 0, uniqueSkills: [], lastSkill: null };
@@ -79319,11 +80105,11 @@ function getSkillsFilePath(sessionId) {
 }
 function getSkillsMetrics(sessionId) {
   const filePath = getSkillsFilePath(sessionId);
-  if (!fs16.existsSync(filePath)) {
+  if (!fs17.existsSync(filePath)) {
     return EMPTY;
   }
   try {
-    const invocations = fs16.readFileSync(filePath, "utf-8").trim().split(`
+    const invocations = fs17.readFileSync(filePath, "utf-8").trim().split(`
 `).filter((line) => line.trim()).map((line) => {
       try {
         return JSON.parse(line);
@@ -79377,14 +80163,14 @@ function handleHookInput(input) {
       return;
     }
     const filePath = getSkillsFilePath(sessionId);
-    fs17.mkdirSync(path13.dirname(filePath), { recursive: true });
+    fs18.mkdirSync(path13.dirname(filePath), { recursive: true });
     const entry = JSON.stringify({
       timestamp: new Date().toISOString(),
       session_id: sessionId,
       skill: skillName,
       source: data.hook_event_name
     });
-    fs17.appendFileSync(filePath, entry + `
+    fs18.appendFileSync(filePath, entry + `
 `);
   } catch {}
 }
@@ -79661,7 +80447,8 @@ async function renderMultipleLines(data) {
     terminalWidth: getTerminalWidth(),
     isPreview: false,
     minimalist: settings.minimalistMode,
-    gitCacheTtlSeconds: settings.gitCacheTtlSeconds
+    gitCacheTtlSeconds: settings.gitCacheTtlSeconds,
+    gitReviewNeedsChecks: lines.some((line) => line.some((item) => item.type === "git-ci-status"))
   };
   const preRenderedLines = preRenderAllWidgets(lines, settings, context);
   const preCalculatedMaxWidths = calculateMaxWidthsFromPreRendered(preRenderedLines, settings);
@@ -79736,7 +80523,24 @@ async function handleHook() {
   const input = await readStdin();
   handleHookInput(input);
 }
+function handleGitReviewRefresh() {
+  const flagIndex = process.argv.indexOf(GIT_REVIEW_REFRESH_FLAG);
+  if (flagIndex === -1) {
+    return false;
+  }
+  const cwd2 = process.argv[flagIndex + 1];
+  const mode = process.argv[flagIndex + 2];
+  const lockPath = process.argv[flagIndex + 3];
+  if (!cwd2 || mode !== "metadata" && mode !== "checks" || !lockPath) {
+    return true;
+  }
+  refreshGitReviewCacheFromCli(cwd2, { includeChecks: mode === "checks" }, lockPath);
+  return true;
+}
 async function main() {
+  if (handleGitReviewRefresh()) {
+    return;
+  }
   if (process.argv.includes("--version")) {
     console.log(getPackageVersion());
     process.exit(0);