@groeponline/pi-wishcraft 1.4.0 → 1.6.0

package/src/render/layout.ts

@@ -0,0 +1,95 @@
+// Pure layout for the v2 powerline. No fs, no git, no theme reload.
+// ponytail: this is a refactor target. The legacy getResponsiveLayout stays
+// in place until U12 cutover; the v2 entry point is the only public surface
+// for the new pipeline. Width classes follow the existing renderer
+// (status-line-renderers.ts): small <60, medium <120, wide otherwise.
+
+import { visibleWidth } from "@earendil-works/pi-tui";
+
+export type WidthClass = "small" | "medium" | "wide";
+
+export interface LayoutSegment {
+  id: string;
+  text: string;
+  priority: number;
+}
+
+export interface LayoutConfig {
+  primary: string[];
+  secondary: string[];
+  separator: string;
+  maxWidth: number;
+}
+
+export interface LayoutResult {
+  primary: LayoutSegment[];
+  secondary: LayoutSegment[];
+  dropped: LayoutSegment[];
+  widthClass: WidthClass;
+}
+
+function widthClassFor(width: number): WidthClass {
+  if (width < 60) return "small";
+  if (width < 120) return "medium";
+  return "wide";
+}
+
+function laneFor(seg: LayoutSegment, config: LayoutConfig): "primary" | "secondary" | null {
+  if (config.primary.includes(seg.id)) return "primary";
+  if (config.secondary.includes(seg.id)) return "secondary";
+  return null;
+}
+
+export function computeLaneLayout(
+  segments: LayoutSegment[],
+  width: number,
+  config: LayoutConfig,
+): LayoutResult {
+  const cap = Math.max(0, Math.min(width, config.maxWidth));
+  const separatorWidth = visibleWidth(config.separator);
+  const primary: LayoutSegment[] = [];
+  const secondary: LayoutSegment[] = [];
+  const dropped: LayoutSegment[] = [];
+  // Sort by priority desc once; then assign by lane membership and width.
+  const sorted = [...segments].sort((a, b) => b.priority - a.priority);
+  let primaryUsed = 0;
+  let secondaryUsed = 0;
+  for (const seg of sorted) {
+    const lane = laneFor(seg, config);
+    if (lane === null) {
+      dropped.push(seg);
+      continue;
+    }
+    if (visibleWidth(seg.text) === 0) {
+      dropped.push(seg);
+      continue;
+    }
+    const w = visibleWidth(seg.text);
+    // Each lane owns its own budget: a primary segment must not push a
+    // secondary segment off the line. Separator width is charged only when
+    // a segment follows another in the same lane.
+    const used = lane === "primary" ? primaryUsed : secondaryUsed;
+    const addedWidth = used === 0 ? w : separatorWidth + w;
+    if (used + addedWidth > cap) {
+      dropped.push(seg);
+      continue;
+    }
+    (lane === "primary" ? primary : secondary).push(seg);
+    if (lane === "primary") primaryUsed += addedWidth;
+    else secondaryUsed += addedWidth;
+  }
+
+  // Honor the original primary/secondary order in the config so callers
+  // expect model->context->git->queue rather than priority-sorted.
+  const primaryOrder = new Map(config.primary.map((id, i) => [id, i]));
+  primary.sort((a, b) => (primaryOrder.get(a.id) ?? 0) - (primaryOrder.get(b.id) ?? 0));
+  const secondaryOrder = new Map(config.secondary.map((id, i) => [id, i]));
+  secondary.sort((a, b) => (secondaryOrder.get(a.id) ?? 0) - (secondaryOrder.get(b.id) ?? 0));
+
+  return {
+    primary,
+    secondary,
+    dropped,
+    widthClass: widthClassFor(width),
+  };
+}

package/src/render/motion-rail.ts

