ccstatusline 2.2.24 → 2.2.26

package/README.md

@@ -47,6 +47,14 @@
 
 ## 🆕 Recent Updates
 
+### v2.2.25 - v2.2.26 - Fable usage, migrated usage API support, compaction accuracy, and rendering reliability
+
+- **🪄 Weekly Fable usage** - Added a `Weekly Fable Usage` widget with percentage, progress-bar, remaining-mode, and time-cursor controls.
+- **📊 Reshaped usage API support** - Session and all-model weekly usage can fall back to the newer `limits[]` response, while Sonnet, Opus, and Fable weekly widgets read authoritative `weekly_scoped` entries so migrated accounts do not show stale or frozen values.
+- **🧠 Correct post-compaction context** - Context length and percentage widgets reset immediately from `compact_boundary.postTokens` after `/compact`, then switch to the first new turn instead of retaining the pre-compaction size.
+- **🧹 Reliable hidden-widget separators** - Manual separators now look past widgets that render empty, preserve the intended visible boundary, and inherit colors from the actual preceding visible widget.
+- **⚡ Non-blocking Git PR/CI refreshes** - Git PR and CI widgets render from a versioned disk cache while stale data refreshes in the background, preventing slow `gh` calls from blocking the status line.
+
 ### v2.2.22 - v2.2.24 - Powerline flex mode, cache/CI/sandbox visibility, layout controls, composable metrics, and safer config
 
 ![Powerline Flex Mode](https://raw.githubusercontent.com/sirmalloc/ccstatusline/main/screenshots/powerline-flex.png)
@@ -258,7 +266,7 @@
 
 ## ✨ Features
 
-- **📊 Real-time Metrics** - Display model name, git branch, token usage, per-model weekly usage, extra usage limits, voice input state, session duration, compaction count, block timer, and more
+- **📊 Real-time Metrics** - Display model name, git branch, token usage, Sonnet/Opus/Fable weekly usage, extra usage limits, voice input state, session duration, compaction count, block timer, and more
 - **🎨 Fully Customizable** - Choose what to display and customize colors for each element
 - **⚡ Powerline Support** - Beautiful Powerline-style rendering with arrow separators, caps, and custom fonts
 - **📐 Multi-line Support** - Configure multiple independent status lines

package/dist/ccstatusline.js

@@ -55594,12 +55594,18 @@ var init_GitUntrackedFiles = __esm(() => {
 });
 
 // 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";
@@ -55689,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) {
@@ -55798,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;
@@ -55833,12 +55877,25 @@ function mapGlabState(state) {
     return "LOCKED";
   return state.toUpperCase();
 }
-function queryGhPr(cwd2, args, fields, 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", "ignore"],
+    stdio: ["pipe", "pipe", "pipe"],
     cwd: cwd2,
-    timeout: CLI_TIMEOUT,
+    timeout: getRemainingTimeout(deadline, deps),
     windowsHide: true
   }).trim();
   if (output.length === 0) {
@@ -55846,7 +55903,7 @@ function queryGhPr(cwd2, args, fields, deps) {
   }
   return JSON.parse(output);
 }
