ccstatusline 2.2.10 → 2.2.11

package/README.md

@@ -47,7 +47,7 @@
 
 ## 🆕 Recent Updates
 
-### v2.2.9 - v2.2.10 - GitLab support, reset timers, context, and git widgets
+### v2.2.9 - v2.2.11 - GitLab support, reset timers, context, compaction, and git widgets
 
 - **🦊 GitLab PR/MR support** - `Git Branch` and `Git PR/MR` now support GitHub, GitLab, and compatible self-hosted remotes, using `gh` or `glab` as appropriate.
 - **🔄 Status line refresh interval** - Installed configs can set Claude Code's `statusLine.refreshInterval` from the TUI when Claude Code >=2.1.97 supports it.
@@ -56,10 +56,12 @@
 - **📊 Short bar display modes** - Context percentage, Context Bar, Session Usage, Weekly Usage, Block Timer, and reset timer widgets can use compact bar variants.
 - **🕒 Reset timer timestamps** - Block and Weekly Reset Timer widgets can show exact reset timestamps with compact formatting, 12/24-hour display, IANA time zones, and locale selection.
 - **🪟 Context Window widget** - Added a `Context Window` widget for total model window size, keeping `Context Length` focused on current context usage.
+- **🔁 Compaction Counter widget** - Added a `Compaction Counter` widget that tracks session context compactions, with icon/text/number formats, optional Nerd Font icon, and hide-when-zero behavior.
 - **🧮 Git file status widgets** - Added `Git Staged Files`, `Git Unstaged Files`, `Git Untracked Files`, and `Git Clean Status` for file counts and clean/dirty state.
-- **🧠 Thinking Effort updates** - Added `xhigh`, show `default` when no effort is set, and mark unknown future effort levels with `?`.
+- **🧠 Thinking Effort updates** - Added `xhigh`, show `default` when no effort is set, mark unknown future effort levels with `?`, and track live status JSON plus `/effort` command changes.
 - **🧮 More accurate token counts** - Streaming duplicate JSONL entries are deduped so token widgets do not overcount live Claude Code output.
 - **🏷️ Cleaner model display** - The Model widget strips trailing context suffixes like `(1M context)`; use `Context Window` when you want the total window size shown.
+- **🧹 Cleaner empty-widget separators** - Manual separators now collapse around widgets that render empty, avoiding dangling separators when hide-when-empty widgets disappear.
 - **🧱 More resilient Git helpers** - Git widgets handle missing or unusual git command output more defensively.
 
 ### v2.2.8 - Git widgets, smarter picker search, and minimalist mode
@@ -192,7 +194,7 @@
 
 ## ✨ Features
 
-- **📊 Real-time Metrics** - Display model name, git branch, token usage, session duration, block timer, and more
+- **📊 Real-time Metrics** - Display model name, git branch, token usage, 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