@@ -0,0 +1,79 @@
+/**
+ * Motion rail (v2). Renders the Signal activity rail — the animated
+ * sweep/compact rail plus activity label — as a first-class layout segment.
+ * Extracted from the legacy v1 Signal renderer (src/signal/render.ts,
+ * deleted in the U12 cutover); rail semantics are unchanged: idle = flat
+ * rail, streaming = travelling head + trail, compacting = inward heads.
+ */
+
+import { sweepPosition, trailGlyph } from "../motion/index.ts";
+import type { SignalRuntime } from "../signal/controller.ts";
+import type { SignalSpec } from "../config/types.ts";
+import { ansi, colorEnabled, getFgAnsiCode } from "../theme/colors.ts";
+
+export function renderActivity(
+  runtime: SignalRuntime,
+  spec: SignalSpec,
+  ascii = false,
+): string {
+  const label = runtime.activity || "ready";
+  const open = spec.caps.leftOpen ?? "";
+  const close = spec.caps.leftClose ?? "";
+  const dim = getFgAnsiCode("sep");
+  const hot = getFgAnsiCode("accent");
+  const reset = colorEnabled() ? ansi.reset : "";
+  // One glyph family, directional comet: light `─` track, fixed solid
+  // head, and a short box-drawing trail ONLY behind the head. Idle is a
+  // calm flat rail (no cycling glyphs — the old shade-block cloud read
+  // muddy across three unrelated glyph families).
+  const RAIL_WIDTH = 12;
+  const track = ascii ? "-" : "─";
+  const head = ascii ? "o" : "●";
+  let railInner: string;
+  if (!runtime.active) {
+    railInner = track.repeat(RAIL_WIDTH);
+  } else if (runtime.activity === "compacting") {
+    // Compact state: two heads travel inward and compress a heavy core —
+    // visually distinct from the sweep so compaction reads at a glance.
+    railInner = renderCompactRail(runtime.tick, RAIL_WIDTH, ascii);
+  } else {
+    const pos = sweepPosition(runtime.tick, RAIL_WIDTH, true);
+    const built: string[] = [];
+    for (let i = 0; i < RAIL_WIDTH; i++) {
+      if (i === pos) built.push(head);
+      else if (i < pos) built.push(trailGlyph(Math.min(pos - i, 4), ascii));
+      else built.push(track);
+    }
+    railInner = built.join("");
+  }
+  const railColor = runtime.active ? hot : dim;
+  const rail = `${spec.separators.left}${railInner}${spec.separators.right}`;
+  return `${railColor}${open}${rail}${close}${reset} ${label}`;
+}
+
+/**
+ * Compact rail: two heads travel inward toward center, compressing the rail.
+ * Gives compaction a distinct visual signature vs the generic sweep.
+ */
+function renderCompactRail(
+  tick: number,
+  width: number,
+  ascii: boolean,
+): string {
+  const half = Math.floor(width / 2);
+  // Heads oscillate from the edges toward center and back.
+  const span = half;
+  const phase = tick % (span * 2);
+  const inward = phase < span ? phase : span * 2 - phase;
+  const leftPos = inward;
+  const rightPos = width - 1 - inward;
+  const head = ascii ? "*" : "●";
+  const core = ascii ? "=" : "━";
+  const track = ascii ? "-" : "─";
+  let built = "";
+  for (let i = 0; i < width; i++) {
+    if (i === leftPos || i === rightPos) built += head;
+    else built += i > leftPos && i < rightPos ? core : track;
+  }
+  return built;
+}

package/src/render/paint.ts

@@ -0,0 +1,40 @@
+// Cheap paint assembly. Consumes a layout and produces terminal-ready
+// strings. No fs, no git, no theme reload — those are upstream of layout.
+
+export interface PaintedLane {
+  id: string;
+  text: string;
+  bg: string;
+  fg: string;
+}
+
+export interface PaintedLayout {
+  primary: PaintedLane[];
+  secondary: PaintedLane[];
+  dropped: PaintedLane[];
+  widthClass: "small" | "medium" | "wide";
+}
+
+const RESET = "\x1b[0m";
+
+export function paintLane(lane: PaintedLane): string {
+  return `${lane.bg}${lane.fg}${lane.text}${RESET}`;
+}
+
+export function paintLayout(layout: PaintedLayout, separator: string): string {
+  const out: string[] = [];
+  for (let i = 0; i < layout.primary.length; i++) {
+    if (i > 0) out.push(separator);
+    out.push(paintLane(layout.primary[i]!));
+  }
+  return out.join("");
+}
+
+export function paintSecondary(layout: PaintedLayout, separator: string): string {
+  const out: string[] = [];
+  for (let i = 0; i < layout.secondary.length; i++) {
+    if (i > 0) out.push(separator);
+    out.push(paintLane(layout.secondary[i]!));
+  }
+  return out.join("");
+}

