ccstatusline 2.2.21 → 2.2.22

package/README.md

@@ -47,6 +47,14 @@
 
 ## 🆕 Recent Updates
 
+### v2.2.22 - Powerline flex mode, dim styling, safer config, and polish
+
+![Powerline Flex Mode](https://raw.githubusercontent.com/sirmalloc/ccstatusline/main/screenshots/powerline-flex.png)
+
+- **⚡ Powerline flex mode** - Flex separators now work in Powerline mode, letting Powerline status lines right-align content or absorb available width.
+- **🌗 Per-widget dim styling** - The color editor can dim an entire widget or only parenthesized text, with reset and clear-all actions covering dim state.
+- **🧯 Safer settings recovery** - Invalid `settings.json` files are left untouched, defaults render in memory, and the status line shows an invalid-config warning.
+
 ### v2.2.21 - Cache widgets, compaction details, extra usage currency, and package fixes
 
 - **🔣 Custom widget glyphs** - Git and JJ symbol widgets can override or suppress their built-in glyphs from the TUI.
@@ -100,7 +108,7 @@
 - **🧮 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.
 - **🏷️ Clear context percentage labels** - `Context %` and `Context % (usable)` now label rendered values as used or left when toggling used/remaining mode.
 - **⚡ More Powerline caps** - The Powerline separator editor now supports more than three start/end caps.
-- **🧠 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.
+- **🧠 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. Claude Code reports Ultracode as `xhigh` in status line data.
 - **🧮 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.

package/dist/ccstatusline.js

@@ -52986,6 +52986,7 @@ var init_Widget = __esm(() => {
     color: exports_external.string().optional(),
     backgroundColor: exports_external.string().optional(),
     bold: exports_external.boolean().optional(),
+    dim: exports_external.union([exports_external.boolean(), exports_external.literal("parens")]).optional(),
     character: exports_external.string().optional(),
     rawValue: exports_external.boolean().optional(),
     customText: exports_external.string().optional(),
@@ -57351,14 +57352,24 @@ function getChalkColor(colorName, colorLevel = "ansi16", isBackground = false) {
       return colorEntry.ansi16;
   }
 }
-function applyColors(text, foregroundColor, backgroundColor, bold, colorLevel = "ansi16") {
-  if (!foregroundColor && !backgroundColor && !bold) {
-    return text;
+function applyParensDim(text, bold) {
+  const intensityReset = bold ? "\x1B[22;1m" : "\x1B[22m";
+  return text.replace(/\([^()]*\)/g, (span) => `\x1B[2m${span}${intensityReset}`);
+}
+function applyColors(text, foregroundColor, backgroundColor, bold, colorLevel = "ansi16", dim) {
+  const styledText = dim === "parens" ? applyParensDim(text, bold) : text;
+  if (!foregroundColor && !backgroundColor && !bold && dim !== true) {
+    return styledText;
   }
   let prefix = "";
   let suffix = "";
   if (bold) {
     prefix += "\x1B[1m";
+  }
+  if (dim === true) {
+    prefix += "\x1B[2m";
+  }
+  if (bold || dim === true) {
     suffix = "\x1B[22m" + suffix;
   }
   if (backgroundColor) {
@@ -57371,7 +57382,7 @@ function applyColors(text, foregroundColor, backgroundColor, bold, colorLevel =
   if (foregroundColor) {
     const gradientStops = parseGradientSpec(foregroundColor);
     if (gradientStops && colorLevel !== "ansi16") {
-      return prefix + applyGradientToText(text, gradientStops, colorLevel) + "\x1B[39m" + suffix;
+      return prefix + applyGradientToText(styledText, gradientStops, colorLevel) + "\x1B[39m" + suffix;
     }
     const fgCode = getColorAnsiCode(foregroundColor, colorLevel, false);
     if (fgCode) {
@@ -57379,7 +57390,7 @@ function applyColors(text, foregroundColor, backgroundColor, bold, colorLevel =
       suffix = "\x1B[39m" + suffix;
     }
   }
-  return prefix + text + suffix;
+  return prefix + styledText + suffix;
 }
 function getColorAnsiCode(colorName, colorLevel = "ansi16", isBackground = false) {
   if (!colorName)
@@ -57861,19 +57872,22 @@ function getTerminalWidth() {
 function canDetectTerminalWidth() {
   return probeTerminalWidth() !== null;
 }
-var __dirname = "/home/runner/work/ccstatusline/ccstatusline/src/utils", PACKAGE_VERSION = "2.2.21";
+var __dirname = "/home/runner/work/ccstatusline/ccstatusline/src/utils", PACKAGE_VERSION = "2.2.22";
 var init_terminal = () => {};
 
 // src/utils/format-tokens.ts
-function formatTokens(count) {
-  if (count >= 999950)
+function formatTokens(count, decimals = 1) {
+  if (count >= 1e6 - 500 / 10 ** decimals)
     return `${(count / 1e6).toFixed(1)}M`;
   if (count >= 1000)
-    return `${(count / 1000).toFixed(1)}k`;
+    return `${(count / 1000).toFixed(decimals)}k`;
   return count.toString();
 }
 
 // src/utils/renderer.ts
+function buildConfigWarningBadge(colorLevel) {
+  return applyColors("⚠ invalid config", "red", undefined, false, getColorLevelString(colorLevel));
+}
 function maybeApplyForegroundGradient(line, settings, colorLevel) {
   const stops = parseGradientSpec(settings.overrideForegroundColor);
   return stops ? applyLineGradient(line, stops, colorLevel) : line;
@@ -57917,8 +57931,9 @@ function renderPowerlineStatusLine(widgets, settings, context, lineIndex = 0, gl
   const startCaps = config2.startCaps ?? [];
   const endCaps = config2.endCaps ?? [];
   const capLineIndex = context.lineIndex ?? lineIndex;
-  const startCap = startCaps.length > 0 ? startCaps[capLineIndex % startCaps.length] : "";
-  const endCap = endCaps.length > 0 ? endCaps[capLineIndex % endCaps.length] : "";
+  const startCapIndex = context.globalPowerlineStartCapIndex ?? capLineIndex;
+  const getStartCap = (segmentOffset2) => startCaps.length > 0 ? startCaps[(startCapIndex + segmentOffset2) % startCaps.length] ?? "" : "";
+  const getEndCap = (segmentOffset2) => endCaps.length > 0 ? endCaps[(startCapIndex + segmentOffset2) % endCaps.length] ?? "" : "";
   const themeName = config2.theme;
   let themeColors;
   if (themeName && themeName !== "custom") {
@@ -57931,13 +57946,45 @@ function renderPowerlineStatusLine(widgets, settings, context, lineIndex = 0, gl
   }
   const colorLevel = getColorLevelString(settings.colorLevel);
   const overrideForegroundGradientStops = parseGradientSpec(settings.overrideForegroundColor);
+  const isSeparatorBoundary = (widget) => widget?.type === "separator" || widget?.type === "flex-separator";
   const filteredWidgets = widgets.filter((widget) => widget.type !== "separator" && widget.type !== "flex-separator");
+  const FLEX_SENTINEL = "\x01FLEX_SEP\x01";
   if (filteredWidgets.length === 0)
     return "";
   const detectedWidth = context.terminalWidth ?? getTerminalWidth();
   const terminalWidth = resolveEffectiveTerminalWidth(detectedWidth, settings, context);
   const widgetElements = [];
   let widgetColorIndex = continueThemeAcrossLines ? globalThemeColorOffset : 0;
+  const hasNextRenderedWidgetBeforeSeparator = (originalIndex) => {
+    for (let j = originalIndex + 1;j < widgets.length; j++) {
+      const nextWidget = widgets[j];
+      if (!nextWidget)
+        continue;
+      if (isSeparatorBoundary(nextWidget))
+        return false;
+      if (preRenderedWidgets[j]?.content)
+        return true;
+    }
+    return false;
+  };
+  const canMergeWithNextRenderedWidget = (originalIndex) => {
+    if (originalIndex === undefined)
+      return false;
+    const widget = widgets[originalIndex];
+    return Boolean(widget?.merge && hasNextRenderedWidgetBeforeSeparator(originalIndex));
+  };
+  const findPreviousRenderedWidgetIndexBeforeSeparator = (originalIndex) => {
+    for (let j = originalIndex - 1;j >= 0; j--) {
+      const previousWidget = widgets[j];
+      if (!previousWidget)
+        continue;
+      if (isSeparatorBoundary(previousWidget))
+        return null;
+      if (preRenderedWidgets[j]?.content)
+        return j;
+    }
+    return null;
+  };
   const preRenderedIndices = [];
   for (let i = 0;i < widgets.length; i++) {
     const widget = widgets[i];
@@ -57968,10 +58015,11 @@ function renderPowerlineStatusLine(widgets, settings, context, lineIndex = 0, gl
       if (settings.overrideForegroundColor && settings.overrideForegroundColor !== "none" && widget.type === "custom-command" && widget.preserveColors) {
         widgetText = stripSgrCodes(widgetText);
       }
-      const prevItem = i > 0 ? filteredWidgets[i - 1] : null;
-      const nextItem = i < filteredWidgets.length - 1 ? filteredWidgets[i + 1] : null;
-      const omitLeadingPadding = prevItem?.merge === "no-padding";
-      const omitTrailingPadding = widget.merge === "no-padding" && nextItem;
+      const previousRenderedIndex = actualPreRenderedIndex !== undefined ? findPreviousRenderedWidgetIndexBeforeSeparator(actualPreRenderedIndex) : null;
+      const previousRenderedWidget = previousRenderedIndex !== null ? widgets[previousRenderedIndex] : undefined;
+      const mergesWithNext = canMergeWithNextRenderedWidget(actualPreRenderedIndex);
+      const omitLeadingPadding = previousRenderedWidget?.merge === "no-padding" && canMergeWithNextRenderedWidget(previousRenderedIndex ?? undefined);
+      const omitTrailingPadding = widget.merge === "no-padding" && mergesWithNext;
       const leadingPadding = omitLeadingPadding ? "" : padding;
       const trailingPadding = omitTrailingPadding ? "" : padding;
       const paddedText = `${leadingPadding}${widgetText}${trailingPadding}`;
@@ -57983,7 +58031,7 @@ function renderPowerlineStatusLine(widgets, settings, context, lineIndex = 0, gl
           fgColor = themeColors.fg[widgetColorIndex % themeColors.fg.length] ?? fgColor;
         }
         bgColor = themeColors.bg[widgetColorIndex % themeColors.bg.length] ?? bgColor;
-        if (!widget.merge) {
+        if (!mergesWithNext) {
           widgetColorIndex++;
         }
       }
@@ -57994,12 +58042,56 @@ function renderPowerlineStatusLine(widgets, settings, context, lineIndex = 0, gl
         content: paddedText,
         bgColor: bgColor ?? undefined,
         fgColor,
+        mergesWithNext,
+        originalIndex: actualPreRenderedIndex ?? -1,
         widget
       });
     }
   }
   if (widgetElements.length === 0)
     return "";
+  const renderedElementIndexByOriginalIndex = new Map;
+  widgetElements.forEach((element, index) => {
+    renderedElementIndexByOriginalIndex.set(element.originalIndex, index);
+  });
+  const flexAfterIndex = new Map;
+  const startCapBeforeIndex = new Map;
+  const segmentOffsetByRenderedIndex = new Map;
+  let leadingFlexCount = 0;
+  let totalFlexCount = 0;
+  let lastRenderedIndex = null;
+  let pendingFlexCount = 0;
+  let segmentOffset = 0;
+  let hasRenderedSegment = false;
+  for (let i = 0;i < widgets.length; i++) {
+    const widget = widgets[i];
+    if (!widget || widget.type === "separator")
+      continue;
+    if (widget.type === "flex-separator") {
+      totalFlexCount++;
+      if (lastRenderedIndex === null) {
+        leadingFlexCount++;
+      } else {
+        pendingFlexCount++;
+        flexAfterIndex.set(lastRenderedIndex, (flexAfterIndex.get(lastRenderedIndex) ?? 0) + 1);
+      }
+      continue;
+    }
+    const renderedIndex = renderedElementIndexByOriginalIndex.get(i);
+    if (renderedIndex !== undefined) {
+      if (!hasRenderedSegment) {
+        startCapBeforeIndex.set(renderedIndex, segmentOffset);
+        pendingFlexCount = 0;
+        hasRenderedSegment = true;
+      } else if (pendingFlexCount > 0) {
+        segmentOffset++;
+        startCapBeforeIndex.set(renderedIndex, segmentOffset);
+        pendingFlexCount = 0;
+      }
+      segmentOffsetByRenderedIndex.set(renderedIndex, segmentOffset);
+      lastRenderedIndex = renderedIndex;
+    }
+  }
   const autoAlign = config2.autoAlign;
   if (autoAlign) {
     let alignmentPos = 0;
@@ -58008,13 +58100,13 @@ function renderPowerlineStatusLine(widgets, settings, context, lineIndex = 0, gl
       if (!element)
         continue;
       const prevWidget = i > 0 ? widgetElements[i - 1] : null;
-      const isPreviousMerged = prevWidget?.widget.merge;
+      const isPreviousMerged = prevWidget?.mergesWithNext;
       if (!isPreviousMerged) {
         const maxWidth = preCalculatedMaxWidths[alignmentPos];
         if (maxWidth !== undefined) {
           let combinedLength = getVisibleWidth(element.content);
           let j = i;
-          while (j < widgetElements.length - 1 && widgetElements[j]?.widget.merge) {
+          while (j < widgetElements.length - 1 && widgetElements[j]?.mergesWithNext) {
             j++;
             const nextElement = widgetElements[j];
             if (nextElement) {
@@ -58040,29 +58132,45 @@ function renderPowerlineStatusLine(widgets, settings, context, lineIndex = 0, gl
   }, 0) : 0;
   let powerlineGradientColumn = 0;
   let result2 = "";
-  if (startCap && widgetElements.length > 0) {
-    const firstWidget = widgetElements[0];
-    if (firstWidget?.bgColor) {
-      const capFg = bgToFg(firstWidget.bgColor);
-      const fgCode = getColorAnsiCode(capFg, colorLevel, false);
-      result2 += fgCode + startCap + "\x1B[39m";
-    } else {
-      result2 += startCap;
-    }
+  if (leadingFlexCount > 0) {
+    result2 += FLEX_SENTINEL.repeat(leadingFlexCount);
   }
+  let localSeparatorIndex = 0;
   for (let i = 0;i < widgetElements.length; i++) {
     const widget = widgetElements[i];
     const nextWidget = widgetElements[i + 1];
     if (!widget)
       continue;
     const shouldBold = settings.globalBold || widget.widget.bold;
-    const needsSeparator = i < widgetElements.length - 1 && separators.length > 0 && nextWidget && !widget.widget.merge;
+    const shouldDim = widget.widget.dim === true;
+    const needsSeparator = i < widgetElements.length - 1 && separators.length > 0 && nextWidget !== undefined && !widget.mergesWithNext;
+    const flexCountAfter = flexAfterIndex.get(i) ?? 0;
+    const currentSegmentOffset = segmentOffsetByRenderedIndex.get(i) ?? 0;
+    const isLastWidget = i === widgetElements.length - 1;
+    const hasEndCapAfterWidget = Boolean(getEndCap(currentSegmentOffset)) && (flexCountAfter > 0 || isLastWidget);
+    const startCapSegmentOffset = startCapBeforeIndex.get(i);
+    if (startCapSegmentOffset !== undefined) {
+      const segmentStartCap = getStartCap(startCapSegmentOffset);
+      if (segmentStartCap) {
+        if (widget.bgColor) {
+          const capFg = bgToFg(widget.bgColor);
+          const fgCode = getColorAnsiCode(capFg, colorLevel, false);
+          result2 += fgCode + segmentStartCap + "\x1B[39m";
+        } else {
+          result2 += segmentStartCap;
+        }
+      }
+    }
     let widgetContent = "";
     const isPreserveColors = widget.widget.type === "custom-command" && widget.widget.preserveColors;
     if (shouldBold && !isPreserveColors) {
       widgetContent += "\x1B[1m";
     }
+    if (shouldDim && !isPreserveColors) {
+      widgetContent += "\x1B[2m";
+    }
     const textGradientStops = !isPreserveColors && powerlineGradientWidth > 1 ? overrideForegroundGradientStops : null;
+    const styledContent = widget.widget.dim === "parens" && !isPreserveColors ? applyParensDim(widget.content, shouldBold) : widget.content;
     if (widget.fgColor && !isPreserveColors && !textGradientStops) {
       widgetContent += getColorAnsiCode(widget.fgColor, colorLevel, false);
     }
@@ -58070,26 +58178,44 @@ function renderPowerlineStatusLine(widgets, settings, context, lineIndex = 0, gl
       widgetContent += getColorAnsiCode(widget.bgColor, colorLevel, true);
     }
     if (textGradientStops) {
-      const gradientResult = applyLineGradientSegment(widget.content, textGradientStops, colorLevel, powerlineGradientColumn, powerlineGradientWidth);
+      const gradientResult = applyLineGradientSegment(styledContent, textGradientStops, colorLevel, powerlineGradientColumn, powerlineGradientWidth);
       widgetContent += gradientResult.text;
       powerlineGradientColumn = gradientResult.nextColumn;
     } else {
-      widgetContent += widget.content;
+      widgetContent += styledContent;
     }
     if (isPreserveColors) {
       widgetContent += "\x1B[0m";
     } else {
       widgetContent += "\x1B[49m\x1B[39m";
-      const isLastWidget = i === widgetElements.length - 1;
-      const hasEndCap = endCaps.length > 0 && endCaps[capLineIndex % endCaps.length];
-      if (shouldBold && !needsSeparator && !(isLastWidget && hasEndCap)) {
+      const shouldRestoreBoldForBoundary = shouldDim && shouldBold && (needsSeparator || hasEndCapAfterWidget);
+      if (shouldRestoreBoldForBoundary) {
+        widgetContent += "\x1B[22;1m";
+      } else if (shouldDim || shouldBold && !needsSeparator && !hasEndCapAfterWidget) {
         widgetContent += "\x1B[22m";
       }
     }
     result2 += widgetContent;
+    if (flexCountAfter > 0) {
+      const segmentEndCap = getEndCap(currentSegmentOffset);
+      if (segmentEndCap) {
+        if (widget.bgColor) {
+          const capFg = bgToFg(widget.bgColor);
+          const fgCode = getColorAnsiCode(capFg, colorLevel, false);
+          result2 += fgCode + segmentEndCap + "\x1B[39m";
+        } else {
+          result2 += segmentEndCap;
+        }
+      }
+      if (shouldBold) {
+        result2 += "\x1B[22m";
+      }
+      result2 += FLEX_SENTINEL.repeat(flexCountAfter);
+      continue;
+    }
     if (needsSeparator) {
-      const globalIndex = globalSeparatorOffset + i;
-      const separatorIndex = Math.min(globalIndex, separators.length - 1);
+      const globalIndex = globalSeparatorOffset + localSeparatorIndex;
+      const separatorIndex = globalIndex % separators.length;
       const separator = separators[separatorIndex] ?? "";
       const shouldInvert = invertBgs[separatorIndex] ?? false;
       let separatorOutput;
@@ -58144,23 +58270,49 @@ function renderPowerlineStatusLine(widgets, settings, context, lineIndex = 0, gl
         }
       }
       result2 += separatorOutput;
-      if (shouldBold) {
+      if (shouldBold || shouldDim) {
         result2 += "\x1B[22m";
       }
+      localSeparatorIndex++;
     }
   }
-  if (endCap && widgetElements.length > 0) {
-    const lastWidget = widgetElements[widgetElements.length - 1];
-    if (lastWidget?.bgColor) {
-      const capFg = bgToFg(lastWidget.bgColor);
-      const fgCode = getColorAnsiCode(capFg, colorLevel, false);
-      result2 += fgCode + endCap + "\x1B[39m";
-    } else {
-      result2 += endCap;
-    }
+  if (widgetElements.length > 0) {
+    const lastWidgetIndex = widgetElements.length - 1;
+    const lastWidget = widgetElements[lastWidgetIndex];
     const lastWidgetBold = settings.globalBold || lastWidget?.widget.bold;
-    if (lastWidgetBold) {
-      result2 += "\x1B[22m";
+    const lastWidgetDim = lastWidget?.widget.dim === true;
+    const lastSegmentOffset = segmentOffsetByRenderedIndex.get(lastWidgetIndex) ?? 0;
+    const lastWidgetHasFlexAfter = (flexAfterIndex.get(lastWidgetIndex) ?? 0) > 0;
+    const segmentEndCap = getEndCap(lastSegmentOffset);
+    if (segmentEndCap && !lastWidgetHasFlexAfter) {
+      if (lastWidget?.bgColor) {
+        const capFg = bgToFg(lastWidget.bgColor);
+        const fgCode = getColorAnsiCode(capFg, colorLevel, false);
+        result2 += fgCode + segmentEndCap + "\x1B[39m";
+      } else {
+        result2 += segmentEndCap;
+      }
+      if (lastWidgetBold || lastWidgetDim) {
+        result2 += "\x1B[22m";
+      }
+    }
+  }
+  if (totalFlexCount > 0) {
+    if (terminalWidth && terminalWidth > 0) {
+      const parts = result2.split(FLEX_SENTINEL);
+      const totalContentWidth = parts.reduce((sum2, p) => sum2 + getVisibleWidth(p), 0);
+      const flexCount = parts.length - 1;
+      const totalSpace = Math.max(0, terminalWidth - totalContentWidth);
+      const spacePerFlex = flexCount > 0 ? Math.floor(totalSpace / flexCount) : 0;
+      const extraSpace = flexCount > 0 ? totalSpace % flexCount : 0;
+      let newResult = parts[0] ?? "";
+      for (let i = 1;i < parts.length; i++) {
+        const flexSize = spacePerFlex + (i - 1 < extraSpace ? 1 : 0);
+        newResult += " ".repeat(flexSize) + (parts[i] ?? "");
+      }
+      result2 = newResult;
+    } else {
+      result2 = result2.split(FLEX_SENTINEL).join(" ");
     }
   }
   result2 += source_default.reset("");
@@ -58184,6 +58336,32 @@ function formatSeparator(sep) {
   }
   return sep;
 }
+function countPowerlineStartCapSlots(widgets, preRenderedWidgets) {
+  let pendingFlexAfterRenderedSegment = false;
+  let hasRenderedSegment = false;
+  let renderedSegmentCount = 0;
+  for (let i = 0;i < widgets.length; i++) {
+    const widget = widgets[i];
+    if (!widget || widget.type === "separator")
+      continue;
+    if (widget.type === "flex-separator") {
+      if (hasRenderedSegment) {
+        pendingFlexAfterRenderedSegment = true;
+      }
+      continue;
+    }
+    if (!preRenderedWidgets[i]?.content)
+      continue;
+    if (!hasRenderedSegment) {
+      hasRenderedSegment = true;
+      renderedSegmentCount = 1;
+    } else if (pendingFlexAfterRenderedSegment) {
+      renderedSegmentCount++;
+      pendingFlexAfterRenderedSegment = false;
+    }
+  }
+  return renderedSegmentCount;
+}
 function preRenderAllWidgets(allLinesWidgets, settings, context) {
   const preRenderedLines = [];
   for (const lineWidgets of allLinesWidgets) {
@@ -58199,6 +58377,11 @@ function preRenderAllWidgets(allLinesWidgets, settings, context) {
       }
       const widgetImpl = getWidget(widget.type);
       if (!widgetImpl) {
+        preRenderedLine.push({
+          content: "",
+          plainLength: 0,
+          widget
+        });
         continue;
       }
       const effectiveWidget = context.minimalist ? { ...widget, rawValue: true } : widget;
@@ -58219,19 +58402,35 @@ function calculateMaxWidthsFromPreRendered(preRenderedLines, settings) {
   const defaultPadding = settings.defaultPadding ?? "";
   const paddingLength = defaultPadding.length;
   for (const preRenderedLine of preRenderedLines) {
-    const filteredWidgets = preRenderedLine.filter((w) => w.widget.type !== "separator" && w.widget.type !== "flex-separator" && w.content);
+    const isSeparatorBoundary = (entry) => entry?.widget.type === "separator" || entry?.widget.type === "flex-separator";
+    const hasNextRenderedWidgetBeforeSeparator = (originalIndex) => {
+      for (let j = originalIndex + 1;j < preRenderedLine.length; j++) {
+        const nextEntry = preRenderedLine[j];
+        if (!nextEntry)
+          continue;
+        if (isSeparatorBoundary(nextEntry))
+          return false;
+        if (nextEntry.content)
+          return true;
+      }
+      return false;
+    };
+    const renderedWidgets = preRenderedLine.map((entry, originalIndex) => ({
+      ...entry,
+      mergesWithNext: Boolean(entry.widget.merge && hasNextRenderedWidgetBeforeSeparator(originalIndex))
+    })).filter((entry) => !isSeparatorBoundary(entry) && entry.content);
     let alignmentPos = 0;
-    for (let i = 0;i < filteredWidgets.length; i++) {
-      const widget = filteredWidgets[i];
+    for (let i = 0;i < renderedWidgets.length; i++) {
+      const widget = renderedWidgets[i];
       if (!widget)
         continue;
       let totalWidth = widget.plainLength + paddingLength * 2;
       let j = i;
-      while (j < filteredWidgets.length - 1 && filteredWidgets[j]?.widget.merge) {
+      while (j < renderedWidgets.length - 1 && renderedWidgets[j]?.mergesWithNext) {
         j++;
-        const nextWidget = filteredWidgets[j];
+        const nextWidget = renderedWidgets[j];
         if (nextWidget) {
-          if (filteredWidgets[j - 1]?.widget.merge === "no-padding") {
+          if (renderedWidgets[j - 1]?.widget.merge === "no-padding") {
             totalWidth += nextWidget.plainLength;
           } else {
             totalWidth += nextWidget.plainLength + paddingLength * 2;
@@ -58261,7 +58460,7 @@ function renderStatusLine(widgets, settings, context, preRenderedWidgets, preCal
   const isPowerlineMode = Boolean(powerlineSettings?.enabled);
   if (isPowerlineMode)
     return renderPowerlineStatusLine(widgets, settings, context, context.lineIndex ?? 0, context.globalSeparatorIndex ?? 0, context.globalPowerlineThemeIndex ?? 0, preRenderedWidgets, preCalculatedMaxWidths);
-  const applyColorsWithOverride = (text, foregroundColor, backgroundColor, bold) => {
+  const applyColorsWithOverride = (text, foregroundColor, backgroundColor, bold, dim) => {
     let fgColor = foregroundColor;
     const fgOverride = settings.overrideForegroundColor;
     if (fgOverride && fgOverride !== "none") {
@@ -58276,7 +58475,7 @@ function renderStatusLine(widgets, settings, context, preRenderedWidgets, preCal
       bgColor = settings.overrideBackgroundColor;
     }
     const shouldBold = settings.globalBold || bold;
-    return applyColors(text, fgColor, bgColor, shouldBold, colorLevel);
+    return applyColors(text, fgColor, bgColor, shouldBold, colorLevel, dim);
   };
   const detectedWidth = context.terminalWidth ?? getTerminalWidth();
   const terminalWidth = resolveEffectiveTerminalWidth(detectedWidth, settings, context);
@@ -58304,6 +58503,7 @@ function renderStatusLine(widgets, settings, context, preRenderedWidgets, preCal
       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") {
@@ -58315,9 +58515,10 @@ function renderStatusLine(widgets, settings, context, preRenderedWidgets, preCal
           separatorColor = widgetColor;
           separatorBg = prevWidget.backgroundColor;
           separatorBold = prevWidget.bold;
+          separatorDim = prevWidget.dim;
         }
       }
-      elements.push({ content: applyColorsWithOverride(formattedSep, separatorColor, separatorBg, separatorBold), type: "separator", widget });
+      elements.push({ content: applyColorsWithOverride(formattedSep, separatorColor, separatorBg, separatorBold, separatorDim), type: "separator", widget });
       continue;
     }
     if (widget.type === "flex-separator") {
@@ -58348,7 +58549,7 @@ function renderStatusLine(widgets, settings, context, preRenderedWidgets, preCal
           elements.push({ content: finalOutput, type: widget.type, widget });
         } else {
           elements.push({
-            content: applyColorsWithOverride(widgetText, widget.color ?? defaultColor, widget.backgroundColor, widget.bold),
+            content: applyColorsWithOverride(widgetText, widget.color ?? defaultColor, widget.backgroundColor, widget.bold, widget.dim),
             type: widget.type,
             widget
           });
@@ -58378,7 +58579,7 @@ function renderStatusLine(widgets, settings, context, preRenderedWidgets, preCal
             const widgetImpl = getWidget(prevElem2.widget.type);
             widgetColor = widgetImpl ? widgetImpl.getDefaultColor() : "white";
           }
-          const coloredSep = applyColorsWithOverride(defaultSep, widgetColor, prevElem2.widget.backgroundColor, prevElem2.widget.bold);
+          const coloredSep = applyColorsWithOverride(defaultSep, widgetColor, prevElem2.widget.backgroundColor, prevElem2.widget.bold, prevElem2.widget.dim);
           finalElements.push(coloredSep);
         } else {
           finalElements.push(defaultSep);
@@ -58395,7 +58596,7 @@ function renderStatusLine(widgets, settings, context, preRenderedWidgets, preCal
     } else {
       const nextElem = index < elements.length - 1 ? elements[index + 1] : null;
       const omitLeadingPadding = prevElem?.widget?.merge === "no-padding";
-      const omitTrailingPadding = elem.widget?.merge === "no-padding" && nextElem;
+      const omitTrailingPadding = elem.widget?.merge === "no-padding" && nextElem && nextElem.type !== "separator" && nextElem.type !== "flex-separator";
       const hasColorOverride = Boolean(settings.overrideBackgroundColor && settings.overrideBackgroundColor !== "none") || Boolean(settings.overrideForegroundColor && settings.overrideForegroundColor !== "none");
       if (padding && (elem.widget?.backgroundColor || hasColorOverride)) {
         const leadingPadding = omitLeadingPadding ? "" : applyColorsWithOverride(padding, undefined, elem.widget?.backgroundColor);
@@ -68227,15 +68428,15 @@ class ContextBarWidget {
     }
     const percent = used / total * 100;
     const clampedPercent = Math.max(0, Math.min(100, percent));
-    const usedK = Math.round(used / 1000);
-    const totalK = Math.round(total / 1000);
+    const usedDisplay = formatTokens(used, 0);
+    const totalDisplay = formatTokens(total, 0);
     if (isBarSliderMode(displayMode)) {
       const slider = makeSliderBar(clampedPercent);
-      const sliderDisplay = displayMode === "slider" ? `${slider} ${usedK}k/${totalK}k (${Math.round(clampedPercent)}%)` : slider;
+      const sliderDisplay = displayMode === "slider" ? `${slider} ${usedDisplay}/${totalDisplay} (${Math.round(clampedPercent)}%)` : slider;
       return item.rawValue ? sliderDisplay : `Context: ${sliderDisplay}`;
     }
     const barWidth = displayMode === "progress" ? 32 : 16;
-    const display = `${makeUsageProgressBar(clampedPercent, barWidth)} ${usedK}k/${totalK}k (${Math.round(clampedPercent)}%)`;
+    const display = `${makeUsageProgressBar(clampedPercent, barWidth)} ${usedDisplay}/${totalDisplay} (${Math.round(clampedPercent)}%)`;
     return item.rawValue ? display : `Context: ${display}`;
   }
   getCustomKeybinds() {
@@ -68252,7 +68453,10 @@ class ContextBarWidget {
 }
 var init_ContextBar = __esm(async () => {
   init_usage_display();
-  await init_usage();
+  await __promiseAll([
+    init_renderer2(),
+    init_usage()
+  ]);
 });
 
 // src/widgets/Link.tsx
@@ -68683,6 +68887,7 @@ class ThinkingEffortWidget {
   }
   getDescription() {
     return `Displays the current thinking effort level (low, medium, high, xhigh, max).
+Claude Code reports Ultracode as xhigh in status line data; Ultracode is not exposed as a separate effort level.
 Unknown levels are shown with a trailing "?" (e.g. "super-max?").
 May be incorrect when multiple Claude Code sessions are running due to current Claude Code limitations.`;
   }
@@ -69084,8 +69289,12 @@ function toggleHideZero(item) {
     }
   };
 }
-function formatReclaimedSuffix(tokensReclaimed) {
-  return tokensReclaimed > 0 ? ` ↓${formatTokens(tokensReclaimed)}` : "";
+function formatReclaimedSuffix(tokensReclaimed, item) {
+  if (tokensReclaimed <= 0) {
+    return "";
+  }
+  const symbol2 = getSlotSymbol(item, RECLAIMED_SLOT);
+  return symbol2.length > 0 ? ` ${symbol2}${formatTokens(tokensReclaimed)}` : ` ${formatTokens(tokensReclaimed)}`;
 }
 function formatTriggerSuffix(byTrigger) {
   const parts = [];
@@ -69106,7 +69315,7 @@ function formatStats(data, item, icon) {
     out += formatTriggerSuffix(data.byTrigger);
   }
   if (isMetadataFlagEnabled(item, SHOW_RECLAIMED_METADATA_KEY)) {
-    out += formatReclaimedSuffix(data.tokensReclaimed);
+    out += formatReclaimedSuffix(data.tokensReclaimed, item);
   }
   return out;
 }
@@ -69208,8 +69417,12 @@ class CompactionCounterWidget {
     keybinds.push({ key: "s", label: "(s)plit by trigger", action: TOGGLE_TRIGGERS_ACTION });
     keybinds.push({ key: "t", label: "(t)okens reclaimed", action: TOGGLE_RECLAIMED_ACTION });
     keybinds.push({ key: "h", label: "(h)ide when zero", action: TOGGLE_HIDE_ZERO_ACTION });
+    keybinds.push(getSymbolKeybind());
     return keybinds;
   }
+  renderEditor(props) {
+    return renderSymbolSlotsEditor(props, [RECLAIMED_SLOT]);
+  }
   supportsRawValue() {
     return false;
   }
@@ -69217,10 +69430,12 @@ class CompactionCounterWidget {
     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", TOGGLE_TRIGGERS_ACTION = "toggle-triggers", SHOW_TRIGGERS_METADATA_KEY = "showTriggers", TOGGLE_RECLAIMED_ACTION = "toggle-reclaimed", SHOW_RECLAIMED_METADATA_KEY = "showReclaimed", SAMPLE_STATS;
-var init_CompactionCounter = __esm(() => {
+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", TOGGLE_TRIGGERS_ACTION = "toggle-triggers", SHOW_TRIGGERS_METADATA_KEY = "showTriggers", TOGGLE_RECLAIMED_ACTION = "toggle-reclaimed", SHOW_RECLAIMED_METADATA_KEY = "showReclaimed", RECLAIMED_SLOT, SAMPLE_STATS;
+var init_CompactionCounter = __esm(async () => {
   init_compaction();
+  await init_symbol_override();
   FORMATS2 = ["icon-space-number", "text-and-number", "number"];
+  RECLAIMED_SLOT = { id: "symbolReclaimed", label: "Reclaimed", defaultSymbol: "↓" };
   SAMPLE_STATS = Object.freeze({
     count: 2,
     byTrigger: Object.freeze({ auto: 1, manual: 1, unknown: 0 }),
@@ -69525,7 +69740,6 @@ var init_widgets = __esm(async () => {
   init_FreeMemory();
   init_SessionName();
   init_VimMode();
-  init_CompactionCounter();
   await __promiseAll([
     init_GitBranch(),
     init_GitWorktree(),
@@ -69569,6 +69783,7 @@ var init_widgets = __esm(async () => {
     init_Skills(),
     init_ThinkingEffort(),
     init_GitWorktreeMode(),
+    init_CompactionCounter(),
     init_VoiceStatus(),
     init_RemoteControlStatus()
   ]);
@@ -69694,12 +69909,10 @@ function getWidget(type) {
 }
 function getAllWidgetTypes(settings) {
   const allTypes = WIDGET_MANIFEST.map((entry) => entry.type);
-  if (!settings.powerline.enabled) {
-    if (!settings.defaultSeparator) {
-      allTypes.push("separator");
-    }
-    allTypes.push("flex-separator");
+  if (!settings.powerline.enabled && !settings.defaultSeparator) {
+    allTypes.push("separator");
   }
+  allTypes.push("flex-separator");
   return allTypes;
 }
 function getLayoutCatalogEntry(type) {
@@ -69844,6 +70057,9 @@ var init_hooks = __esm(async () => {
 import * as fs12 from "fs";
 import * as os9 from "os";
 import * as path8 from "path";
+function getConfigLoadError() {
+  return lastLoadError;
+}
 function initConfigPath(filePath) {
   settingsPath = filePath ? path8.resolve(filePath) : DEFAULT_SETTINGS_PATH;
 }
@@ -69854,49 +70070,78 @@ function isCustomConfigPath() {
   return settingsPath !== DEFAULT_SETTINGS_PATH;
 }
 function getSettingsPaths() {
-  const configDir = path8.dirname(settingsPath);
-  const parsedPath = path8.parse(settingsPath);
-  const backupBaseName = parsedPath.ext ? `${parsedPath.name}.bak` : `${parsedPath.base}.bak`;
   return {
-    configDir,
-    settingsPath,
-    settingsBackupPath: path8.join(configDir, backupBaseName)
+    configDir: path8.dirname(settingsPath),
+    settingsPath
   };
 }
-async function writeSettingsJson(settings, paths) {
-  await mkdir(paths.configDir, { recursive: true });
-  await writeFile(paths.settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+function getErrorCode(error51) {
+  return typeof error51 === "object" && error51 !== null && "code" in error51 ? String(error51.code) : undefined;
 }
-async function backupBadSettings(paths) {
+async function resolveSymlinkTarget(linkPath) {
   try {
-    if (fs12.existsSync(paths.settingsPath)) {
-      const content = await readFile3(paths.settingsPath, "utf-8");
-      await writeFile(paths.settingsBackupPath, content, "utf-8");
-      console.error(`Bad settings backed up to ${paths.settingsBackupPath}`);
+    return await realpath2(linkPath);
+  } catch (error51) {
+    if (getErrorCode(error51) !== "ENOENT") {
+      throw error51;
     }
+    const linkTarget = await readlink(linkPath);
+    return path8.resolve(path8.dirname(linkPath), linkTarget);
+  }
+}
+async function resolveAtomicWriteTarget(paths) {
+  try {
+    const stats = await lstat(paths.settingsPath);
+    if (!stats.isSymbolicLink()) {
+      return {
+        targetPath: paths.settingsPath,
+        tempDir: paths.configDir
+      };
+    }
+    const targetPath = await resolveSymlinkTarget(paths.settingsPath);
+    return {
+      targetPath,
+      tempDir: path8.dirname(targetPath)
+    };
   } catch (error51) {
-    console.error("Failed to backup bad settings:", error51);
+    if (getErrorCode(error51) === "ENOENT") {
+      return {
+        targetPath: paths.settingsPath,
+        tempDir: paths.configDir
+      };
+    }
+    throw error51;
+  }
+}
+async function writeSettingsJson(settings, paths) {
+  await mkdir(paths.configDir, { recursive: true });
+  const writeTarget = await resolveAtomicWriteTarget(paths);
+  const tempPath = path8.join(writeTarget.tempDir, `${path8.basename(writeTarget.targetPath)}.${process.pid}.${Date.now()}.tmp`);
+  try {
+    await writeFile(tempPath, JSON.stringify(settings, null, 2), "utf-8");
+    await rename(tempPath, writeTarget.targetPath);
+  } catch (error51) {
+    try {
+      await unlink(tempPath);
+    } catch {}
+    throw error51;
   }
 }
+function inMemoryDefaults() {
+  return SettingsSchema.parse({});
+}
 async function writeDefaultSettings(paths) {
-  const defaults2 = SettingsSchema.parse({});
-  const settingsWithVersion = {
-    ...defaults2,
-    version: CURRENT_VERSION
-  };
+  const defaults2 = inMemoryDefaults();
   try {
-    await writeSettingsJson(settingsWithVersion, paths);
+    await writeSettingsJson(defaults2, paths);
     console.error(`Default settings written to ${paths.settingsPath}`);
   } catch (error51) {
     console.error("Failed to write default settings:", error51);
   }
   return defaults2;
 }
-async function recoverWithDefaults(paths) {
-  await backupBadSettings(paths);
-  return await writeDefaultSettings(paths);
-}
 async function loadSettings() {
+  lastLoadError = null;
   const paths = getSettingsPaths();
   try {
     if (!fs12.existsSync(paths.settingsPath))
@@ -69906,34 +70151,42 @@ async function loadSettings() {
     try {
       rawData = JSON.parse(content);
     } catch {
-      console.error("Failed to parse settings.json, backing up and using defaults");
-      return await recoverWithDefaults(paths);
+      console.error("Failed to parse settings.json, using defaults (file left unchanged)");
+      lastLoadError = "settings.json is not valid JSON";
+      return inMemoryDefaults();
     }
     const hasVersion = typeof rawData === "object" && rawData !== null && "version" in rawData;
+    let migrated = false;
     if (!hasVersion) {
       const v1Result = SettingsSchema_v1.safeParse(rawData);
       if (!v1Result.success) {
-        console.error("Invalid v1 settings format:", v1Result.error);
-        return await recoverWithDefaults(paths);
+        console.error("Invalid v1 settings format, using defaults (file left unchanged):", v1Result.error);
+        lastLoadError = "settings.json is not in a valid format";
+        return inMemoryDefaults();
       }
       rawData = migrateConfig(rawData, CURRENT_VERSION);
-      await writeSettingsJson(rawData, paths);
+      migrated = true;
     } else if (needsMigration(rawData, CURRENT_VERSION)) {
       rawData = migrateConfig(rawData, CURRENT_VERSION);
-      await writeSettingsJson(rawData, paths);
+      migrated = true;
     }
     const result2 = SettingsSchema.safeParse(rawData);
     if (!result2.success) {
-      console.error("Failed to parse settings:", result2.error);
-      return await recoverWithDefaults(paths);
+      console.error("Failed to parse settings, using defaults (file left unchanged):", result2.error);
+      lastLoadError = "settings.json is not in a valid format";
+      return inMemoryDefaults();
+    }
+    if (migrated) {
+      await writeSettingsJson(rawData, paths);
     }
     return {
       ...result2.data,
       lines: upgradeLegacyWidgetTypes(result2.data.lines)
     };
   } catch (error51) {
-    console.error("Error loading settings:", error51);
-    return await recoverWithDefaults(paths);
+    console.error("Error loading settings, using defaults:", error51);
+    lastLoadError = "settings.json could not be read";
+    return inMemoryDefaults();
   }
 }
 async function saveSettings(settings) {
@@ -69954,6 +70207,10 @@ async function saveInstallationMetadata(metadata) {
     return;
   }
   const settings = await loadSettings();
+  if (getConfigLoadError() !== null) {
+    console.error("Skipping installation-metadata write: settings.json is unreadable (left unchanged).");
+    return;
+  }
   const settingsWithVersion = {
     ...settings,
     version: CURRENT_VERSION
@@ -69965,7 +70222,7 @@ async function saveInstallationMetadata(metadata) {
   }
   await writeSettingsJson(settingsWithVersion, paths);
 }
-var readFile3, writeFile, mkdir, DEFAULT_SETTINGS_PATH, settingsPath;
+var readFile3, writeFile, mkdir, rename, unlink, lstat, readlink, realpath2, DEFAULT_SETTINGS_PATH, settingsPath, lastLoadError = null;
 var init_config = __esm(async () => {
   init_Settings();
   init_migrations();
@@ -69973,6 +70230,11 @@ var init_config = __esm(async () => {
   readFile3 = fs12.promises.readFile;
   writeFile = fs12.promises.writeFile;
   mkdir = fs12.promises.mkdir;
+  rename = fs12.promises.rename;
+  unlink = fs12.promises.unlink;
+  lstat = fs12.promises.lstat;
+  readlink = fs12.promises.readlink;
+  realpath2 = fs12.promises.realpath;
   DEFAULT_SETTINGS_PATH = path8.join(os9.homedir(), ".config", "ccstatusline", "settings.json");
   settingsPath = DEFAULT_SETTINGS_PATH;
 });
@@ -72558,12 +72820,31 @@ function toggleWidgetBold(widgets, widgetId) {
     bold: !widget.bold
   }));
 }
+function cycleWidgetDim(widgets, widgetId) {
+  return updateWidgetById(widgets, widgetId, (widget) => {
+    if (widget.dim === true) {
+      return {
+        ...widget,
+        dim: "parens"
+      };
+    }
+    if (widget.dim === "parens") {
+      const { dim, ...restWidget } = widget;
+      return restWidget;
+    }
+    return {
+      ...widget,
+      dim: true
+    };
+  });
+}
 function resetWidgetStyling(widgets, widgetId) {
   return updateWidgetById(widgets, widgetId, (widget) => {
     const {
       color,
       backgroundColor,
       bold,
+      dim,
       ...restWidget
     } = widget;
     return restWidget;
@@ -72575,6 +72856,7 @@ function clearAllWidgetStyling(widgets) {
       color,
       backgroundColor,
       bold,
+      dim,
       ...restWidget
     } = widget;
     return restWidget;
@@ -72831,6 +73113,14 @@ var ColorMenu = ({ widgets, lineIndex, settings, onUpdate, onBack }) => {
           onUpdate(newItems);
         }
       }
+    } else if (input === "d" || input === "D") {
+      if (highlightedItemId && highlightedItemId !== "back") {
+        const selectedWidget2 = colorableWidgets.find((widget) => widget.id === highlightedItemId);
+        if (selectedWidget2) {
+          const newItems = cycleWidgetDim(widgets, selectedWidget2.id);
+          onUpdate(newItems);
+        }
+      }
     } else if (input === "r" || input === "R") {
       if (highlightedItemId && highlightedItemId !== "back") {
         const selectedWidget2 = colorableWidgets.find((widget) => widget.id === highlightedItemId);
@@ -72914,7 +73204,7 @@ var ColorMenu = ({ widgets, lineIndex, settings, onUpdate, onBack }) => {
         defaultColor = widgetImpl.getDefaultColor();
       }
     }
-    const styledLabel = applyColors(label, widget.color ?? defaultColor, widget.backgroundColor, widget.bold, level);
+    const styledLabel = applyColors(label, widget.color ?? defaultColor, widget.backgroundColor, widget.bold, level, widget.dim);
     return {
       label: styledLabel,
       value: widget.id
@@ -72981,6 +73271,11 @@ var ColorMenu = ({ widgets, lineIndex, settings, onUpdate, onBack }) => {
       colorDisplay = applyColors(displayName, currentColor, undefined, false, level);
     }
   }
+  const styleIndicators = [
+    selectedWidget?.bold ? "[BOLD]" : null,
+    selectedWidget?.dim === true ? "[DIM]" : null,
+    selectedWidget?.dim === "parens" ? "[DIM ()]" : null
+  ].filter((indicator) => indicator !== null).join(" ");
   if (gradientMode) {
     const level = getColorLevelString(settings.colorLevel);
     const widgetName = selectedWidget ? getItemLabel(selectedWidget) : "";
@@ -73195,7 +73490,7 @@ var ColorMenu = ({ widgets, lineIndex, settings, onUpdate, onBack }) => {
               "↑↓ to select, ←→ to cycle",
               " ",
               editingBackground ? "background" : "foreground",
-              ", (f) to toggle bg/fg, (b)old,",
+              ", (f) to toggle bg/fg, (b)old, (d)im,",
               settings.colorLevel === 3 ? " (h)ex," : settings.colorLevel === 2 ? " (a)nsi256," : "",
               !editingBackground && settings.colorLevel >= 2 ? " (g)radient," : "",
               " ",
@@ -73222,7 +73517,7 @@ var ColorMenu = ({ widgets, lineIndex, settings, onUpdate, onBack }) => {
                 "):",
                 " ",
                 colorDisplay,
-                selectedWidget.bold && source_default.bold(" [BOLD]")
+                styleIndicators && ` ${styleIndicators}`
               ]
             }, undefined, true, undefined, this)
           }, undefined, false, undefined, this) : /* @__PURE__ */ jsx_dev_runtime13.jsxDEV(Box_default, {
@@ -74664,7 +74959,7 @@ var ItemsEditor = ({ widgets, onUpdate, onBack, lineNumber, settings }) => {
               children: [
                 "⚠",
                 " ",
-                settings.powerline.enabled ? "Powerline mode active: separators controlled by powerline settings" : "Default separator active: manual separators disabled"
+                settings.powerline.enabled ? "Powerline mode active: manual separators disabled" : "Default separator active: manual separators disabled"
               ]
             }, undefined, true, undefined, this)
           }, undefined, false, undefined, this)
@@ -75583,7 +75878,7 @@ function resolveEnabledPowerlineTheme(theme) {
 }
 function buildEnabledPowerlineSettings(settings, removeManualSeparators) {
   const powerlineConfig = settings.powerline;
-  const lines = removeManualSeparators ? settings.lines.map((line) => line.filter((item) => item.type !== "separator" && item.type !== "flex-separator")) : settings.lines;
+  const lines = removeManualSeparators ? settings.lines.map((line) => line.filter((item) => item.type !== "separator")) : settings.lines;
   return {
     ...settings,
     powerline: {
@@ -76208,7 +76503,7 @@ var PowerlineSetup = ({
   const [selectedMenuItem, setSelectedMenuItem] = import_react47.useState(0);
   const [confirmingEnable, setConfirmingEnable] = import_react47.useState(false);
   const [confirmingFontInstall, setConfirmingFontInstall] = import_react47.useState(false);
-  const hasSeparatorItems = settings.lines.some((line) => line.some((item) => item.type === "separator" || item.type === "flex-separator"));
+  const hasManualSeparatorItems = settings.lines.some((line) => line.some((item) => item.type === "separator"));
   const hasGlobalFgOverride = Boolean(settings.overrideForegroundColor && settings.overrideForegroundColor !== "none");
   const globalOverrideMessage = hasGlobalFgOverride ? "⚠ Global override for FG active" : null;
   use_input_default((input, key) => {
@@ -76226,7 +76521,7 @@ var PowerlineSetup = ({
         onBack();
       } else if (input === "t" || input === "T") {
         if (!powerlineConfig.enabled) {
-          if (hasSeparatorItems) {
+          if (hasManualSeparatorItems) {
             setConfirmingEnable(true);
           } else {
             onUpdate(buildEnabledPowerlineSettings(settings, false));
@@ -76461,12 +76756,12 @@ var PowerlineSetup = ({
         flexDirection: "column",
         marginTop: 1,
         children: [
-          hasSeparatorItems && /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(jsx_dev_runtime22.Fragment, {
+          hasManualSeparatorItems && /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(jsx_dev_runtime22.Fragment, {
             children: [
               /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Box_default, {
                 children: /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Text, {
                   color: "yellow",
-                  children: "⚠ Warning: Enabling Powerline mode will remove all existing separators and flex-separators from your status lines."
+                  children: "⚠ Warning: Enabling Powerline mode will remove all existing manual separators from your status lines."
                 }, undefined, false, undefined, this)
               }, undefined, false, undefined, this),
               /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Box_default, {
@@ -76479,7 +76774,7 @@ var PowerlineSetup = ({
             ]
           }, undefined, true, undefined, this),
           /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Box_default, {
-            marginTop: hasSeparatorItems ? 1 : 0,
+            marginTop: hasManualSeparatorItems ? 1 : 0,
             children: /* @__PURE__ */ jsx_dev_runtime22.jsxDEV(Text, {
               children: "Do you want to continue? "
             }, undefined, false, undefined, this)
@@ -76882,7 +77177,11 @@ function countPowerlineThemeSlots(entries) {
   let previousVisibleWidget = null;
   let slotCount = 0;
   for (const entry of entries) {
-    if (!entry.content || entry.widget.type === "separator" || entry.widget.type === "flex-separator") {
+    if (entry.widget.type === "separator" || entry.widget.type === "flex-separator") {
+      previousVisibleWidget = null;
+      continue;
+    }
+    if (!entry.content) {
       continue;
     }
     if (!previousVisibleWidget?.merge) {
@@ -76900,17 +77199,47 @@ function advanceGlobalPowerlineThemeIndex(currentIndex, entries) {
 await init_renderer2();
 
 // src/utils/separator-index.ts
-function countSeparatorSlots(widgets) {
-  const nonMergedWidgets = widgets.filter((_, idx) => idx === widgets.length - 1 || !widgets[idx]?.merge);
-  return Math.max(0, nonMergedWidgets.length - 1);
+function hasRenderedContent(widgetIndex, preRenderedWidgets) {
+  return preRenderedWidgets ? Boolean(preRenderedWidgets[widgetIndex]?.content) : true;
 }
-function advanceGlobalSeparatorIndex(currentIndex, widgets) {
-  return currentIndex + countSeparatorSlots(widgets);
+function countSeparatorSlots(widgets, preRenderedWidgets) {
+  let count = 0;
+  let hasPreviousRenderableWidget = false;
+  let previousRenderableWidgetMergesWithNext = false;
+  for (let i = 0;i < widgets.length; i++) {
+    const widget = widgets[i];
+    if (!widget) {
+      continue;
+    }
+    if (widget.type === "separator") {
+      if (hasPreviousRenderableWidget) {
+        previousRenderableWidgetMergesWithNext = false;
+      }
+      continue;
+    }
+    if (widget.type === "flex-separator") {
+      hasPreviousRenderableWidget = false;
+      previousRenderableWidgetMergesWithNext = false;
+      continue;
+    }
+    if (!hasRenderedContent(i, preRenderedWidgets)) {
+      continue;
+    }
+    if (hasPreviousRenderableWidget && !previousRenderableWidgetMergesWithNext) {
+      count++;
+    }
+    hasPreviousRenderableWidget = true;
+    previousRenderableWidgetMergesWithNext = Boolean(widget.merge);
+  }
+  return count;
+}
+function advanceGlobalSeparatorIndex(currentIndex, widgets, preRenderedWidgets) {
+  return currentIndex + countSeparatorSlots(widgets, preRenderedWidgets);
 }
 
 // src/tui/components/StatusLinePreview.tsx
 var jsx_dev_runtime24 = __toESM(require_jsx_dev_runtime(), 1);
-var renderSingleLine = (widgets, terminalWidth, settings, lineIndex, globalSeparatorIndex, globalPowerlineThemeIndex, preRenderedWidgets, preCalculatedMaxWidths) => {
+var renderSingleLine = (widgets, terminalWidth, settings, lineIndex, globalSeparatorIndex, globalPowerlineThemeIndex, globalPowerlineStartCapIndex, preRenderedWidgets, preCalculatedMaxWidths) => {
   const context = {
     terminalWidth,
     isPreview: true,
@@ -76918,7 +77247,8 @@ var renderSingleLine = (widgets, terminalWidth, settings, lineIndex, globalSepar
     gitCacheTtlSeconds: settings.gitCacheTtlSeconds,
     lineIndex,
     globalSeparatorIndex,
-    globalPowerlineThemeIndex
+    globalPowerlineThemeIndex,
+    globalPowerlineStartCapIndex
   };
   return renderStatusLineWithInfo(widgets, settings, context, preRenderedWidgets, preCalculatedMaxWidths);
 };
@@ -76941,18 +77271,22 @@ var StatusLinePreview = ({ lines, terminalWidth, settings, onTruncationChange })
     const preCalculatedMaxWidths = calculateMaxWidthsFromPreRendered(preRenderedLines, settings);
     let globalSeparatorIndex = 0;
     let globalPowerlineThemeIndex = 0;
+    let globalPowerlineStartCapIndex = 0;
     const result2 = [];
     let truncated = false;
     for (let i = 0;i < lines.length; i++) {
       const lineItems = lines[i];
       if (lineItems && lineItems.length > 0) {
         const preRenderedWidgets = preRenderedLines[i] ?? [];
-        const renderResult = renderSingleLine(lineItems, terminalWidth, settings, i, globalSeparatorIndex, globalPowerlineThemeIndex, preRenderedWidgets, preCalculatedMaxWidths);
+        const renderResult = renderSingleLine(lineItems, terminalWidth, settings, i, globalSeparatorIndex, globalPowerlineThemeIndex, globalPowerlineStartCapIndex, preRenderedWidgets, preCalculatedMaxWidths);
         result2.push(renderResult.line);
         if (renderResult.wasTruncated) {
           truncated = true;
         }
-        globalSeparatorIndex = advanceGlobalSeparatorIndex(globalSeparatorIndex, lineItems);
+        globalSeparatorIndex = advanceGlobalSeparatorIndex(globalSeparatorIndex, lineItems, preRenderedWidgets);
+        if (settings.powerline.enabled) {
+          globalPowerlineStartCapIndex += countPowerlineStartCapSlots(lineItems, preRenderedWidgets);
+        }
         if (settings.powerline.enabled && settings.powerline.continueThemeAcrossLines) {
           globalPowerlineThemeIndex = advanceGlobalPowerlineThemeIndex(globalPowerlineThemeIndex, preRenderedWidgets);
         }
@@ -78917,6 +79251,7 @@ async function ensureWindowsUtf8CodePage() {
 }
 async function renderMultipleLines(data) {
   const settings = await loadSettings();
+  const configError = getConfigLoadError();
   source_default.level = settings.colorLevel;
   updateColorMap();
   const lines = settings.lines;
@@ -78974,6 +79309,8 @@ async function renderMultipleLines(data) {
   const preCalculatedMaxWidths = calculateMaxWidthsFromPreRendered(preRenderedLines, settings);
   let globalSeparatorIndex = 0;
   let globalPowerlineThemeIndex = 0;
+  let globalPowerlineStartCapIndex = 0;
+  let configBadgePrepended = false;
   for (let i = 0;i < lines.length; i++) {
     const lineItems = lines[i];
     if (lineItems && lineItems.length > 0) {
@@ -78982,21 +79319,32 @@ async function renderMultipleLines(data) {
         ...context,
         lineIndex: i,
         globalSeparatorIndex,
-        globalPowerlineThemeIndex
+        globalPowerlineThemeIndex,
+        globalPowerlineStartCapIndex
       };
-      const line = renderStatusLine(lineItems, settings, lineContext, preRenderedWidgets, preCalculatedMaxWidths);
+      let line = renderStatusLine(lineItems, settings, lineContext, preRenderedWidgets, preCalculatedMaxWidths);
       const strippedLine = getVisibleText(line).trim();
       if (strippedLine.length > 0) {
+        if (configError && !configBadgePrepended) {
+          line = `${buildConfigWarningBadge(settings.colorLevel)} | ${line}`;
+          configBadgePrepended = true;
+        }
         let outputLine = line.replace(/ /g, " ");
         outputLine = "\x1B[0m" + outputLine;
         console.log(outputLine);
-        globalSeparatorIndex = advanceGlobalSeparatorIndex(globalSeparatorIndex, lineItems);
+        globalSeparatorIndex = advanceGlobalSeparatorIndex(globalSeparatorIndex, lineItems, preRenderedWidgets);
+        if (settings.powerline.enabled) {
+          globalPowerlineStartCapIndex += countPowerlineStartCapSlots(lineItems, preRenderedWidgets);
+        }
         if (settings.powerline.enabled && settings.powerline.continueThemeAcrossLines) {
           globalPowerlineThemeIndex = advanceGlobalPowerlineThemeIndex(globalPowerlineThemeIndex, preRenderedWidgets);
         }
       }
     }
   }
+  if (configError && !configBadgePrepended) {
+    console.log("\x1B[0m" + buildConfigWarningBadge(settings.colorLevel).replace(/ /g, " "));
+  }
   if (settings.updatemessage?.message && settings.updatemessage.message.trim() !== "" && settings.updatemessage.remaining && settings.updatemessage.remaining > 0) {
     console.log(settings.updatemessage.message);
     const newRemaining = settings.updatemessage.remaining - 1;

package/package.json

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