-function fetchFromGh(cwd2, repoRef, deps) {
+function fetchFromGh(cwd2, repoRef, includeChecks, deadline, deps) {
   const args = ["pr", "view"];
   if (repoRef) {
     const branch = getCurrentBranch(cwd2, deps);
@@ -55856,10 +55913,17 @@ function fetchFromGh(cwd2, repoRef, deps) {
     args.push(branch, "--repo", repoRef);
   }
   let parsed;
-  try {
-    parsed = queryGhPr(cwd2, args, GH_PR_WITH_CHECKS_FIELDS, deps);
-  } catch {
-    parsed = queryGhPr(cwd2, args, GH_PR_METADATA_FIELDS, deps);
+  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;
@@ -55877,7 +55941,7 @@ function fetchFromGh(cwd2, repoRef, deps) {
     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);
@@ -55891,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) {
@@ -55910,41 +55974,129 @@ 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) {
+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") {
-    return cached2;
+  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, deps)) {
+    if (!isCliAvailable(provider, deadline, deps)) {
       continue;
     }
     try {
-      const data = fetchFromProvider(provider, cwd2, repoRef, deps);
+      const data = fetchFromProvider(provider, cwd2, repoRef, includeChecks, deadline, deps);
       if (data) {
-        writeCache(cachePath, data, deps);
+        writeCache(cachePath, data, includeChecks, deps);
         return data;
       }
     } catch {}
   }
-  writeCache(cachePath, null, deps);
+  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";
@@ -55964,20 +56116,28 @@ function truncateTitle(title, maxWidth) {
     return title;
   return `${title.slice(0, limit - 1)}…`;
 }
-var GIT_REVIEW_CACHE_TTL = 30000, CLI_TIMEOUT = 5000, DEFAULT_TITLE_MAX_WIDTH = 30, GH_PR_METADATA_FIELDS = "url,number,title,state,reviewDecision", GH_PR_WITH_CHECKS_FIELDS, DEFAULT_GIT_REVIEW_CACHE_DEPS;
+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
@@ -56029,7 +56189,7 @@ class GitCiStatusWidget {
       return isHideNoGitEnabled(item) ? null : "(no git)";
     }
     const cwd2 = this.deps.resolveGitCwd(context) ?? this.deps.getProcessCwd();
-    const checks3 = this.deps.fetchGitReviewData(cwd2)?.checks;
+    const checks3 = this.deps.getCachedGitReviewData(cwd2, { includeChecks: true })?.checks;
     if (!checks3) {
       return NO_CHECKS;
     }
@@ -56057,7 +56217,7 @@ var init_GitCiStatus = __esm(() => {
     pending: "●"
   };
   DEFAULT_DEPS = {
-    fetchGitReviewData,
+    getCachedGitReviewData,
     getProcessCwd: () => process.cwd(),
     isInsideGitWorkTree,
     resolveGitCwd
@@ -56334,7 +56494,7 @@ class GitPrWidget {
       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)})`;
     }
@@ -56362,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,
@@ -58127,7 +58287,7 @@ function getTerminalWidth() {
 function canDetectTerminalWidth() {
   return probeTerminalWidth() !== null;
 }
-var __dirname = "/home/runner/work/ccstatusline/ccstatusline/src/utils", PACKAGE_VERSION = "2.2.24";
+var __dirname = "/home/runner/work/ccstatusline/ccstatusline/src/utils", PACKAGE_VERSION = "2.2.26";
 var init_terminal = () => {};
 
 // src/utils/format-tokens.ts
@@ -58601,6 +58761,9 @@ function formatSeparator(sep) {
   }
   return sep;
 }
+function isSpacingSeparator(widget, defaultSeparator) {
+  return widget?.type === "separator" && (widget.character ?? defaultSeparator ?? "|").trim().length === 0;
+}
 function countPowerlineStartCapSlots(widgets, preRenderedWidgets) {
   let pendingFlexAfterRenderedSegment = false;
   let hasRenderedSegment = false;
@@ -58754,27 +58917,44 @@ function renderStatusLine(widgets, settings, context, preRenderedWidgets, preCal
     if (!widget)
       continue;
     if (widget.type === "separator") {
-      let hasContentBefore = false;
+      let contentBeforeIndex = null;
+      let replacesSpacingSeparator = false;
+      let crossedEmptyWidget = false;
       for (let j = i - 1;j >= 0; j--) {
         const prevWidget = widgets[j];
         if (!prevWidget)
           continue;
-        if (prevWidget.type === "separator" || prevWidget.type === "flex-separator")
+        if (prevWidget.type === "separator") {
+          if (!isSpacingSeparator(prevWidget, settings.defaultSeparator))
+            break;
+          replacesSpacingSeparator = true;
           continue;
-        hasContentBefore = Boolean(preRenderedWidgets[j]?.content);
-        break;
+        }
+        if (prevWidget.type === "flex-separator")
+          break;
+        if (preRenderedWidgets[j]?.content) {
+          if (!prevWidget.merge || !crossedEmptyWidget)
+            contentBeforeIndex = j;
+          break;
+        }
+        crossedEmptyWidget = true;
       }
-      if (!hasContentBefore)
+      if (contentBeforeIndex === null)
         continue;
+      if (replacesSpacingSeparator) {
+        while (isSpacingSeparator(elements[elements.length - 1]?.widget, settings.defaultSeparator)) {
+          elements.pop();
+        }
+      }
       const sepChar = widget.character ?? (settings.defaultSeparator ?? "|");
       const formattedSep = formatSeparator(sepChar);
       let separatorColor = widget.color ?? "gray";
       let separatorBg = widget.backgroundColor;
       let separatorBold = widget.bold;
       let separatorDim = widget.dim;
-      if (settings.inheritSeparatorColors && i > 0 && !widget.color && !widget.backgroundColor) {
-        const prevWidget = widgets[i - 1];
-        if (prevWidget && prevWidget.type !== "separator" && prevWidget.type !== "flex-separator") {
+      if (settings.inheritSeparatorColors && !widget.color && !widget.backgroundColor) {
+        const prevWidget = widgets[contentBeforeIndex];
+        if (prevWidget) {
           let widgetColor = prevWidget.color;
           if (!widgetColor) {
             const widgetImpl = getWidget(prevWidget.type);
@@ -61720,12 +61900,20 @@ var init_dist5 = __esm(() => {
 });
 
 // src/utils/usage-types.ts
-var FIVE_HOUR_BLOCK_MS, SEVEN_DAY_WINDOW_MS, UsageErrorSchema;
+function setUsageField(target, field, value) {
+  target[field] = value;
+}
+var FIVE_HOUR_BLOCK_MS, SEVEN_DAY_WINDOW_MS, UsageErrorSchema, WEEKLY_MODEL_USAGE_BUCKETS;
 var init_usage_types = __esm(() => {
   init_zod();
   FIVE_HOUR_BLOCK_MS = 5 * 60 * 60 * 1000;
   SEVEN_DAY_WINDOW_MS = 7 * 24 * 60 * 60 * 1000;
   UsageErrorSchema = exports_external.enum(["no-credentials", "timeout", "rate-limited", "api-error", "parse-error"]);
+  WEEKLY_MODEL_USAGE_BUCKETS = [
+    { widgetType: "weekly-sonnet-usage", modelDisplayName: "Sonnet", apiBucketKey: "seven_day_sonnet", usageField: "weeklySonnetUsage", resetField: "weeklySonnetResetAt" },
+    { widgetType: "weekly-opus-usage", modelDisplayName: "Opus", apiBucketKey: "seven_day_opus", usageField: "weeklyOpusUsage", resetField: "weeklyOpusResetAt" },
+    { widgetType: "fable-weekly-usage", modelDisplayName: "Fable", usageField: "fableUsage", resetField: "fableResetAt" }
+  ];
 });
 
 // src/utils/usage-fetch.ts
@@ -61738,6 +61926,22 @@ import * as path4 from "path";
 function getUsageApiBucketUtilization(bucket) {
   return bucket === null ? 0 : bucket?.utilization ?? undefined;
 }
+function findUsageApiLimit(limits, kind) {
+  return limits?.find((limit) => limit.kind === kind);
+}
+function isPlaceholderUsageApiLimit(limit) {
+  return (limit.percent ?? 0) === 0 && (limit.resets_at ?? null) === null;
+}
+function getUsageApiLimitPercent(limit) {
+  return limit && !isPlaceholderUsageApiLimit(limit) ? limit.percent ?? undefined : undefined;
+}
+function getUsageApiLimitResetAt(limit) {
+  return limit && !isPlaceholderUsageApiLimit(limit) ? limit.resets_at ?? undefined : undefined;
+}
+function findWeeklyScopedLimit(limits, modelDisplayName) {
+  const normalizedModelName = modelDisplayName.toLowerCase();
+  return limits?.find((limit) => limit.kind === "weekly_scoped" && (limit.scope?.model?.display_name ?? "").toLowerCase().includes(normalizedModelName));
+}
 function parseJsonWithSchema(rawJson, schema) {
   try {
     const parsed = schema.safeParse(JSON.parse(rawJson));
@@ -61765,6 +61969,8 @@ function parseCachedUsageData(rawJson) {
     weeklySonnetResetAt: parsed.weeklySonnetResetAt ?? undefined,
     weeklyOpusUsage: parsed.weeklyOpusUsage ?? undefined,
     weeklyOpusResetAt: parsed.weeklyOpusResetAt ?? undefined,
+    fableUsage: parsed.fableUsage ?? undefined,
+    fableResetAt: parsed.fableResetAt ?? undefined,
     extraUsageEnabled: parsed.extraUsageEnabled ?? undefined,
     extraUsageLimit: parsed.extraUsageLimit ?? undefined,
     extraUsageUsed: parsed.extraUsageUsed ?? undefined,
@@ -61785,26 +61991,34 @@ function tokenHashMatches(cachedHash, currentHash) {
   }
   return cachedHash === currentHash;
 }
+function getLegacyUsageApiBucket(parsed, apiBucketKey) {
+  return parsed[apiBucketKey];
+}
 function parseUsageApiResponse(rawJson) {
   const parsed = parseJsonWithSchema(rawJson, UsageApiResponseSchema);
   if (!parsed) {
     return null;
   }
-  return {
-    sessionUsage: getUsageApiBucketUtilization(parsed.five_hour),
-    sessionResetAt: parsed.five_hour?.resets_at ?? undefined,
-    weeklyUsage: getUsageApiBucketUtilization(parsed.seven_day),
-    weeklyResetAt: parsed.seven_day?.resets_at ?? undefined,
-    weeklySonnetUsage: getUsageApiBucketUtilization(parsed.seven_day_sonnet),
-    weeklySonnetResetAt: parsed.seven_day_sonnet?.resets_at ?? undefined,
-    weeklyOpusUsage: getUsageApiBucketUtilization(parsed.seven_day_opus),
-    weeklyOpusResetAt: parsed.seven_day_opus?.resets_at ?? undefined,
+  const sessionLimit = findUsageApiLimit(parsed.limits, "session");
+  const weeklyLimit = findUsageApiLimit(parsed.limits, "weekly_all");
+  const result2 = {
+    sessionUsage: getUsageApiBucketUtilization(parsed.five_hour) ?? getUsageApiLimitPercent(sessionLimit),
+    sessionResetAt: parsed.five_hour?.resets_at ?? getUsageApiLimitResetAt(sessionLimit),
+    weeklyUsage: getUsageApiBucketUtilization(parsed.seven_day) ?? getUsageApiLimitPercent(weeklyLimit),
+    weeklyResetAt: parsed.seven_day?.resets_at ?? getUsageApiLimitResetAt(weeklyLimit),
     extraUsageEnabled: parsed.extra_usage?.is_enabled ?? undefined,
     extraUsageLimit: parsed.extra_usage?.monthly_limit ?? undefined,
     extraUsageUsed: parsed.extra_usage?.used_credits ?? undefined,
     extraUsageUtilization: parsed.extra_usage?.utilization ?? undefined,
     extraUsageCurrency: parsed.extra_usage?.currency ?? undefined
   };
+  for (const bucket of WEEKLY_MODEL_USAGE_BUCKETS) {
+    const scopedLimit = findWeeklyScopedLimit(parsed.limits, bucket.modelDisplayName);
+    const legacyBucket = bucket.apiBucketKey ? getLegacyUsageApiBucket(parsed, bucket.apiBucketKey) : undefined;
+    setUsageField(result2, bucket.usageField, getUsageApiLimitPercent(scopedLimit) ?? getUsageApiBucketUtilization(legacyBucket));
+    setUsageField(result2, bucket.resetField, getUsageApiLimitResetAt(scopedLimit) ?? legacyBucket?.resets_at ?? undefined);
+  }
+  return result2;
 }
 function ensureCacheDirExists() {
   if (!fs4.existsSync(CACHE_DIR)) {
@@ -61832,7 +62046,10 @@ function hasRequiredUsageField(data, field) {
   if (windowSentinel !== undefined && data[windowSentinel] !== undefined) {
     return true;
   }
-  return data.extraUsageEnabled !== undefined && EXTRA_USAGE_DETAIL_FIELDS.has(field);
+  if (data.extraUsageEnabled !== undefined && EXTRA_USAGE_DETAIL_FIELDS.has(field)) {
+    return true;
+  }
+  return (data.sessionUsage !== undefined || data.weeklyUsage !== undefined) && FABLE_USAGE_FIELDS.has(field);
 }
 function hasRequiredUsageFields(data, requiredFields = []) {
   return requiredFields.every((field) => hasRequiredUsageField(data, field));
@@ -62165,7 +62382,7 @@ async function fetchUsageData(options = {}) {
     return getStaleUsageOrError("parse-error", now2, currentTokenHash, LOCK_MAX_AGE, requiredFields);
   }
 }
-var CACHE_DIR, CACHE_FILE, LOCK_FILE, CACHE_MAX_AGE = 180, LOCK_MAX_AGE = 30, DEFAULT_RATE_LIMIT_BACKOFF = 300, MACOS_USAGE_CREDENTIALS_SERVICE = "Claude Code-credentials", MACOS_SECURITY_DUMP_MAX_BUFFER, EXTRA_USAGE_DETAIL_FIELDS, WINDOW_RESET_FIELD_SENTINELS, UsageCredentialsSchema, UsageLockErrorSchema, UsageLockSchema, CachedUsageDataSchema, CachedTokenHashSchema, UsageApiBucketSchema, UsageApiResponseSchema, cachedUsageData = null, usageCacheTime = 0, usageErrorCacheMaxAge, USAGE_API_HOST = "api.anthropic.com", USAGE_API_PATH = "/api/oauth/usage", USAGE_API_TIMEOUT_MS = 5000;
+var CACHE_DIR, CACHE_FILE, LOCK_FILE, CACHE_MAX_AGE = 180, LOCK_MAX_AGE = 30, DEFAULT_RATE_LIMIT_BACKOFF = 300, MACOS_USAGE_CREDENTIALS_SERVICE = "Claude Code-credentials", MACOS_SECURITY_DUMP_MAX_BUFFER, EXTRA_USAGE_DETAIL_FIELDS, FABLE_USAGE_FIELDS, WINDOW_RESET_FIELD_SENTINELS, UsageCredentialsSchema, UsageLockErrorSchema, UsageLockSchema, CachedUsageDataSchema, CachedTokenHashSchema, UsageApiBucketSchema, UsageApiLimitSchema, UsageApiResponseSchema, cachedUsageData = null, usageCacheTime = 0, usageErrorCacheMaxAge, USAGE_API_HOST = "api.anthropic.com", USAGE_API_PATH = "/api/oauth/usage", USAGE_API_TIMEOUT_MS = 5000;
 var init_usage_fetch = __esm(async () => {
   init_dist5();
   init_zod();
@@ -62180,11 +62397,14 @@ var init_usage_fetch = __esm(async () => {
     "extraUsageUsed",
     "extraUsageUtilization"
   ]);
+  FABLE_USAGE_FIELDS = new Set([
+    "fableUsage",
+    "fableResetAt"
+  ]);
   WINDOW_RESET_FIELD_SENTINELS = {
     sessionResetAt: "sessionUsage",
     weeklyResetAt: "weeklyUsage",
-    weeklySonnetResetAt: "weeklySonnetUsage",
-    weeklyOpusResetAt: "weeklyOpusUsage"
+    ...Object.fromEntries(WEEKLY_MODEL_USAGE_BUCKETS.map((bucket) => [bucket.resetField, bucket.usageField]))
   };
   UsageCredentialsSchema = exports_external.object({ claudeAiOauth: exports_external.object({ accessToken: exports_external.string().nullable().optional() }).optional() });
   UsageLockErrorSchema = exports_external.enum(["timeout", "rate-limited", "parse-error"]);
@@ -62201,6 +62421,8 @@ var init_usage_fetch = __esm(async () => {
     weeklySonnetResetAt: exports_external.string().nullable().optional(),
     weeklyOpusUsage: exports_external.number().nullable().optional(),
     weeklyOpusResetAt: exports_external.string().nullable().optional(),
+    fableUsage: exports_external.number().nullable().optional(),
+    fableResetAt: exports_external.string().nullable().optional(),
     extraUsageEnabled: exports_external.boolean().nullable().optional(),
     extraUsageLimit: exports_external.number().nullable().optional(),
     extraUsageUsed: exports_external.number().nullable().optional(),
@@ -62213,11 +62435,18 @@ var init_usage_fetch = __esm(async () => {
     utilization: exports_external.number().nullable().optional(),
     resets_at: exports_external.string().nullable().optional()
   }).nullable().optional();
+  UsageApiLimitSchema = exports_external.looseObject({
+    kind: exports_external.string().nullable().optional(),
+    percent: exports_external.number().nullable().optional(),
+    resets_at: exports_external.string().nullable().optional(),
+    scope: exports_external.looseObject({ model: exports_external.looseObject({ display_name: exports_external.string().nullable().optional() }).nullable().optional() }).nullable().catch(null).optional()
+  });
   UsageApiResponseSchema = exports_external.looseObject({
     five_hour: UsageApiBucketSchema,
     seven_day: UsageApiBucketSchema,
     seven_day_sonnet: UsageApiBucketSchema,
     seven_day_opus: UsageApiBucketSchema,
+    limits: exports_external.array(UsageApiLimitSchema).nullable().optional(),
     extra_usage: exports_external.looseObject({
       is_enabled: exports_external.boolean().nullable().optional(),
       monthly_limit: exports_external.number().nullable().optional(),
@@ -64973,8 +65202,79 @@ var init_jsonl_cache = __esm(async () => {
   existsSync6 = fs7.existsSync;
 });
 
-// src/utils/jsonl-metrics.ts
+// src/utils/compaction.ts
 import * as fs8 from "fs";
+function isCompactBoundary(record2) {
+  if (typeof record2 !== "object" || record2 === null) {
+    return false;
+  }
+  const r = record2;
+  return r.type === "system" && r.subtype === "compact_boundary" && r.isSidechain !== true;
+}
+function getCompactBoundaryPostTokens(record2) {
+  if (!isCompactBoundary(record2)) {
+    return null;
+  }
+  const meta3 = record2.compactMetadata;
+  const post = typeof meta3 === "object" && meta3 !== null ? meta3.postTokens : undefined;
+  return typeof post === "number" && Number.isFinite(post) ? Math.max(0, post) : null;
+}
+function computeCompactionStats(lines) {
+  const stats = {
+    count: 0,
+    byTrigger: { auto: 0, manual: 0, unknown: 0 },
+    tokensReclaimed: 0
+  };
+  for (const line of lines) {
+    const record2 = parseJsonlLine(line);
+    if (!isCompactBoundary(record2)) {
+      continue;
+    }
+    stats.count += 1;
+    const meta3 = record2.compactMetadata;
+    const metaRecord = typeof meta3 === "object" && meta3 !== null ? meta3 : null;
+    const trigger = metaRecord?.trigger;
+    if (trigger === "auto") {
+      stats.byTrigger.auto += 1;
+    } else if (trigger === "manual") {
+      stats.byTrigger.manual += 1;
+    } else {
+      stats.byTrigger.unknown += 1;
+    }
+    const pre = metaRecord?.preTokens;
+    const post = metaRecord?.postTokens;
+    if (typeof pre === "number" && typeof post === "number") {
+      const reclaimed = pre - post;
+      if (Number.isFinite(reclaimed)) {
+        stats.tokensReclaimed += Math.max(0, reclaimed);
+      }
+    }
+  }
+  return stats;
+}
+async function getCompactionStats(transcriptPath) {
+  try {
+    if (!fs8.existsSync(transcriptPath)) {
+      return ZERO_COMPACTION_STATS;
+    }
+    const lines = await readJsonlLines(transcriptPath);
+    return computeCompactionStats(lines);
+  } catch {
+    return ZERO_COMPACTION_STATS;
+  }
+}
+var ZERO_COMPACTION_STATS;
+var init_compaction = __esm(() => {
+  init_jsonl_lines();
+  ZERO_COMPACTION_STATS = Object.freeze({
+    count: 0,
+    byTrigger: Object.freeze({ auto: 0, manual: 0, unknown: 0 }),
+    tokensReclaimed: 0
+  });
+});
+
+// src/utils/jsonl-metrics.ts
+import * as fs9 from "fs";
 import path7 from "node:path";
 function collectAgentIds(value, agentIds) {
   if (!value || typeof value !== "object") {
@@ -65007,7 +65307,7 @@ function getReferencedSubagentIds(lines) {
 }
 async function getSessionDuration(transcriptPath) {
   try {
-    if (!fs8.existsSync(transcriptPath)) {
+    if (!fs9.existsSync(transcriptPath)) {
       return null;
     }
     const lines = await readJsonlLines(transcriptPath);
@@ -65057,7 +65357,7 @@ async function getSessionDuration(transcriptPath) {
 }
 async function getTokenMetrics(transcriptPath) {
   try {
-    if (!fs8.existsSync(transcriptPath)) {
+    if (!fs9.existsSync(transcriptPath)) {
       return { inputTokens: 0, outputTokens: 0, cachedTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0, totalTokens: 0, contextLength: 0 };
     }
     const lines = await readJsonlLines(transcriptPath);
@@ -65068,22 +65368,30 @@ async function getTokenMetrics(transcriptPath) {
     let contextLength = 0;
     let mostRecentMainChainEntry = null;
     let mostRecentTimestamp = null;
+    let mostRecentPostCompactionEntry = null;
+    let mostRecentPostCompactionTimestamp = null;
+    let lastCompactBoundaryLineIndex = -1;
+    let lastCompactBoundaryPostTokens = null;
     const parsedEntries = [];
     let hasStopReasonField = false;
-    for (const line of lines) {
+    for (const [lineIndex, line] of lines.entries()) {
       const data = parseJsonlLine(line);
+      if (isCompactBoundary(data)) {
+        lastCompactBoundaryLineIndex = lineIndex;
+        lastCompactBoundaryPostTokens = getCompactBoundaryPostTokens(data);
+      }
       if (data?.message?.usage) {
-        parsedEntries.push(data);
+        parsedEntries.push({ data, lineIndex });
         if (Object.hasOwn(data.message, "stop_reason")) {
           hasStopReasonField = true;
         }
       }
     }
-    const entriesToCount = hasStopReasonField ? parsedEntries.filter((data, index) => {
-      const stopReason = data.message?.stop_reason;
+    const entriesToCount = hasStopReasonField ? parsedEntries.filter((entry, index) => {
+      const stopReason = entry.data.message?.stop_reason;
       return Boolean(stopReason) || stopReason === null && index === parsedEntries.length - 1;
     }) : parsedEntries;
-    for (const data of entriesToCount) {
+    for (const { data, lineIndex } of entriesToCount) {
       const usage = data.message?.usage;
       if (!usage) {
         continue;
@@ -65098,12 +65406,20 @@ async function getTokenMetrics(transcriptPath) {
           mostRecentTimestamp = entryTime;
           mostRecentMainChainEntry = data;
         }
+        if (lineIndex > lastCompactBoundaryLineIndex && (!mostRecentPostCompactionTimestamp || entryTime > mostRecentPostCompactionTimestamp)) {
+          mostRecentPostCompactionTimestamp = entryTime;
+          mostRecentPostCompactionEntry = data;
+        }
       }
     }
-    if (mostRecentMainChainEntry?.message?.usage) {
-      const usage = mostRecentMainChainEntry.message.usage;
-      contextLength = (usage.input_tokens || 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0);
-    }
+    const contextLengthFromEntry = (entry) => {
+      const usage = entry?.message?.usage;
+      if (!usage) {
+        return null;
+      }
+      return (usage.input_tokens || 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0);
+    };
+    contextLength = lastCompactBoundaryLineIndex >= 0 ? contextLengthFromEntry(mostRecentPostCompactionEntry) ?? lastCompactBoundaryPostTokens ?? 0 : contextLengthFromEntry(mostRecentMainChainEntry) ?? 0;
     const cachedTokens = cacheReadTokens + cacheCreationTokens;
     const totalTokens = inputTokens + outputTokens + cachedTokens;
     return { inputTokens, outputTokens, cachedTokens, cacheReadTokens, cacheCreationTokens, totalTokens, contextLength };
@@ -65282,11 +65598,11 @@ function getSubagentTranscriptPaths(transcriptPath, referencedAgentIds) {
   const seenPaths = new Set;
   const matchedPaths = [];
   for (const subagentsDir of candidateDirs) {
-    if (!fs8.existsSync(subagentsDir)) {
+    if (!fs9.existsSync(subagentsDir)) {
       continue;
     }
     try {
-      const dirEntries = fs8.readdirSync(subagentsDir, { withFileTypes: true });
+      const dirEntries = fs9.readdirSync(subagentsDir, { withFileTypes: true });
       for (const entry of dirEntries) {
         if (!entry.isFile()) {
           continue;
@@ -65315,7 +65631,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 (!fs8.existsSync(transcriptPath)) {
+    if (!fs9.existsSync(transcriptPath)) {
       return {
         sessionAverage: createEmptySpeedMetrics(),
         windowed: emptyWindowedMetrics
@@ -65360,6 +65676,7 @@ async function getSpeedMetricsCollection(transcriptPath, options = {}) {
   }
 }
 var init_jsonl_metrics = __esm(() => {
+  init_compaction();
   init_jsonl_lines();
 });
 
@@ -65498,6 +65815,9 @@ function resolveWeeklySonnetUsageWindow(usageData, nowMs = Date.now()) {
 function resolveWeeklyOpusUsageWindow(usageData, nowMs = Date.now()) {
   return getWeeklyUsageWindowFromResetAt(usageData.weeklyOpusResetAt ?? usageData.weeklyResetAt, nowMs);
 }
+function resolveFableUsageWindow(usageData, nowMs = Date.now()) {
+  return getWeeklyUsageWindowFromResetAt(usageData.fableResetAt ?? usageData.weeklyResetAt, nowMs);
+}
 function formatUsageDuration(durationMs, compact2 = false, useDays = true) {
   const clampedMs = Math.max(0, durationMs);
   const totalHours = Math.floor(clampedMs / (1000 * 60 * 60));
@@ -66712,7 +67032,7 @@ var init_JjRevision = __esm(() => {
 });
 
 // src/widgets/ClaudeAccountEmail.ts
-import * as fs9 from "fs";
+import * as fs10 from "fs";
 
 class ClaudeAccountEmailWidget {
   getDefaultColor() {
@@ -66735,7 +67055,7 @@ class ClaudeAccountEmailWidget {
       return item.rawValue ? "you@example.com" : "Account: you@example.com";
     }
     try {
-      const content = fs9.readFileSync(getClaudeJsonPath(), "utf-8");
+      const content = fs10.readFileSync(getClaudeJsonPath(), "utf-8");
       const data = JSON.parse(content);
       const email3 = data.oauthAccount?.emailAddress;
       if (typeof email3 !== "string" || email3.length === 0) {
@@ -67173,7 +67493,7 @@ class FreeMemoryWidget {
 var init_FreeMemory = () => {};
 
 // src/widgets/SessionName.ts
-import * as fs10 from "fs";
+import * as fs11 from "fs";
 
 class SessionNameWidget {
   getDefaultColor() {
@@ -67200,7 +67520,7 @@ class SessionNameWidget {
       return null;
     }
     try {
-      const content = fs10.readFileSync(transcriptPath, "utf-8");
+      const content = fs11.readFileSync(transcriptPath, "utf-8");
       const lines = content.split(`
 `);
       for (let i = lines.length - 1;i >= 0; i--) {
@@ -67879,6 +68199,102 @@ var init_WeeklyOpusUsage = __esm(async () => {
   await init_usage();
 });
 
+// src/widgets/FableWeeklyUsage.ts
+class FableWeeklyUsageWidget {
+  getDefaultColor() {
+    return "brightBlue";
+  }
+  getDescription() {
+    return "Shows Fable-only weekly usage percentage";
+  }
+  getDisplayName() {
+    return "Weekly Fable Usage";
+  }
+  getCategory() {
+    return "Usage";
+  }
+  getEditorDisplay(item) {
+    return {
+      displayText: this.getDisplayName(),
+      modifierText: getUsageDisplayModifierText(item, { showUsageDirection: true })
+    };
+  }
+  handleEditorAction(action, item) {
+    if (action === "toggle-progress") {
+      return cycleUsageDisplayMode(item, [], true, true);
+    }
+    if (action === "toggle-invert") {
+      return toggleUsageInverted(item);
+    }
+    if (action === "toggle-cursor") {
+      return toggleUsageCursor(item);
+    }
+    return null;
+  }
+  render(item, context, settings) {
+    const displayMode = getUsageDisplayMode(item);
+    const inverted = isUsageInverted(item);
+    const showCursor = isUsageCursorEnabled(item);
+    if (context.isPreview) {
+      const previewPercent = 4;
+      const renderedPercent2 = inverted ? 100 - previewPercent : previewPercent;
+      if (isUsageProgressMode(displayMode)) {
+        const width = getUsageProgressBarWidth(displayMode);
+        const progressBar = makeTimerProgressBar2(renderedPercent2, width, showCursor ? { cursorPercent: 50 } : undefined);
+        const progressDisplay = `[${progressBar}] ${renderedPercent2.toFixed(1)}%`;
+        return formatRawOrLabeledValue(item, LABEL3, progressDisplay);
+      }
+      if (isUsageSliderMode(displayMode)) {
+        const slider = makeSliderBar(renderedPercent2, undefined, showCursor ? { cursorPercent: 50 } : undefined);
+        const sliderDisplay = displayMode === "slider" ? `${slider} ${renderedPercent2.toFixed(1)}%` : slider;
+        return formatRawOrLabeledValue(item, LABEL3, sliderDisplay);
+      }
+      return formatRawOrLabeledValue(item, LABEL3, `${renderedPercent2.toFixed(1)}%`);
+    }
+    const data = context.usageData ?? {};
+    if (data.fableUsage === undefined) {
+      if (data.error)
+        return getUsageErrorMessage(data.error);
+      return null;
+    }
+    const percent = Math.max(0, Math.min(100, data.fableUsage));
+    const renderedPercent = inverted ? 100 - percent : percent;
+    const getCursorOptions = () => {
+      if (!showCursor) {
+        return;
+      }
+      const window2 = resolveFableUsageWindow(data);
+      return window2 ? { cursorPercent: window2.elapsedPercent } : undefined;
+    };
+    if (isUsageProgressMode(displayMode)) {
+      const width = getUsageProgressBarWidth(displayMode);
+      const progressBar = makeTimerProgressBar2(renderedPercent, width, getCursorOptions());
+      const progressDisplay = `[${progressBar}] ${renderedPercent.toFixed(1)}%`;
+      return formatRawOrLabeledValue(item, LABEL3, progressDisplay);
+    }
+    if (isUsageSliderMode(displayMode)) {
+      const slider = makeSliderBar(renderedPercent, undefined, getCursorOptions());
+      const sliderDisplay = displayMode === "slider" ? `${slider} ${renderedPercent.toFixed(1)}%` : slider;
+      return formatRawOrLabeledValue(item, LABEL3, sliderDisplay);
+    }
+    return formatRawOrLabeledValue(item, LABEL3, `${renderedPercent.toFixed(1)}%`);
+  }
+  getCustomKeybinds(item) {
+    return getUsagePercentCustomKeybinds(item);
+  }
+  supportsRawValue() {
+    return true;
+  }
+  supportsColors(item) {
+    return true;
+  }
+}
+var LABEL3 = "Fable Weekly: ";
+var init_FableWeeklyUsage = __esm(async () => {
+  init_usage_display();
+  await init_usage();
+});
+
 // src/widgets/shared/locale-editor.tsx
 function getInitialSelectedIndex(options, currentLocale) {
   const selectedValue = currentLocale ? canonicalizeLocale(currentLocale) : DEFAULT_RESET_LOCALE;
@@ -69515,69 +69931,6 @@ class GitWorktreeOriginalBranchWidget {
   }
 }
 
-// src/utils/compaction.ts
-import * as fs11 from "fs";
-function isCompactBoundary(record2) {
-  if (typeof record2 !== "object" || record2 === null) {
-    return false;
-  }
-  const r = record2;
-  return r.type === "system" && r.subtype === "compact_boundary" && r.isSidechain !== true;
-}
-function computeCompactionStats(lines) {
-  const stats = {
-    count: 0,
-    byTrigger: { auto: 0, manual: 0, unknown: 0 },
-    tokensReclaimed: 0
-  };
-  for (const line of lines) {
-    const record2 = parseJsonlLine(line);
-    if (!isCompactBoundary(record2)) {
-      continue;
-    }
-    stats.count += 1;
-    const meta3 = record2.compactMetadata;
-    const metaRecord = typeof meta3 === "object" && meta3 !== null ? meta3 : null;
-    const trigger = metaRecord?.trigger;
-    if (trigger === "auto") {
-      stats.byTrigger.auto += 1;
-    } else if (trigger === "manual") {
-      stats.byTrigger.manual += 1;
-    } else {
-      stats.byTrigger.unknown += 1;
-    }
-    const pre = metaRecord?.preTokens;
-    const post = metaRecord?.postTokens;
-    if (typeof pre === "number" && typeof post === "number") {
-      const reclaimed = pre - post;
-      if (Number.isFinite(reclaimed)) {
-        stats.tokensReclaimed += Math.max(0, reclaimed);
-      }
-    }
-  }
-  return stats;
-}
-async function getCompactionStats(transcriptPath) {
-  try {
-    if (!fs11.existsSync(transcriptPath)) {
-      return ZERO_COMPACTION_STATS;
-    }
-    const lines = await readJsonlLines(transcriptPath);
-    return computeCompactionStats(lines);
-  } catch {
-    return ZERO_COMPACTION_STATS;
-  }
-}
-var ZERO_COMPACTION_STATS;
-var init_compaction = __esm(() => {
-  init_jsonl_lines();
-  ZERO_COMPACTION_STATS = Object.freeze({
-    count: 0,
-    byTrigger: Object.freeze({ auto: 0, manual: 0, unknown: 0 }),
-    tokensReclaimed: 0
-  });
-});
-
 // src/widgets/CompactionCounter.ts
 function getFormat2(item) {
   const format = item.metadata?.format;
@@ -70547,6 +70900,7 @@ var init_widgets = __esm(async () => {
     init_ExtraUsageUsed(),
     init_WeeklySonnetUsage(),
     init_WeeklyOpusUsage(),
+    init_FableWeeklyUsage(),
     init_BlockResetTimer(),
     init_WeeklyResetTimer(),
     init_ContextBar(),
@@ -70639,6 +70993,7 @@ var init_widget_manifest = __esm(async () => {
     { type: "extra-usage-used", create: () => new ExtraUsageUsedWidget },
     { type: "weekly-sonnet-usage", create: () => new WeeklySonnetUsageWidget },
     { type: "weekly-opus-usage", create: () => new WeeklyOpusUsageWidget },
+    { type: "fable-weekly-usage", create: () => new FableWeeklyUsageWidget },
     { type: "reset-timer", create: () => new BlockResetTimerWidget },
     { type: "weekly-reset-timer", create: () => new WeeklyResetTimerWidget },
     { type: "context-bar", create: () => new ContextBarWidget },
@@ -79925,6 +80280,7 @@ var StatusJSONSchema = exports_external.looseObject({
 init_ansi();
 init_colors();
 init_compaction();
+init_git_review_cache();
 await init_config();
 
 // src/utils/hook-handler.ts
@@ -80020,28 +80376,28 @@ await init_renderer2();
 init_terminal();
 
 // src/utils/usage-prefetch.ts
+init_usage_types();
 await init_usage();
-var USAGE_WIDGET_TYPES = new Set([
+var BASE_USAGE_WIDGET_TYPES = [
   "session-usage",
   "weekly-usage",
-  "weekly-sonnet-usage",
-  "weekly-opus-usage",
   "block-timer",
   "reset-timer",
   "weekly-reset-timer",
   "extra-usage-utilization",
   "extra-usage-remaining",
   "extra-usage-used"
+];
+var USAGE_WIDGET_TYPES = new Set([
+  ...BASE_USAGE_WIDGET_TYPES,
+  ...WEEKLY_MODEL_USAGE_BUCKETS.map((bucket) => bucket.widgetType)
 ]);
 var USAGE_DATA_FIELDS = [
   "sessionUsage",
   "sessionResetAt",
   "weeklyUsage",
   "weeklyResetAt",
-  "weeklySonnetUsage",
-  "weeklySonnetResetAt",
-  "weeklyOpusUsage",
-  "weeklyOpusResetAt",
+  ...WEEKLY_MODEL_USAGE_BUCKETS.flatMap((bucket) => [bucket.usageField, bucket.resetField]),
   "extraUsageEnabled",
   "extraUsageLimit",
   "extraUsageUsed",
@@ -80052,8 +80408,7 @@ var EMPTY_USAGE_REQUIREMENTS = [];
 var USAGE_WIDGET_REQUIREMENTS = {
   "session-usage": [{ field: "sessionUsage" }],
   "weekly-usage": [{ field: "weeklyUsage" }],
-  "weekly-sonnet-usage": [{ field: "weeklySonnetUsage" }],
-  "weekly-opus-usage": [{ field: "weeklyOpusUsage" }],
+  ...Object.fromEntries(WEEKLY_MODEL_USAGE_BUCKETS.map((bucket) => [bucket.widgetType, [{ field: bucket.usageField }]])),
   "block-timer": [{ field: "sessionResetAt", suppressFetchError: true }],
   "reset-timer": [{ field: "sessionResetAt", suppressFetchError: true }],
   "weekly-reset-timer": [{ field: "weeklyResetAt", suppressFetchError: true }],
@@ -80074,8 +80429,7 @@ var USAGE_WIDGET_REQUIREMENTS = {
 var USAGE_CURSOR_REQUIREMENTS = {
   "session-usage": { field: "sessionResetAt" },
   "weekly-usage": { field: "weeklyResetAt" },
-  "weekly-sonnet-usage": { field: "weeklySonnetResetAt", alternatives: ["weeklyResetAt"] },
-  "weekly-opus-usage": { field: "weeklyOpusResetAt", alternatives: ["weeklyResetAt"] }
+  ...Object.fromEntries(WEEKLY_MODEL_USAGE_BUCKETS.map((bucket) => [bucket.widgetType, { field: bucket.resetField, alternatives: ["weeklyResetAt"] }]))
 };
 function hasUsageDependentWidgets(lines) {
   return lines.some((line) => line.some((item) => USAGE_WIDGET_TYPES.has(item.type)));
@@ -80125,21 +80479,14 @@ function hasAnyUsageDataField(data) {
   return USAGE_DATA_FIELDS.some((field) => data?.[field] !== undefined);
 }
 function pickDefinedUsageFields(data) {
-  return {
-    ...data?.sessionUsage !== undefined ? { sessionUsage: data.sessionUsage } : {},
-    ...data?.sessionResetAt !== undefined ? { sessionResetAt: data.sessionResetAt } : {},
-    ...data?.weeklyUsage !== undefined ? { weeklyUsage: data.weeklyUsage } : {},
-    ...data?.weeklyResetAt !== undefined ? { weeklyResetAt: data.weeklyResetAt } : {},
-    ...data?.weeklySonnetUsage !== undefined ? { weeklySonnetUsage: data.weeklySonnetUsage } : {},
-    ...data?.weeklySonnetResetAt !== undefined ? { weeklySonnetResetAt: data.weeklySonnetResetAt } : {},
-    ...data?.weeklyOpusUsage !== undefined ? { weeklyOpusUsage: data.weeklyOpusUsage } : {},
-    ...data?.weeklyOpusResetAt !== undefined ? { weeklyOpusResetAt: data.weeklyOpusResetAt } : {},
-    ...data?.extraUsageEnabled !== undefined ? { extraUsageEnabled: data.extraUsageEnabled } : {},
-    ...data?.extraUsageLimit !== undefined ? { extraUsageLimit: data.extraUsageLimit } : {},
-    ...data?.extraUsageUsed !== undefined ? { extraUsageUsed: data.extraUsageUsed } : {},
-    ...data?.extraUsageUtilization !== undefined ? { extraUsageUtilization: data.extraUsageUtilization } : {},
-    ...data?.extraUsageCurrency !== undefined ? { extraUsageCurrency: data.extraUsageCurrency } : {}
-  };
+  const picked = {};
+  for (const field of USAGE_DATA_FIELDS) {
+    const value = data?.[field];
+    if (value !== undefined) {
+      setUsageField(picked, field, value);
+    }
+  }
+  return picked;
 }
 function mergeUsageData(rateLimitsData, apiData) {
   return {
@@ -80154,28 +80501,28 @@ function epochSecondsToIsoString(epochSeconds) {
   }
   return new Date(epochSeconds * 1000).toISOString();
 }
+function getRateLimitBucketUsage(bucket) {
+  return bucket?.used_percentage ?? undefined;
+}
 function extractUsageDataFromRateLimits(rateLimits) {
   if (!rateLimits) {
     return null;
   }
-  const sessionUsage = rateLimits.five_hour?.used_percentage ?? undefined;
-  const sessionResetAt = epochSecondsToIsoString(rateLimits.five_hour?.resets_at);
-  const weeklyUsage = rateLimits.seven_day?.used_percentage ?? undefined;
-  const weeklyResetAt = epochSecondsToIsoString(rateLimits.seven_day?.resets_at);
-  const weeklySonnetUsage = rateLimits.seven_day_sonnet === null ? 0 : rateLimits.seven_day_sonnet?.used_percentage ?? undefined;
-  const weeklySonnetResetAt = epochSecondsToIsoString(rateLimits.seven_day_sonnet?.resets_at);
-  const weeklyOpusUsage = rateLimits.seven_day_opus === null ? 0 : rateLimits.seven_day_opus?.used_percentage ?? undefined;
-  const weeklyOpusResetAt = epochSecondsToIsoString(rateLimits.seven_day_opus?.resets_at);
+  const rateLimitBuckets = rateLimits;
   const usageData = {
-    sessionUsage,
-    sessionResetAt,
-    weeklyUsage,
-    weeklyResetAt,
-    weeklySonnetUsage,
-    weeklySonnetResetAt,
-    weeklyOpusUsage,
-    weeklyOpusResetAt
+    sessionUsage: rateLimits.five_hour?.used_percentage ?? undefined,
+    sessionResetAt: epochSecondsToIsoString(rateLimits.five_hour?.resets_at),
+    weeklyUsage: rateLimits.seven_day?.used_percentage ?? undefined,
+    weeklyResetAt: epochSecondsToIsoString(rateLimits.seven_day?.resets_at)
   };
+  for (const bucket of WEEKLY_MODEL_USAGE_BUCKETS) {
+    if (!bucket.apiBucketKey) {
+      continue;
+    }
+    const rateLimitBucket = rateLimitBuckets[bucket.apiBucketKey];
+    setUsageField(usageData, bucket.usageField, getRateLimitBucketUsage(rateLimitBucket));
+    setUsageField(usageData, bucket.resetField, epochSecondsToIsoString(rateLimitBucket?.resets_at));
+  }
   return hasAnyUsageDataField(usageData) ? usageData : null;
 }
 async function prefetchUsageDataIfNeeded(lines, data) {
@@ -80286,7 +80633,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);
@@ -80361,7 +80709,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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccstatusline",
-  "version": "2.2.24",
+  "version": "2.2.26",
   "bugs": {
     "url": "https://github.com/sirmalloc/ccstatusline/issues"
   },