package/src/render/v2-adapter.ts

@@ -0,0 +1,68 @@
+// v2 render adapter: wires the pure layout + paint into a top/secondary
+// string pair matching the shape that status-line-renderers.ts consumers
+// (renderPowerlinePrimaryLines / renderPowerlineSecondaryLines) already
+// expect. This is the U12 cutover entry point. v1 paths remain in place
+// until a follow-up PR deletes them after live-golden verification.
+//
+// ponytail: this is a delegating adapter, not a replacement. The
+// status-line-renderers.ts consumers stay on v1 until v2 is exercised
+// against real presets; the adapter exists so consumers can opt in via a
+// single import swap once that is done.
+
+import { computeLaneLayout, type LayoutSegment, type WidthClass } from "./layout.ts";
+import { paintLayout, paintSecondary, type PaintedLane } from "./paint.ts";
+
+export interface V2Segment extends LayoutSegment {}
+
+export interface V2LaneConfig {
+  primary: string[];
+  secondary: string[];
+  /** Separator between painted lanes; styled separators carry ANSI. */
+  separator?: string;
+}
+
+export interface V2RenderResult {
+  topContent: string;
+  secondaryContent: string;
+  dropped: LayoutSegment[];
+  widthClass: WidthClass;
+}
+
+const SEPARATOR = " | ";
+
+function toPainted(seg: LayoutSegment): PaintedLane {
+  return {
+    id: seg.id,
+    text: seg.text,
+    bg: "",
+    fg: "",
+  };
+}
+
+export function renderPowerlineV2(
+  segments: V2Segment[],
+  width: number,
+  config: V2LaneConfig,
+): V2RenderResult {
+  const separator = config.separator ?? SEPARATOR;
+  const layout = computeLaneLayout(segments, width, {
+    primary: config.primary,
+    secondary: config.secondary,
+    separator,
+    maxWidth: width,
+  });
+
+  const painted = {
+    primary: layout.primary.map(toPainted),
+    secondary: layout.secondary.map(toPainted),
+    dropped: [] as PaintedLane[],
+    widthClass: layout.widthClass,
+  };
+
+  return {
+    topContent: paintLayout(painted, separator),
+    secondaryContent: paintSecondary(painted, separator),
+    dropped: layout.dropped,
+    widthClass: layout.widthClass,
+  };
+}

package/src/render/v2-entry.ts

