copilot-statusline 0.1.13 → 0.1.15

package/README.md

@@ -265,6 +265,7 @@ Copilot CLI spawns your status line command on every state change, passing sessi
 | Tokens Input | `tokens-input` | Total input tokens |
 | Tokens Output | `tokens-output` | Total output tokens |
 | Tokens Cached | `tokens-cached` | Total cached tokens (read + write) |
+| Tokens Reasoning | `tokens-reasoning` | Total reasoning (thinking) tokens consumed |
 | Tokens Total | `tokens-total` | Total tokens |
 | Last Call Input | `last-call-input` | Input tokens from most recent API call |
 | Last Call Output | `last-call-output` | Output tokens from most recent API call |
@@ -274,11 +275,11 @@ Copilot CLI spawns your status line command on every state change, passing sessi
 ### Context
 | Widget | Type | Description |
 |--------|------|-------------|
-| Context Length | `context-length` | Context window size |
-| Context % | `context-percentage` | Percentage of context window used or remaining |
-| Context % (Usable) | `context-percentage-usable` | Percentage of usable context (80% of max) |
-| Context Bar | `context-bar` | Visual progress bar for context usage |
-| Remaining Tokens | `remaining-tokens` | Absolute remaining context tokens |
+| Context Length | `context-length` | Current context length in tokens (live, from `current_context_tokens`) |
+| Context Window | `context-window` | Model's context window size (max tokens, from `displayed_context_limit ?? context_window_size`) |
+| Context % | `context-percentage` | Live context % from Copilot (`current_context_used_percentage`) |
+| Context Bar | `context-bar` | Visual progress bar for live context usage |
+| Remaining Tokens | `remaining-tokens` | Live remaining tokens (`displayed_context_limit − current_context_tokens`) |
 
 ### Git
 | Widget | Type | Description |
@@ -289,8 +290,12 @@ Copilot CLI spawns your status line command on every state change, passing sessi
 | Git Deletions | `git-deletions` | Uncommitted deletions only |
 | Git Status | `git-status` | Staged/unstaged/untracked/conflicts indicators |
 | Git Staged | `git-staged` | Staged changes indicator |
+| Git Staged Files | `git-staged-files` | Count of staged files (`S:3`, raw: `3`) |
 | Git Unstaged | `git-unstaged` | Unstaged changes indicator |
+| Git Unstaged Files | `git-unstaged-files` | Count of unstaged tracked files (`M:2`, raw: `2`) |
 | Git Untracked | `git-untracked` | Untracked files indicator |
+| Git Untracked Files | `git-untracked-files` | Count of untracked files (`?:1`, raw: `1`) |
+| Git Clean Status | `git-clean-status` | Working tree clean/dirty status (`✓`/`✗`, raw: `clean`/`dirty`) |
 | Git Conflicts | `git-conflicts` | Merge conflict count |
 | Git Ahead/Behind | `git-ahead-behind` | Commits ahead/behind upstream |
 | Git SHA | `git-sha` | Short commit hash |
@@ -303,6 +308,8 @@ Copilot CLI spawns your status line command on every state change, passing sessi
 | Git Upstream Repo | `git-upstream-repo` | Upstream remote repo name |
 | Git Upstream Owner/Repo | `git-upstream-owner-repo` | Upstream `owner/repo` |
 | Git Is Fork | `git-is-fork` | Fork detection indicator |
+| Git Worktree | `git-worktree` | Current git worktree name (probes `git rev-parse --git-dir`) |
+| Git Worktree Mode | `git-worktree-mode` | `⎇` indicator when current dir is a linked worktree |
 
 ### System
 | Widget | Type | Description |
@@ -339,7 +346,8 @@ These widgets are exclusive to copilot-statusline and not available in ccstatusl
 | Premium Rate | `premium-rate` | Burn rate in requests/minute |
 | Last Call Input | `last-call-input` | Input tokens from the most recent API call |
 | Last Call Output | `last-call-output` | Output tokens from the most recent API call |
-| Remaining Tokens | `remaining-tokens` | Absolute remaining context window tokens |
+| Remaining Tokens | `remaining-tokens` | Live remaining tokens (`displayed_context_limit − current_context_tokens`) |
+| Tokens Reasoning | `tokens-reasoning` | Total reasoning (thinking) tokens consumed |
 | Cache Read Tokens | `cache-read-tokens` | Total cache read tokens |
 | Cache Write Tokens | `cache-write-tokens` | Total cache write tokens |
 