@@ -56010,17 +56010,26 @@ function getContextConfig(modelIdentifier, contextWindowSize) {
 var DEFAULT_CONTEXT_WINDOW_SIZE = 200000, USABLE_CONTEXT_RATIO = 0.8;
 
 // src/utils/context-percentage.ts
-function calculateContextPercentage(context) {
+function calculateContextPercentageMetrics(context) {
   const contextWindowMetrics = getContextWindowMetrics(context.data);
+  const modelIdentifier = getModelContextIdentifier(context.data?.model);
+  const contextConfig = getContextConfig(modelIdentifier, contextWindowMetrics.windowSize);
   if (contextWindowMetrics.usedPercentage !== null) {
-    return contextWindowMetrics.usedPercentage;
+    return {
+      usedPercentage: contextWindowMetrics.usedPercentage,
+      windowSize: contextConfig.maxTokens
+    };
   }
   if (!context.tokenMetrics) {
-    return 0;
+    return null;
   }
-  const modelIdentifier = getModelContextIdentifier(context.data?.model);
-  const contextConfig = getContextConfig(modelIdentifier, contextWindowMetrics.windowSize);
-  return Math.min(100, context.tokenMetrics.contextLength / contextConfig.maxTokens * 100);
+  return {
+    usedPercentage: Math.min(100, context.tokenMetrics.contextLength / contextConfig.maxTokens * 100),
+    windowSize: contextConfig.maxTokens
+  };
+}
+function calculateContextPercentage(context) {
+  return calculateContextPercentageMetrics(context)?.usedPercentage ?? 0;
 }
 var init_context_percentage = () => {};
 
@@ -56127,7 +56136,7 @@ function getTerminalWidth() {
 function canDetectTerminalWidth() {
   return probeTerminalWidth() !== null;
 }
-var __dirname = "/Users/sirmalloc/Projects/Personal/ccstatusline/src/utils", PACKAGE_VERSION = "2.2.10";
+var __dirname = "/Users/sirmalloc/Projects/Personal/ccstatusline/src/utils", PACKAGE_VERSION = "2.2.11";
 var init_terminal = () => {};
 
 // src/utils/renderer.ts
@@ -56532,12 +56541,12 @@ function renderStatusLine(widgets, settings, context, preRenderedWidgets, preCal
       let hasContentBefore = 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)
+          continue;
+        if (prevWidget.type === "separator" || prevWidget.type === "flex-separator")
+          continue;
+        hasContentBefore = Boolean(preRenderedWidgets[j]?.content);
+        break;
       }
       if (!hasContentBefore)
         continue;
@@ -57378,7 +57387,7 @@ class ContextPercentageWidget {
   render(item, context, settings) {
     const isInverse = isContextInverse(item);
     const sliderMode = getContextSliderMode(item);
-    const contextWindowMetrics = getContextWindowMetrics(context.data);
+    const contextPercentageMetrics = calculateContextPercentageMetrics(context);
     if (context.isPreview) {
       const previewPercent = isInverse ? 90.7 : 9.3;
       const sliderResult = renderContextSlider(sliderMode, previewPercent);
@@ -57387,19 +57396,8 @@ class ContextPercentageWidget {
       }
       return formatRawOrLabeledValue(item, "Ctx: ", `${previewPercent.toFixed(1)}%`);
     }
-    if (contextWindowMetrics.usedPercentage !== null) {
-      const displayPercentage = isInverse ? 100 - contextWindowMetrics.usedPercentage : contextWindowMetrics.usedPercentage;
-      const sliderResult = renderContextSlider(sliderMode, displayPercentage);
-      if (sliderResult !== null) {
-        return formatRawOrLabeledValue(item, "Ctx: ", sliderResult);
-      }
-      return formatRawOrLabeledValue(item, "Ctx: ", `${displayPercentage.toFixed(1)}%`);
-    }
-    if (context.tokenMetrics) {
-      const modelIdentifier = getModelContextIdentifier(context.data?.model);
-      const contextConfig = getContextConfig(modelIdentifier, contextWindowMetrics.windowSize);
-      const usedPercentage = Math.min(100, context.tokenMetrics.contextLength / contextConfig.maxTokens * 100);
-      const displayPercentage = isInverse ? 100 - usedPercentage : usedPercentage;
+    if (contextPercentageMetrics !== null) {
+      const displayPercentage = isInverse ? 100 - contextPercentageMetrics.usedPercentage : contextPercentageMetrics.usedPercentage;
       const sliderResult = renderContextSlider(sliderMode, displayPercentage);
       if (sliderResult !== null) {
         return formatRawOrLabeledValue(item, "Ctx: ", sliderResult);
@@ -57422,6 +57420,7 @@ class ContextPercentageWidget {
   }
 }
 var init_ContextPercentage = __esm(() => {
+  init_context_percentage();
   init_context_inverse();
   init_context_slider();
 });
@@ -63063,6 +63062,12 @@ function getTranscriptThinkingEffort(transcriptPath) {
         continue;
       }
       const visibleContent = getVisibleText(entry.message.content).trim();
+      if (visibleContent.startsWith(EFFORT_STDOUT_PREFIX)) {
+        const effortMatch = EFFORT_STDOUT_REGEX.exec(visibleContent);
+        if (effortMatch) {
+          return normalizeThinkingEffort(effortMatch[1]);
+        }
+      }
       if (!visibleContent.startsWith(MODEL_STDOUT_PREFIX)) {
         continue;
       }
@@ -63074,13 +63079,14 @@ function getTranscriptThinkingEffort(transcriptPath) {
   }
   return;
 }
-var KNOWN_THINKING_EFFORTS, KNOWN_THINKING_EFFORTS_SET, MODEL_STDOUT_PREFIX = "<local-command-stdout>Set model to ", MODEL_STDOUT_EFFORT_REGEX, UNKNOWN_EFFORT_PATTERN;
+var KNOWN_THINKING_EFFORTS, KNOWN_THINKING_EFFORTS_SET, MODEL_STDOUT_PREFIX = "<local-command-stdout>Set model to ", MODEL_STDOUT_EFFORT_REGEX, EFFORT_STDOUT_PREFIX = "<local-command-stdout>Set effort level to ", EFFORT_STDOUT_REGEX, UNKNOWN_EFFORT_PATTERN;
 var init_jsonl_metadata = __esm(() => {
   init_ansi();
   init_jsonl_lines();
   KNOWN_THINKING_EFFORTS = ["low", "medium", "high", "xhigh", "max"];
   KNOWN_THINKING_EFFORTS_SET = new Set(KNOWN_THINKING_EFFORTS);
   MODEL_STDOUT_EFFORT_REGEX = /^<local-command-stdout>Set model to[\s\S]*? with ([a-zA-Z0-9-]+) effort<\/local-command-stdout>$/i;
+  EFFORT_STDOUT_REGEX = /^<local-command-stdout>Set effort level to ([a-zA-Z0-9-]+)\b/i;
   UNKNOWN_EFFORT_PATTERN = /^(?=.*[a-z0-9])[a-z0-9-]{2,20}$/;
 });
 
@@ -65587,6 +65593,13 @@ var init_Skills = __esm(async () => {
 });
 
 // src/widgets/ThinkingEffort.ts
+function resolveThinkingEffortFromStatusJson(context) {
+  const effort = context.data?.effort;
+  if (!effort || !("level" in effort)) {
+    return;
+  }
+  return typeof effort.level === "string" ? normalizeThinkingEffort(effort.level) : null;
+}
 function resolveThinkingEffortFromSettings() {
   try {
     const settings = loadClaudeSettingsSync({ logErrors: false });
@@ -65595,6 +65608,10 @@ function resolveThinkingEffortFromSettings() {
   return;
 }
 function resolveThinkingEffort(context) {
+  const statusEffort = resolveThinkingEffortFromStatusJson(context);
+  if (statusEffort !== undefined) {
+    return statusEffort;
+  }
   return getTranscriptThinkingEffort(context.data?.transcript_path) ?? resolveThinkingEffortFromSettings() ?? null;
 }
 function formatEffort(resolved) {
@@ -65893,6 +65910,149 @@ class GitWorktreeOriginalBranchWidget {
   }
 }
 
+// src/widgets/CompactionCounter.ts
+function getFormat2(item) {
+  const format = item.metadata?.format;
+  return FORMATS2.includes(format ?? "") ? format : DEFAULT_FORMAT2;
+}
+function removeNerdFont(item) {
+  const { [NERD_FONT_METADATA_KEY2]: removedNerdFont, ...restMetadata } = item.metadata ?? {};
+  return {
+    ...item,
+    metadata: Object.keys(restMetadata).length > 0 ? restMetadata : undefined
+  };
+}
+function setFormat2(item, format) {
+  if (format === DEFAULT_FORMAT2) {
+    const { format: removedFormat, ...restMetadata2 } = item.metadata ?? {};
+    return {
+      ...item,
+      metadata: Object.keys(restMetadata2).length > 0 ? restMetadata2 : undefined
+    };
+  }
+  const { [NERD_FONT_METADATA_KEY2]: removedNerdFont, ...restMetadata } = item.metadata ?? {};
+  return {
+    ...item,
+    metadata: {
+      ...restMetadata,
+      format
+    }
+  };
+}
+function isNerdFontEnabled2(item) {
+  return item.metadata?.[NERD_FONT_METADATA_KEY2] === "true" && getFormat2(item) === DEFAULT_FORMAT2;
+}
+function isHideZeroEnabled(item) {
+  return item.metadata?.[HIDE_ZERO_METADATA_KEY] === "true";
+}
+function toggleHideZero(item) {
+  return {
+    ...item,
+    metadata: {
+      ...item.metadata ?? {},
+      [HIDE_ZERO_METADATA_KEY]: (!isHideZeroEnabled(item)).toString()
+    }
+  };
+}
+function toggleNerdFont2(item) {
+  if (getFormat2(item) !== DEFAULT_FORMAT2) {
+    return removeNerdFont(item);
+  }
+  if (!isNerdFontEnabled2(item)) {
+    return {
+      ...item,
+      metadata: {
+        ...item.metadata ?? {},
+        [NERD_FONT_METADATA_KEY2]: "true"
+      }
+    };
+  }
+  return removeNerdFont(item);
+}
+function formatCount(count, format, icon) {
+  switch (format) {
+    case "icon-space-number":
+      return `${icon} ${count}`;
+    case "text-and-number":
+      return `Compactions: ${count}`;
+    case "number":
+      return String(count);
+  }
+}
+
+class CompactionCounterWidget {
+  getDefaultColor() {
+    return "yellow";
+  }
+  getDescription() {
+    return "Count of context compaction events in the current session.";
+  }
+  getDisplayName() {
+    return "Compaction Counter";
+  }
+  getCategory() {
+    return "Context";
+  }
+  getEditorDisplay(item) {
+    const modifiers = [getFormat2(item)];
+    if (isNerdFontEnabled2(item)) {
+      modifiers.push("nerd font");
+    }
+    if (isHideZeroEnabled(item)) {
+      modifiers.push("hide zero");
+    }
+    return {
+      displayText: "Compaction Counter",
+      modifierText: `(${modifiers.join(", ")})`
+    };
+  }
+  handleEditorAction(action, item) {
+    if (action === CYCLE_FORMAT_ACTION2) {
+      const currentFormat = getFormat2(item);
+      const nextFormat = FORMATS2[(FORMATS2.indexOf(currentFormat) + 1) % FORMATS2.length] ?? DEFAULT_FORMAT2;
+      return setFormat2(item, nextFormat);
+    }
+    if (action === TOGGLE_HIDE_ZERO_ACTION) {
+      return toggleHideZero(item);
+    }
+    if (action === TOGGLE_NERD_FONT_ACTION2) {
+      return toggleNerdFont2(item);
+    }
+    return null;
+  }
+  render(item, context, settings) {
+    const format = getFormat2(item);
+    const icon = isNerdFontEnabled2(item) ? COMPACTION_NERD_FONT_ICON : COMPACTION_ICON;
+    if (context.isPreview) {
+      return formatCount(2, format, icon);
+    }
+    const count = context.compactionData?.count ?? 0;
+    if (count === 0 && isHideZeroEnabled(item))
+      return null;
+    return formatCount(count, format, icon);
+  }
+  getCustomKeybinds(item) {
+    const keybinds = [
+      { key: "f", label: "(f)ormat", action: CYCLE_FORMAT_ACTION2 }
+    ];
+    if (item === undefined || getFormat2(item) === DEFAULT_FORMAT2) {
+      keybinds.push({ key: "n", label: "(n)erd font", action: TOGGLE_NERD_FONT_ACTION2 });
+    }
+    keybinds.push({ key: "h", label: "(h)ide when zero", action: TOGGLE_HIDE_ZERO_ACTION });
+    return keybinds;
+  }
+  supportsRawValue() {
+    return false;
+  }
+  supportsColors(item) {
+    return true;
+  }
+}
+var COMPACTION_ICON = "↻", COMPACTION_NERD_FONT_ICON = "", FORMATS2, DEFAULT_FORMAT2 = "icon-space-number", CYCLE_FORMAT_ACTION2 = "cycle-format", TOGGLE_HIDE_ZERO_ACTION = "toggle-hide-zero", TOGGLE_NERD_FONT_ACTION2 = "toggle-nerd-font", HIDE_ZERO_METADATA_KEY = "hideZero", NERD_FONT_METADATA_KEY2 = "nerdFont";
+var init_CompactionCounter = __esm(() => {
+  FORMATS2 = ["icon-space-number", "text-and-number", "number"];
+});
+
 // src/widgets/index.ts
 var init_widgets = __esm(async () => {
   init_GitBranch();
@@ -65926,6 +66086,7 @@ var init_widgets = __esm(async () => {
   init_FreeMemory();
   init_SessionName();
   init_VimMode();
+  init_CompactionCounter();
   await __promiseAll([
     init_TokensInput(),
     init_TokensOutput(),
@@ -66021,7 +66182,8 @@ var init_widget_manifest = __esm(async () => {
     { type: "worktree-mode", create: () => new GitWorktreeModeWidget },
     { type: "worktree-name", create: () => new GitWorktreeNameWidget },
     { type: "worktree-branch", create: () => new GitWorktreeBranchWidget },
-    { type: "worktree-original-branch", create: () => new GitWorktreeOriginalBranchWidget }
+    { type: "worktree-original-branch", create: () => new GitWorktreeOriginalBranchWidget },
+    { type: "compaction-counter", create: () => new CompactionCounterWidget }
   ];
   LAYOUT_WIDGET_MANIFEST = [
     {
@@ -72668,6 +72830,7 @@ var StatusJSONSchema = exports_external.looseObject({
   }).optional(),
   version: exports_external.string().optional(),
   output_style: exports_external.object({ name: exports_external.string().optional() }).optional(),
+  effort: exports_external.object({ level: exports_external.string().nullable().optional() }).nullable().optional(),
   cost: exports_external.object({
     total_cost_usd: CoercedNumberSchema.optional(),
     total_duration_ms: CoercedNumberSchema.optional(),
@@ -72708,6 +72871,115 @@ var StatusJSONSchema = exports_external.looseObject({
 // src/ccstatusline.ts
 init_ansi();
 init_colors();
+
+// src/utils/compaction.ts
+init_zod();
+import * as crypto from "crypto";
+import * as fs13 from "fs";
+import * as os13 from "os";
+import * as path10 from "path";
+var DEFAULT_DROP_THRESHOLD = 2;
+var FRESH_PREV_CTX_PCT = -1;
+var MAX_CACHE_FILE_BYTES = 4096;
+var SESSION_ID_HASH_HEX_LEN = 32;
+var FRESH = { count: 0, prevCtxPct: FRESH_PREV_CTX_PCT };
+var CompactionStateSchema = exports_external.object({
+  count: exports_external.number().int().nonnegative().default(0),
+  prevCtxPct: exports_external.number().default(FRESH_PREV_CTX_PCT),
+  prevWindowSize: exports_external.number().positive().nullable().optional()
+});
+function normalizeWindowSize(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    return null;
+  }
+  return value;
+}
+function normalizeOptions(options) {
+  if (typeof options === "number") {
+    return { dropThreshold: options, windowSize: null };
+  }
+  const dropThreshold = typeof options.dropThreshold === "number" && Number.isFinite(options.dropThreshold) ? options.dropThreshold : DEFAULT_DROP_THRESHOLD;
+  return { dropThreshold, windowSize: options.windowSize ?? null };
+}
+function detectCompaction(currentCtxPct, state, options = DEFAULT_DROP_THRESHOLD) {
+  if (!Number.isFinite(currentCtxPct) || currentCtxPct < 0) {
+    return state;
+  }
+  const { dropThreshold, windowSize } = normalizeOptions(options);
+  const currentWindowSize = normalizeWindowSize(windowSize);
+  const prevWindowSize = normalizeWindowSize(state.prevWindowSize);
+  let { count } = state;
+  const { prevCtxPct } = state;
+  const hasKnownWindowChange = currentWindowSize !== null && prevWindowSize !== null && currentWindowSize !== prevWindowSize;
+  const isLearningWindowSize = currentWindowSize !== null && prevWindowSize === null && prevCtxPct >= 0;
+  if (!hasKnownWindowChange && !isLearningWindowSize && prevCtxPct >= 0 && currentCtxPct < prevCtxPct - dropThreshold) {
+    count += 1;
+  }
+  return {
+    count,
+    prevCtxPct: currentCtxPct,
+    ...currentWindowSize !== null ? { prevWindowSize: currentWindowSize } : {}
+  };
+}
+function getCacheDir2() {
+  return path10.join(os13.homedir(), ".cache", "ccstatusline", "compaction");
+}
+function sanitizeSessionId(sessionId) {
+  const sanitized = sessionId.replace(/[^a-zA-Z0-9_-]/g, "_");
+  if (!sanitized || sanitized !== sessionId) {
+    return crypto.createHash("sha256").update(sessionId).digest("hex").slice(0, SESSION_ID_HASH_HEX_LEN);
+  }
+  return sanitized;
+}
+function getStatePath(sessionId) {
+  return path10.join(getCacheDir2(), `compaction-${sanitizeSessionId(sessionId)}.json`);
+}
+function loadCompactionState(sessionId) {
+  const statePath = getStatePath(sessionId);
+  let fd = null;
+  try {
+    fd = fs13.openSync(statePath, fs13.constants.O_RDONLY | fs13.constants.O_NOFOLLOW);
+    const stats = fs13.fstatSync(fd);
+    if (!stats.isFile() || stats.size > MAX_CACHE_FILE_BYTES) {
+      return FRESH;
+    }
+    const raw = JSON.parse(fs13.readFileSync(fd, "utf-8"));
+    const result2 = CompactionStateSchema.safeParse(raw);
+    return result2.success ? result2.data : FRESH;
+  } catch {
+    return FRESH;
+  } finally {
+    if (fd !== null) {
+      try {
+        fs13.closeSync(fd);
+      } catch {}
+    }
+  }
+}
+function saveCompactionState(sessionId, state) {
+  let tmpPath = null;
+  try {
+    const dir = getCacheDir2();
+    if (!fs13.existsSync(dir)) {
+      fs13.mkdirSync(dir, { recursive: true });
+    }
+    const targetPath = getStatePath(sessionId);
+    tmpPath = `${targetPath}.tmp.${process.pid}.${crypto.randomBytes(4).toString("hex")}`;
+    fs13.writeFileSync(tmpPath, JSON.stringify(state) + `
+`);
+    fs13.renameSync(tmpPath, targetPath);
+    tmpPath = null;
+  } catch {
+    if (tmpPath !== null) {
+      try {
+        fs13.unlinkSync(tmpPath);
+      } catch {}
+    }
+  }
+}
+
+// src/ccstatusline.ts
+init_context_percentage();
 await __promiseAll([
   init_config(),
   init_jsonl()
@@ -72715,23 +72987,23 @@ await __promiseAll([
 await init_renderer2();
 
 // src/utils/skills.ts
-import * as fs13 from "fs";
-import * as os13 from "os";
-import * as path10 from "path";
+import * as fs14 from "fs";
+import * as os14 from "os";
+import * as path11 from "path";
 var EMPTY = { totalInvocations: 0, uniqueSkills: [], lastSkill: null };
 function getSkillsDir() {
-  return path10.join(os13.homedir(), ".cache", "ccstatusline", "skills");
+  return path11.join(os14.homedir(), ".cache", "ccstatusline", "skills");
 }
 function getSkillsFilePath(sessionId) {
-  return path10.join(getSkillsDir(), `skills-${sessionId}.jsonl`);
+  return path11.join(getSkillsDir(), `skills-${sessionId}.jsonl`);
 }
 function getSkillsMetrics(sessionId) {
   const filePath = getSkillsFilePath(sessionId);
-  if (!fs13.existsSync(filePath)) {
+  if (!fs14.existsSync(filePath)) {
     return EMPTY;
   }
   try {
-    const invocations = fs13.readFileSync(filePath, "utf-8").trim().split(`
+    const invocations = fs14.readFileSync(filePath, "utf-8").trim().split(`
 `).filter((line) => line.trim()).map((line) => {
       try {
         return JSON.parse(line);
@@ -72880,6 +73152,20 @@ async function renderMultipleLines(data) {
   if (data.session_id) {
     skillsMetrics = getSkillsMetrics(data.session_id);
   }
+  let compactionCount = 0;
+  const hasCompactionWidget = lines.some((line) => line.some((item) => item.type === "compaction-counter"));
+  if (hasCompactionWidget && data.session_id) {
+    const prevState = loadCompactionState(data.session_id);
+    compactionCount = prevState.count;
+    const contextPercentageMetrics = calculateContextPercentageMetrics({ data, tokenMetrics });
+    if (contextPercentageMetrics !== null) {
+      const newState = detectCompaction(contextPercentageMetrics.usedPercentage, prevState, { windowSize: contextPercentageMetrics.windowSize });
+      if (newState.count !== prevState.count || newState.prevCtxPct !== prevState.prevCtxPct || newState.prevWindowSize !== prevState.prevWindowSize) {
+        saveCompactionState(data.session_id, newState);
+      }
+      compactionCount = newState.count;
+    }
+  }
   const context = {
     data,
     tokenMetrics,
@@ -72888,6 +73174,7 @@ async function renderMultipleLines(data) {
     usageData,
     sessionDuration,
     skillsMetrics,
+    compactionData: hasCompactionWidget ? { count: compactionCount } : null,
     isPreview: false,
     minimalist: settings.minimalistMode
   };
@@ -72974,16 +73261,16 @@ async function handleHook() {
       return;
     }
     const filePath = getSkillsFilePath(sessionId);
-    const fs14 = await import("fs");
-    const path11 = await import("path");
-    fs14.mkdirSync(path11.dirname(filePath), { recursive: true });
+    const fs15 = await import("fs");
+    const path12 = await import("path");
+    fs15.mkdirSync(path12.dirname(filePath), { recursive: true });
     const entry = JSON.stringify({
       timestamp: new Date().toISOString(),
       session_id: sessionId,
       skill: skillName,
       source: data.hook_event_name
     });
-    fs14.appendFileSync(filePath, entry + `
+    fs15.appendFileSync(filePath, entry + `
 `);
   } catch {}
   console.log("{}");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccstatusline",
-  "version": "2.2.10",
+  "version": "2.2.11",
   "description": "A customizable status line formatter for Claude Code CLI",
   "module": "src/ccstatusline.ts",
   "type": "module",
@@ -45,7 +45,7 @@
     "strip-ansi": "^7.1.0",
     "tinyglobby": "^0.2.14",
     "typedoc": "^0.28.12",
-    "typescript": "^5.9.2",
+    "typescript": "^6.0.2",
     "typescript-eslint": "^8.39.1",
     "vitest": "^4.0.18",
     "zod": "^4.0.17"