@@ -0,0 +1,132 @@
+/**
+ * v2 status-line entry (U12 cutover). Composes the single render path:
+ * segments render through the per-segment fault-isolated `renderSegment`
+ * boundary, the motion rail renders as a first-class layout segment, and
+ * lanes flow through `computeLaneLayout` + `paintLayout`. The legacy v1
+ * three-lane renderer (src/signal/render.ts) is deleted; rail semantics
+ * live on in ./motion-rail.ts.
+ *
+ * Priority scheme preserves the v1 reading order left -> rail -> right:
+ * left segments 10_000-i, rail 5_000, right segments 1_000-i. Under width
+ * pressure computeLaneLayout drops the lowest priorities first, so the
+ * right lane yields before the rail, and the rail before the left —
+ * matching v1's "preserve model/git first, then context/queue" squeeze.
+ */
+
+import type {
+  PresetDef,
+  SegmentContext,
+  SignalSpec,
+  StatusLineLayout,
+  StatusLineSegmentId,
+  StatusLineSeparatorStyle,
+} from "../config/types.ts";
+import { mergeSegmentsWithCustomItems } from "../config/powerline-config.ts";
+import { renderSegment } from "../segments/index.ts";
+import { getContributedSignalSources } from "../extension/contrib/registry.ts";
+import { getSeparator } from "../theme/separators.ts";
+import { ansi, colorEnabled, getFgAnsiCode } from "../theme/colors.ts";
+import { renderActivity } from "./motion-rail.ts";
+import { renderPowerlineV2, type V2Segment } from "./v2-adapter.ts";
+import type { SignalRuntime } from "../signal/controller.ts";
+
+export interface StatusLineV2Options {
+  separatorStyle: StatusLineSeparatorStyle;
+  signal: SignalSpec;
+  ascii?: boolean;
+  layout?: StatusLineLayout | null;
+  disabledSegments?: StatusLineSegmentId[];
+}
+
+const ANSI_CONTROL_RE =
+  /\x1B(?:\][^\x07]*(?:\u0007|\x1B\\)|\[[0-?]*[ -/]*[@-~]|[@-_])|\x9B[0-?]*[ -/]*[@-~]|\x9D[^\x07]*(?:\u0007|\x1B\\)/g;
+
+function contributedTexts(ctx: SegmentContext): string[] {
+  const out: string[] = [];
+  for (const src of getContributedSignalSources()) {
+    try {
+      const raw = src.render?.(ctx);
+      if (!raw || typeof raw !== "string") continue;
+      const content = raw.trim();
+      if (!content.replace(ANSI_CONTROL_RE, "").trim()) continue;
+      // ponytail: fault-isolated — a throwing or empty source never takes the line down
+      out.push(content);
+    } catch {
+      // skip failing contribution
+    }
+  }
+  return out;
+}
+
+function styledSeparator(separator: string): string {
+  const color = getFgAnsiCode("sep");
+  const reset = colorEnabled() ? ansi.reset : "";
+  return ` ${color}${separator}${reset} `;
+}
+
+export function renderStatusLineV2(
+  ctx: SegmentContext,
+  preset: PresetDef,
+  runtime: SignalRuntime,
+  width: number,
+  options: StatusLineV2Options,
+): { topContent: string; secondaryContent: string } {
+  const merged = mergeSegmentsWithCustomItems(
+    preset,
+    ctx.effectiveCustomItems,
+    {
+      layout: options.layout ?? null,
+      disabledSegments: options.disabledSegments ?? [],
+    },
+  );
+
+  const segments: V2Segment[] = [];
+  const primary: string[] = [];
+
+  const pushSegment = (id: StatusLineSegmentId, priority: number): void => {
+    try {
+      const rendered = renderSegment(id, ctx);
+      if (!rendered.visible || !rendered.content) return;
+      segments.push({ id, text: rendered.content, priority });
+      primary.push(id);
+    } catch {
+      // renderSegment is the established per-segment error boundary; a
+      // throwing segment never blanks the line.
+    }
+  };
+
+  merged.leftSegments.forEach((id, i) => pushSegment(id, 10_000 - i));
+
+  const rail = renderActivity(runtime, options.signal, options.ascii);
+  segments.push({ id: "signal", text: rail, priority: 5_000 });
+  primary.push("signal");
+
+  merged.rightSegments.forEach((id, i) => pushSegment(id, 1_000 - i));
+  contributedTexts(ctx).forEach((text, i) => {
+    const id = `contrib:${i}`;
+    segments.push({ id, text, priority: 900 - i });
+    primary.push(id);
+  });
+
+  merged.secondarySegments.forEach((id, i) => {
+    try {
+      const rendered = renderSegment(id, ctx);
+      if (!rendered.visible || !rendered.content) return;
+      segments.push({ id, text: rendered.content, priority: 500 - i });
+    } catch {
+      // Keep secondary segments behind the same fault boundary as primary.
+    }
+  });
+
+  const separatorGlyph = getSeparator(options.separatorStyle).left;
+  const result = renderPowerlineV2(segments, width, {
+    primary,
+    secondary: [...merged.secondarySegments],
+    separator: styledSeparator(separatorGlyph),
+  });
+
+  return {
+    topContent: result.topContent,
+    secondaryContent: result.secondaryContent,
+  };
+}

package/src/segments/pipeline.ts