@@ -368,7 +376,8 @@ Widget-specific shortcuts:
 | Git widgets | `h` | Toggle hide `no git` output |
 | Git Branch | `l` | Toggle GitHub link |
 | Context % widgets | `u` | Toggle used/remaining display |
-| Context Bar | `p` | Cycle bar style (short/full) |
+| Context % widgets | `p` | Cycle numeric/short bar display |
+| Context Bar | `p` | Cycle bar style (medium/full/short/short-only) |
 | Current Working Dir | `h` | Toggle `~` home abbreviation |
 | Current Working Dir | `s` | Edit segment limit |
 | Current Working Dir | `f` | Toggle fish-style path |
@@ -620,4 +629,4 @@ This project includes substantial portions of code from [ccstatusline](https://g
 [![npm downloads](https://img.shields.io/npm/dm/copilot-statusline.svg)](https://www.npmjs.com/package/copilot-statusline)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 
-</div>
+</div>

package/dist/copilot-statusline.js

@@ -52913,7 +52913,7 @@ import { execSync as execSync3 } from "child_process";
 import * as fs5 from "fs";
 import * as path4 from "path";
 var __dirname = "/Users/ts/workspace/active/statusline/copilot_statusline/src/utils";
-var PACKAGE_VERSION = "0.1.13";
+var PACKAGE_VERSION = "0.1.15";
 function getPackageVersion() {
   if (/^\d+\.\d+\.\d+/.test(PACKAGE_VERSION)) {
     return PACKAGE_VERSION;
@@ -54075,18 +54075,13 @@ function getContextWindowMetrics(data) {
   const empty = {
     windowSize: null,
     displayedContextLimit: null,
-    usedTokens: null,
-    contextLengthTokens: null,
     currentContextTokens: null,
     currentContextUsedPercentage: null,
-    usedPercentage: null,
-    remainingPercentage: null,
     totalInputTokens: null,
     totalOutputTokens: null,
     cachedTokens: null,
     totalTokens: null,
     reasoningTokens: null,
-    remainingTokens: null,
     lastCallInputTokens: null,
     lastCallOutputTokens: null,
     cacheReadTokens: null,
@@ -54107,45 +54102,20 @@ function getContextWindowMetrics(data) {
   const totalOutputTokens = toFiniteNonNegativeNumber(contextWindow.total_output_tokens);
   const cacheReadTokens = toFiniteNonNegativeNumber(contextWindow.total_cache_read_tokens);
   const cacheWriteTokens = toFiniteNonNegativeNumber(contextWindow.total_cache_write_tokens);
-  const remainingTokens = toFiniteNonNegativeNumber(contextWindow.remaining_tokens);
   const lastCallInputTokens = toFiniteNonNegativeNumber(contextWindow.last_call_input_tokens);
   const lastCallOutputTokens = toFiniteNonNegativeNumber(contextWindow.last_call_output_tokens);
   const cachedTokens = cacheReadTokens !== null || cacheWriteTokens !== null ? (cacheReadTokens ?? 0) + (cacheWriteTokens ?? 0) : null;
-  let currentUsageTotalTokens = null;
-  let contextLengthTokens = null;
-  if (contextWindow.current_usage && typeof contextWindow.current_usage === "object") {
-    const usage = contextWindow.current_usage;
-    const inputTokens = toFiniteNonNegativeNumber(usage.input_tokens) ?? 0;
-    const outputTokens = toFiniteNonNegativeNumber(usage.output_tokens) ?? 0;
-    const cacheCreationTokens = toFiniteNonNegativeNumber(usage.cache_creation_input_tokens) ?? 0;
-    const cacheReadInputTokens = toFiniteNonNegativeNumber(usage.cache_read_input_tokens) ?? 0;
-    currentUsageTotalTokens = inputTokens + outputTokens + cacheCreationTokens + cacheReadInputTokens;
-    contextLengthTokens = inputTokens + cacheCreationTokens + cacheReadInputTokens;
-  }
-  const rawUsedPercentage = toFiniteNonNegativeNumber(contextWindow.used_percentage);
-  const rawRemainingPercentage = toFiniteNonNegativeNumber(contextWindow.remaining_percentage);
-  const usedTokensFromRemaining = windowSize !== null && remainingTokens !== null ? windowSize - remainingTokens : null;
-  const usedTokensFromPercentage = rawUsedPercentage !== null && windowSize !== null ? rawUsedPercentage / 100 * windowSize : null;
-  const usedTokens = usedTokensFromRemaining ?? usedTokensFromPercentage ?? currentUsageTotalTokens;
-  const usedPercentage = rawUsedPercentage !== null ? clampPercentage(rawUsedPercentage) : usedTokens !== null && windowSize !== null && windowSize > 0 ? clampPercentage(usedTokens / windowSize * 100) : null;
-  const remainingPercentage = rawRemainingPercentage !== null ? clampPercentage(rawRemainingPercentage) : usedPercentage !== null ? 100 - usedPercentage : null;
-  const totalTokens = currentUsageTotalTokens ?? toFiniteNonNegativeNumber(contextWindow.total_tokens) ?? (totalInputTokens !== null && totalOutputTokens !== null ? totalInputTokens + totalOutputTokens : null);
-  const contextLengthFromAuthoritative = usedTokensFromRemaining ?? usedTokensFromPercentage;
+  const totalTokens = toFiniteNonNegativeNumber(contextWindow.total_tokens) ?? (totalInputTokens !== null && totalOutputTokens !== null ? totalInputTokens + totalOutputTokens : null);
   return {
     windowSize,
     displayedContextLimit,
-    usedTokens,
-    contextLengthTokens: contextLengthFromAuthoritative ?? contextLengthTokens ?? usedTokens,
     currentContextTokens,
     currentContextUsedPercentage,
-    usedPercentage,
-    remainingPercentage,
     totalInputTokens,
     totalOutputTokens,
     cachedTokens,
     totalTokens,
     reasoningTokens,
-    remainingTokens,
     lastCallInputTokens,
     lastCallOutputTokens,
     cacheReadTokens,
@@ -54441,95 +54411,117 @@ function handleContextInverseAction(action, item) {
   return toggleMetadataFlag(item, INVERSE_KEY);
 }
 
-// src/widgets/ContextPercentage.ts
-class ContextPercentageWidget {
-  getDefaultColor() {
-    return "blue";
-  }
-  getDescription() {
-    return "Shows percentage of context window used or remaining";
-  }
-  getDisplayName() {
-    return "Context %";
-  }
-  getCategory() {
-    return "Context";
+// src/widgets/shared/context-slider.ts
+var SLIDER_WIDTH = 10;
+var SLIDER_TOGGLE_KEYBIND = { key: "p", label: "(p)rogress toggle", action: "toggle-slider" };
+function makeSliderBar(percent, width = SLIDER_WIDTH) {
+  const clamped = Math.max(0, Math.min(100, percent));
+  const filled = Math.round(clamped / 100 * width);
+  return "▓".repeat(filled) + "░".repeat(width - filled);
+}
+function getContextSliderMode(item) {
+  const mode = item.metadata?.display;
+  if (mode === "slider" || mode === "slider-only") {
+    return mode;
   }
-  getEditorDisplay(item) {
+  return "none";
+}
+function cycleContextSliderMode(item) {
+  const currentMode = getContextSliderMode(item);
+  const nextMode = currentMode === "none" ? "slider" : currentMode === "slider" ? "slider-only" : "none";
+  if (nextMode === "none") {
+    const nextMetadata = { ...item.metadata ?? {} };
+    delete nextMetadata.display;
     return {
-      displayText: this.getDisplayName(),
-      modifierText: getContextInverseModifierText(item)
+      ...item,
+      metadata: Object.keys(nextMetadata).length > 0 ? nextMetadata : undefined
     };
   }
-  handleEditorAction(action, item) {
-    return handleContextInverseAction(action, item);
-  }
-  render(item, context, settings) {
-    const isInverse = isContextInverse(item);
-    if (context.isPreview) {
-      const previewValue = isInverse ? "90.7%" : "9.3%";
-      return formatRawOrLabeledValue(item, "Ctx: ", previewValue);
-    }
-    const metrics = getContextWindowMetrics(context.data);
-    if (metrics.currentContextUsedPercentage !== null) {
-      const pct = metrics.currentContextUsedPercentage;
-      const displayPercentage = isInverse ? 100 - pct : pct;
-      return formatRawOrLabeledValue(item, "Ctx: ", `${displayPercentage.toFixed(1)}%`);
+  return {
+    ...item,
+    metadata: {
+      ...item.metadata ?? {},
+      display: nextMode
     }
+  };
+}
+function renderContextSlider(mode, percent) {
+  if (mode === "none") {
     return null;
   }
-  getCustomKeybinds() {
-    return [
-      { key: "u", label: "(u)sed/remaining", action: "toggle-inverse" }
-    ];
+  const slider = makeSliderBar(percent);
+  if (mode === "slider") {
+    return `${slider} ${percent.toFixed(1)}%`;
   }
-  supportsRawValue() {
-    return true;
+  return slider;
+}
+function getContextSliderModifierText(item) {
+  const mode = getContextSliderMode(item);
+  if (mode === "slider") {
+    return "(short bar)";
   }
-  supportsColors(item) {
-    return true;
+  if (mode === "slider-only") {
+    return "(short bar only)";
   }
+  return;
 }
-// src/widgets/ContextPercentageUsable.ts
-class ContextPercentageUsableWidget {
+function getContextSliderKeybinds() {
+  return [SLIDER_TOGGLE_KEYBIND];
+}
+
+// src/widgets/ContextPercentage.ts
+class ContextPercentageWidget {
   getDefaultColor() {
     return "blue";
   }
   getDescription() {
-    return "Shows percentage of usable context (current_context_tokens / displayed_context_limit)";
+    return "Shows percentage of context window used or remaining";
   }
   getDisplayName() {
-    return "Context % (Usable)";
+    return "Context %";
   }
   getCategory() {
     return "Context";
   }
   getEditorDisplay(item) {
+    const modifiers = [
+      getContextInverseModifierText(item),
+      getContextSliderModifierText(item)
+    ].filter((modifier) => modifier !== undefined);
     return {
       displayText: this.getDisplayName(),
-      modifierText: getContextInverseModifierText(item)
+      modifierText: modifiers.length > 0 ? `(${modifiers.map((modifier) => modifier.replace(/^\(|\)$/g, "")).join(", ")})` : undefined
     };
   }
   handleEditorAction(action, item) {
+    if (action === "toggle-slider") {
+      return cycleContextSliderMode(item);
+    }
     return handleContextInverseAction(action, item);
   }
   render(item, context, settings) {
     const isInverse = isContextInverse(item);
+    const label = isInverse ? "Ctx Left: " : "Ctx Used: ";
+    const sliderMode = getContextSliderMode(item);
+    const formatPercentage = (displayPercentage) => {
+      const sliderDisplay = renderContextSlider(sliderMode, displayPercentage);
+      return formatRawOrLabeledValue(item, label, sliderDisplay ?? `${displayPercentage.toFixed(1)}%`);
+    };
     if (context.isPreview) {
-      const previewValue = isInverse ? "88.4%" : "11.6%";
-      return formatRawOrLabeledValue(item, "Usable: ", previewValue);
+      return formatPercentage(isInverse ? 90.7 : 9.3);
     }
     const metrics = getContextWindowMetrics(context.data);
-    if (metrics.currentContextTokens !== null && metrics.displayedContextLimit !== null && metrics.displayedContextLimit > 0) {
-      const usablePercent = Math.min(100, metrics.currentContextTokens / metrics.displayedContextLimit * 100);
-      const displayPercentage = isInverse ? 100 - usablePercent : usablePercent;
-      return formatRawOrLabeledValue(item, "Usable: ", `${displayPercentage.toFixed(1)}%`);
+    if (metrics.currentContextUsedPercentage !== null) {
+      const pct = metrics.currentContextUsedPercentage;
+      const displayPercentage = isInverse ? 100 - pct : pct;
+      return formatPercentage(displayPercentage);
     }
     return null;
   }
   getCustomKeybinds() {
     return [
-      { key: "u", label: "(u)sed/remaining", action: "toggle-inverse" }
+      { key: "u", label: "(u)sed/remaining", action: "toggle-inverse" },
+      ...getContextSliderKeybinds()
     ];
   }
   supportsRawValue() {
@@ -54554,7 +54546,14 @@ function makeUsageProgressBar(percent, width = 15, powerlineMode = false) {
 
 // src/widgets/ContextBar.ts
 function getDisplayMode(item) {
-  return item.metadata?.display === "progress" ? "progress" : "progress-short";
+  const mode = item.metadata?.display;
+  if (mode === "progress" || mode === "slider" || mode === "slider-only") {
+    return mode;
+  }
+  return "progress-short";
+}
+function isSliderMode(mode) {
+  return mode === "slider" || mode === "slider-only";
 }
 
 class ContextBarWidget {
@@ -54574,7 +54573,11 @@ class ContextBarWidget {
     const mode = getDisplayMode(item);
     const modifiers = [];
     if (mode === "progress-short") {
+      modifiers.push("medium bar");
+    } else if (mode === "slider") {
       modifiers.push("short bar");
+    } else if (mode === "slider-only") {
+      modifiers.push("short bar only");
     }
     return {
       displayText: this.getDisplayName(),
@@ -54586,7 +54589,7 @@ class ContextBarWidget {
       return null;
     }
     const currentMode = getDisplayMode(item);
-    const nextMode = currentMode === "progress-short" ? "progress" : "progress-short";
+    const nextMode = currentMode === "progress-short" ? "progress" : currentMode === "progress" ? "slider" : currentMode === "slider" ? "slider-only" : "progress-short";
     return {
       ...item,
       metadata: {
@@ -54600,19 +54603,29 @@ class ContextBarWidget {
     const barWidth = displayMode === "progress" ? 32 : 16;
     const powerlineMode = settings.powerline.enabled;
     if (context.isPreview) {
+      if (isSliderMode(displayMode)) {
+        const slider = renderContextSlider("slider-only", 25);
+        const sliderDisplay = displayMode === "slider" ? `${slider} 50k/200k (25%)` : slider;
+        return item.rawValue ? sliderDisplay : `Context: ${sliderDisplay}`;
+      }
       const previewDisplay = `${makeUsageProgressBar(25, barWidth, powerlineMode)} 50k/200k (25%)`;
       return item.rawValue ? previewDisplay : `Context: ${previewDisplay}`;
     }
     const contextWindowMetrics = getContextWindowMetrics(context.data);
     const total = contextWindowMetrics.displayedContextLimit ?? contextWindowMetrics.windowSize;
     const used = contextWindowMetrics.currentContextTokens;
-    if (used === null || total === null || total <= 0) {
+    const upstreamPct = contextWindowMetrics.currentContextUsedPercentage;
+    if (used === null || total === null || total <= 0 || upstreamPct === null) {
       return null;
     }
-    const percent = used / total * 100;
-    const clampedPercent = Math.max(0, Math.min(100, percent));
+    const clampedPercent = Math.max(0, Math.min(100, upstreamPct));
     const usedK = Math.round(used / 1000);
     const totalK = Math.round(total / 1000);
+    if (isSliderMode(displayMode)) {
+      const slider = renderContextSlider("slider-only", clampedPercent);
+      const sliderDisplay = displayMode === "slider" ? `${slider} ${usedK}k/${totalK}k (${Math.round(clampedPercent)}%)` : slider;
+      return item.rawValue ? sliderDisplay : `Context: ${sliderDisplay}`;
+    }
     const display = `${makeUsageProgressBar(clampedPercent, barWidth, powerlineMode)} ${usedK}k/${totalK}k (${Math.round(clampedPercent)}%)`;
     return item.rawValue ? display : `Context: ${display}`;
   }
@@ -55024,6 +55037,9 @@ function getGitChangeCounts(context) {
     deletions: unstagedCounts.deletions + stagedCounts.deletions
   };
 }
+function hasRenameOrCopyStatus(line) {
+  return line.startsWith("R") || line.startsWith("C") || line[1] === "R" || line[1] === "C";
+}
 function getGitStatus(context) {
   const output = runGit("--no-optional-locks status --porcelain -z", context);
   if (!output) {
@@ -55048,13 +55064,39 @@ function getGitStatus(context) {
       untracked = true;
     if (staged && unstaged && untracked && conflicts)
       break;
-    const indexStatus = line[0];
-    if (indexStatus === "R" || indexStatus === "C") {
+    if (hasRenameOrCopyStatus(line)) {
       index += 1;
     }
   }
   return { staged, unstaged, untracked, conflicts };
 }
+function getGitFileStatusCounts(context) {
+  const output = runGit("--no-optional-locks status --porcelain -z", context);
+  if (!output) {
+    return { staged: 0, unstaged: 0, untracked: 0 };
+  }
+  let staged = 0;
+  let unstaged = 0;
+  let untracked = 0;
+  const entries = output.split("\x00");
+  for (let index = 0;index < entries.length; index += 1) {
+    const line = entries[index];
+    if (typeof line !== "string" || line.length < 2)
+      continue;
+    if (line.startsWith("??")) {
+      untracked += 1;
+    } else {
+      if (/^[MADRCTU]/.test(line))
+        staged += 1;
+      if (/^.[MADRCTU]/.test(line))
+        unstaged += 1;
+    }
+    if (hasRenameOrCopyStatus(line)) {
+      index += 1;
+    }
+  }
+  return { staged, unstaged, untracked };
+}
 function getGitAheadBehind(context) {
   const output = runGit("rev-list --left-right --count HEAD...@{upstream}", context);
   if (!output)
@@ -55973,6 +56015,55 @@ class GitStagedWidget {
     return true;
   }
 }
+// src/widgets/GitStagedFiles.ts
+class GitStagedFilesWidget {
+  getDefaultColor() {
+    return "green";
+  }
+  getDescription() {
+    return "Shows count of staged files";
+  }
+  getDisplayName() {
+    return "Git Staged Files";
+  }
+  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 ? "3" : "S:3";
+    }
+    if (!isInsideGitWorkTree(context)) {
+      return hideNoGit ? null : "(no git)";
+    }
+    const count = getGitFileStatusCounts(context).staged;
+    return item.rawValue ? count.toString() : `S:${count}`;
+  }
+  getCustomKeybinds() {
+    return getHideNoGitKeybinds();
+  }
+  getNumericValue(context, _item) {
+    if (!isInsideGitWorkTree(context))
+      return null;
+    return getGitFileStatusCounts(context).staged;
+  }
+  supportsRawValue() {
+    return true;
+  }
+  supportsColors(_item) {
+    return true;
+  }
+}
 // src/widgets/GitUnstaged.ts
 var DEFAULT_SYMBOL2 = "*";
 
@@ -56032,6 +56123,55 @@ class GitUnstagedWidget {
     return true;
   }
 }
+// src/widgets/GitUnstagedFiles.ts
+class GitUnstagedFilesWidget {
+  getDefaultColor() {
+    return "yellow";
+  }
+  getDescription() {
+    return "Shows count of unstaged tracked files";
+  }
+  getDisplayName() {
+    return "Git Unstaged Files";
+  }
+  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 ? "2" : "M:2";
+    }
+    if (!isInsideGitWorkTree(context)) {
+      return hideNoGit ? null : "(no git)";
+    }
+    const count = getGitFileStatusCounts(context).unstaged;
+    return item.rawValue ? count.toString() : `M:${count}`;
+  }
+  getCustomKeybinds() {
+    return getHideNoGitKeybinds();
+  }
+  getNumericValue(context, _item) {
+    if (!isInsideGitWorkTree(context))
+      return null;
+    return getGitFileStatusCounts(context).unstaged;
+  }
+  supportsRawValue() {
+    return true;
+  }
+  supportsColors(_item) {
+    return true;
+  }
+}
 // src/widgets/GitUntracked.ts
 var DEFAULT_SYMBOL3 = "?";
 
@@ -56091,6 +56231,103 @@ class GitUntrackedWidget {
     return true;
   }
 }
+// src/widgets/GitUntrackedFiles.ts
+class GitUntrackedFilesWidget {
+  getDefaultColor() {
+    return "red";
+  }
+  getDescription() {
+    return "Shows count of untracked files";
+  }
+  getDisplayName() {
+    return "Git Untracked Files";
+  }
+  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 ? "1" : "?:1";
+    }
+    if (!isInsideGitWorkTree(context)) {
+      return hideNoGit ? null : "(no git)";
+    }
+    const count = getGitFileStatusCounts(context).untracked;
+    return item.rawValue ? count.toString() : `?:${count}`;
+  }
+  getCustomKeybinds() {
+    return getHideNoGitKeybinds();
+  }
+  getNumericValue(context, _item) {
+    if (!isInsideGitWorkTree(context))
+      return null;
+    return getGitFileStatusCounts(context).untracked;
+  }
+  supportsRawValue() {
+    return true;
+  }
+  supportsColors(_item) {
+    return true;
+  }
+}
+// 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 status = getGitStatus(context);
+    const clean = !status.staged && !status.unstaged && !status.untracked && !status.conflicts;
+    if (item.rawValue) {
+      return clean ? "clean" : "dirty";
+    }
+    return clean ? "✓" : "✗";
+  }
+  getCustomKeybinds() {
+    return getHideNoGitKeybinds();
+  }
+  supportsRawValue() {
+    return true;
+  }
+  supportsColors(_item) {
+    return true;
+  }
+}
 // src/widgets/GitAheadBehind.ts
 class GitAheadBehindWidget {
   getDefaultColor() {
@@ -58218,7 +58455,6 @@ var WIDGET_MANIFEST = [
   { type: "context-length", create: () => new ContextLengthWidget },
   { type: "context-window", create: () => new ContextWindowWidget },
   { type: "context-percentage", create: () => new ContextPercentageWidget },
-  { type: "context-percentage-usable", create: () => new ContextPercentageUsableWidget },
   { type: "context-bar", create: () => new ContextBarWidget },
   { type: "session-clock", create: () => new SessionClockWidget },
   { type: "premium-requests", create: () => new PremiumRequestsWidget },
@@ -58237,8 +58473,12 @@ var WIDGET_MANIFEST = [
   { type: "git-pr", create: () => new GitPrWidget },
   { type: "git-status", create: () => new GitStatusWidget },
   { type: "git-staged", create: () => new GitStagedWidget },
+  { type: "git-staged-files", create: () => new GitStagedFilesWidget },
   { type: "git-unstaged", create: () => new GitUnstagedWidget },
+  { type: "git-unstaged-files", create: () => new GitUnstagedFilesWidget },
   { type: "git-untracked", create: () => new GitUntrackedWidget },
+  { type: "git-untracked-files", create: () => new GitUntrackedFilesWidget },
+  { type: "git-clean-status", create: () => new GitCleanStatusWidget },
   { type: "git-ahead-behind", create: () => new GitAheadBehindWidget },
   { type: "git-conflicts", create: () => new GitConflictsWidget },
   { type: "git-sha", create: () => new GitShaWidget },
@@ -62107,8 +62347,8 @@ function advanceGlobalPowerlineThemeIndex(currentIndex, entries) {
 // src/utils/context-percentage.ts
 function calculateContextPercentage(context) {
   const contextWindowMetrics = getContextWindowMetrics(context.data);
-  if (contextWindowMetrics.usedPercentage !== null) {
-    return contextWindowMetrics.usedPercentage;
+  if (contextWindowMetrics.currentContextUsedPercentage !== null) {
+    return contextWindowMetrics.currentContextUsedPercentage;
   }
   return 0;
 }
@@ -62509,17 +62749,18 @@ function renderStatusLine(widgets, settings, context, preRenderedWidgets, preCal
     if (!widget)
       continue;
     if (widget.type === "separator") {
-      let hasContentBefore = false;
+      let previousWidgetRenderedContent = false;
       for (let j = i - 1;j >= 0; j--) {
         const prevWidget = widgets[j];
-        if (prevWidget && prevWidget.type !== "separator" && prevWidget.type !== "flex-separator") {
-          if (preRenderedWidgets[j]?.content) {
-            hasContentBefore = true;
-            break;
-          }
+        if (prevWidget?.type === "separator" || prevWidget?.type === "flex-separator") {
+          continue;
+        }
+        if (prevWidget) {
+          previousWidgetRenderedContent = Boolean(preRenderedWidgets[j]?.content);
+          break;
         }
       }
-      if (!hasContentBefore)
+      if (!previousWidgetRenderedContent)
         continue;
       const sepChar = widget.character ?? (settings.defaultSeparator ?? "|");
       const formattedSep = formatSeparator(sepChar);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "copilot-statusline",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "A customizable status line formatter for GitHub Copilot CLI — based on ccstatusline",
   "module": "src/copilot-statusline.ts",
   "type": "module",