@@ -0,0 +1,164 @@
+/**
+ * Segment pipeline v2 (U2, KTD5).
+ *
+ * Routes builtin segments and contributed signal sources through the same
+ * try/catch + cache + render-budget path. v1's `renderSegment` /
+ * `renderContributedSources` still work; U11 cuts them over to call this
+ * pipeline instead.
+ */
+
+import type { RenderedSegment, SegmentContext } from "../config/types.ts";
+import type {
+  PipelineContext,
+  PipelineOptions,
+  PipelineSegment,
+  PipelineSource,
+  RenderedPipelineOutput,
+} from "./types.ts";
+
+interface CacheEntry {
+  key: string;
+  value: RenderedPipelineOutput;
+}
+
+const cacheStore = new Map<string, CacheEntry>();
+
+function cacheKey(kind: "builtin" | "source", id: string, version: string): string {
+  // Namespace by producer type: a builtin segment and a contributed source
+  // may share an id and must never reuse each other's cached entry.
+  return `${kind}:${id}:${version}`;
+}
+
+function normalizeSourceOutput(raw: string | undefined): RenderedSegment {
+  if (raw === undefined) return { content: "", visible: false };
+  const trimmed = raw.trim();
+  if (!trimmed) return { content: "", visible: false };
+  return { content: raw, visible: true };
+}
+
+async function renderBuiltin(
+  segment: PipelineSegment,
+  ctx: SegmentContext,
+  budgetMs: number,
+): Promise<RenderedSegment | null> {
+  if (budgetMs > 0) {
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    try {
+      return await Promise.race([
+        (async () => segment.render(ctx))(),
+        new Promise<RenderedSegment>((_resolve, reject) => {
+          timer = setTimeout(
+            () => reject(new Error("render-budget-exceeded")),
+            budgetMs,
+          );
+        }),
+      ]);
+    } catch (err) {
+      if (err instanceof Error && err.message === "render-budget-exceeded") {
+        return { content: "", visible: false };
+      }
+      return null;
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+  try {
+    return await (async () => segment.render(ctx))();
+  } catch {
+    return null;
+  }
+}
+
+async function renderSource(
+  source: PipelineSource,
+  ctx: SegmentContext,
+  budgetMs: number,
+): Promise<RenderedSegment | null> {
+  if (budgetMs > 0) {
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    try {
+      const raw = await Promise.race([
+        (async () => source.render(ctx))(),
+        new Promise<string | undefined>((_resolve, reject) => {
+          timer = setTimeout(
+            () => reject(new Error("render-budget-exceeded")),
+            budgetMs,
+          );
+        }),
+      ]);
+      return normalizeSourceOutput(raw);
+    } catch {
+      return null;
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+  let raw: string | undefined;
+  try {
+    raw = await (async () => source.render(ctx))();
+  } catch {
+    return null;
+  }
+  return normalizeSourceOutput(raw);
+}
+
+export async function runSegmentPipeline(
+  segments: readonly PipelineSegment[],
+  sources: readonly PipelineSource[],
+  ctx: PipelineContext,
+  options: PipelineOptions = {},
+): Promise<RenderedPipelineOutput[]> {
+  const { cache = false, budgetMs = 0 } = options;
+  // PipelineContext extends SegmentContext, so renderers receive the context
+  // values they read (usage stats, window, thresholds) without a cast.
+  const segCtx: SegmentContext = ctx;
+  const out: RenderedPipelineOutput[] = [];
+
+  for (const segment of segments) {
+    const key = cacheKey("builtin", segment.id, ctx.version);
+    if (cache) {
+      const hit = cacheStore.get(key);
+      if (hit) {
+        out.push({ ...hit.value, cached: true });
+        continue;
+      }
+    }
+    const rendered = await renderBuiltin(segment, segCtx, budgetMs);
+    if (rendered === null) continue;
+    const entry: RenderedPipelineOutput = {
+      id: segment.id,
+      content: rendered.content,
+      visible: rendered.visible,
+      cached: false,
+    };
+    out.push(entry);
+    if (cache) cacheStore.set(key, { key, value: entry });
+  }
+
+  for (const source of sources) {
+    const key = cacheKey("source", source.id, ctx.version);
+    if (cache) {
+      const hit = cacheStore.get(key);
+      if (hit) {
+        out.push({ ...hit.value, cached: true });
+        continue;
+      }
+    }
+    const rendered = await renderSource(source, segCtx, budgetMs);
+    if (rendered === null || !rendered.visible) continue;
+    const entry: RenderedPipelineOutput = {
+      id: source.id,
+      content: rendered.content,
+      visible: rendered.visible,
+      cached: false,
+    };
+    out.push(entry);
+    if (cache) cacheStore.set(key, { key, value: entry });
+  }
+
+  return out;
+}
+
+export function clearSegmentCache(): void {
+  cacheStore.clear();
+}

package/src/segments/types.ts

@@ -0,0 +1,36 @@
+/** Segment pipeline v2 (U2). Pure types — no TUI imports. */
+
+import type { RenderedSegment, SegmentContext } from "../config/types.ts";
+
+export interface PipelineContext extends SegmentContext {
+  /** Bumped by callers when any input that affects rendering changes; the
+   *  pipeline uses this together with the segment id as the cache key. */
+  version: string;
+}
+
+/** A builtin-style segment: typed contract with id + render. */
+export interface PipelineSegment {
+  id: string;
+  render(ctx: SegmentContext): RenderedSegment | Promise<RenderedSegment>;
+}
+
+/** A contributed source: free-form id, render returns a raw string. */
+export interface PipelineSource {
+  id: string;
+  render(ctx: SegmentContext): string | undefined | Promise<string | undefined>;
+}
+
+export interface RenderedPipelineOutput {
+  id: string;
+  content: string;
+  visible: boolean;
+  cached: boolean;
+}
+
+export interface PipelineOptions {
+  /** Cache rendered results by (id, ctx.version). Default false. */
+  cache?: boolean;
+  /** Per-segment render budget in ms. Exceeding segments degrade to hidden.
+   *  Set to 0 to disable. Default 0 (no budget). */
+  budgetMs?: number;
+}

package/src/segments/usage.ts

@@ -2,6 +2,7 @@ import type { StatusLineSegment } from "../config/types.ts";
 import { getIcons } from "../theme/icons.ts";
 import { formatUsdCost } from "../usage/rates.ts";
 import { costColorForBudget, tokenBudgetLevel } from "../usage/token-budget.ts";
+import { ansi, colorEnabled } from "../theme/colors.ts";
 import { color, withIcon, formatTokens } from "./shared.ts";
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -110,18 +111,56 @@ export const contextPctSegment: StatusLineSegment = {
       percentOnly
         ? color(ctx, semantic, text)
         : withIcon(icons.context, color(ctx, semantic, text));
+    let semantic: "context" | "contextWarn" | "contextError";
     if (contextPercent > 90) {
-      content = colored("contextError");
+      semantic = "contextError";
     } else if (contextPercent > 70) {
-      content = colored("contextWarn");
+      semantic = "contextWarn";
     } else {
-      content = colored("context");
+      semantic = "context";
     }
+    const baseContent = colored(semantic);
+
+    // Append a compact 8-cell fill bar so usage is scannable at a glance.
+    // Filled cells use the semantic color, empty cells use the muted separator.
+    const bar = contextFillBar(contextPercent, (s) => color(ctx, s, ""));
+    content = percentOnly ? baseContent : `${baseContent} ${bar}`;
 
     return { content, visible: true };
   },
 };
 
+/**
+ * Compact 8-cell context fill bar. Filled cells track the usage percentage;
+ * the cell color follows the threshold (normal/warn/error) so the bar doubles
+ * as a glanceable usage meter alongside the numeric readout.
+ */
+function contextFillBar(
+  percent: number,
+  colorFn: (semantic: "context" | "contextWarn" | "contextError") => string,
+): string {
+  const CELLS = 8;
+  // Clamp to the bar's cell count: percentages above 100 must not grow the
+  // status line, and negative percentages must not underflow the empty run.
+  const filled = Math.max(0, Math.min(CELLS, Math.round((percent / 100) * CELLS)));
+  let semantic: "context" | "contextWarn" | "contextError";
+  if (percent > 90) {
+    semantic = "contextError";
+  } else if (percent > 70) {
+    semantic = "contextWarn";
+  } else {
+    semantic = "context";
+  }
+  // Filled cells are left-aligned, so we can emit them as one colored run,
+  // then the empty cells as another — just two color codes total, not one per cell.
+  const filledColor = colorFn(semantic);
+  const emptyColor = colorFn("context");
+  const reset = colorEnabled() ? ansi.reset : "";
+  const filledRun = filled > 0 ? `${filledColor}${"▓".repeat(filled)}${reset}` : "";
+  const emptyRun = filled < CELLS ? `${emptyColor}${"░".repeat(CELLS - filled)}${reset}` : "";
+  return `${filledRun}${emptyRun}`;
+}
+
 export const contextTotalSegment: StatusLineSegment = {
   id: "context_total",
   render(ctx) {