@pi-unipi/footer 0.1.3 → 2.0.0

package/src/rendering/icons.ts

@@ -27,6 +27,10 @@ export interface IconSet {
   session: string;
   hostname: string;
   time: string;
+  tps: string;
+  clock: string;
+  duration: string;
+  thinkingLevel: string;
 
   // Compactor segments
   sessionEvents: string;
@@ -80,61 +84,65 @@ export interface IconSet {
 /** Nerd Font glyphs — requires a Nerd Font installed in the terminal */
 export const NERD_ICONS: IconSet = {
   // Core
-  model:           "\uDB81\uDE5B", // 󰚩 custom model icon
-  apiState:        "\uF725", // 󱂛 api state icon
-  toolCount:       "\uF0AD", //  tool count icon
-  git:             "\uF0E8", //  git icon
-  context:         "\uF8D8", //  context icon
-  cost:            "\uF155", //  cost icon
-  tokens:          "\uF07B", //  tokens icon
-  tokensIn:        "\uF07B", //  tokens in icon
-  tokensOut:       "\uF07B", //  tokens out icon
-  session:         "\uF550", // nf-md-identifier
-  hostname:        "\uF109", // nf-fa-laptop
-  time:            "\uF017", // nf-fa-clock_o
+  model:           "\u{F06A9}", // 󰚩
+  apiState:        "\u{F109B}", // 󱂛
+  toolCount:       "\u{F1064}", // 󱁤
+  git:             "\uEAFE", // 
+  context:         "\u{F0077}", // 󰁷
+  cost:            "\uF155", // 
+  tokens:          "\uEDE8", // 
+  tokensIn:        "\uEDE8", // 
+  tokensOut:       "\uEDE8", // 
+  session:         "\uF03A", // 
+  hostname:        "\uEA7A", // 
+  time:            "\uF017", // 
+  tps:             "\u{F04C5}", // 󰓅
+  clock:           "\uF017", // 
+  duration:        "\u{F13AB}", // 󱎫
+  thinkingLevel:   "\uF400", // 
 
   // Compactor
-  sessionEvents:   "\uDBB1\uDECF", // 󰲏 session events icon
-  compactions:     "\uDBB1\uDECF", // 󰲏 compactions icon
-  tokensSaved:     "\uF155", //  tokens saved icon
-  compressionRatio:"\uDBB1\uDECF", // 󰲏 compression ratio icon
-  indexedDocs:     "\uDB81\uDE19", // 󰈙 indexed docs icon
-  sandboxRuns:     "\uF121", //  sandbox runs icon
-  searchQueries:   "\uF002", //  search queries icon
+  sessionEvents:   "\uEA86", // 
+  compactions:     "\u{F0C8F}", // 󰲏
+  tokensSaved:     "\uF155", //  (kept — missing from customization)
+  compressionRatio:"\u{F0C8F}", // 󰲏
+  indexedDocs:     "\u{F0219}", // 󰈙
+  sandboxRuns:     "\uF233", // 
+  searchQueries:   "\uF002", // 
 
   // Memory
-  projectCount:    "\uDB81\uDED4", // 󰍚 memory icon
-  totalCount:      "\uEB9C", //  total count icon
-  consolidations:  "\uDB81\uDED4", // 󰍚 consolidations icon
+  projectCount:    "\uEE9C", // 
+  totalCount:      "\uEE9C", // 
+  consolidations:  "\uEE9C", // 
 
   // MCP
-  serversTotal:    "\uF0F6", //  servers total icon
-  serversActive:   "\uF058", //  servers active icon
-  toolsTotal:      "\uF0AD", //  tools total icon
-  serversFailed:   "\uF467", //  servers failed icon
+  serversTotal:    "\u{F05B7}", // 󰖷
+  serversActive:   "\u{F05B7}", // 󰖷
+  toolsTotal:      "\u{F05B7}", // 󰖷
+  serversFailed:   "\u{F05B7}", // 󰖷
 
   // Ralph
-  activeLoops:     "\udb81\udf09", // 󰼉 ralph loop icon
-  totalIterations: "\udb81\udf09", // 󰼉 ralph loop icon
-  loopStatus:      "\udb81\udf09", // 󰼉 ralph loop icon
+  activeLoops:     "\u{F0709}", // 󰜉
+  totalIterations: "\u{F0709}", // 󰜉
+  loopStatus:      "\u{F0709}", // 󰜉
 
   // Workflow
-  currentCommand:  "\uF0E8", //  current command icon
-  sandboxLevel:    "\uDBB1\uDDFE", // 󰟾 sandbox level icon
-  commandDuration: "\uDBB9\uDEAB", // 󱎫 command duration icon
+  currentCommand:  "\uF124", // 
+  sandboxLevel:    "\u{F07FE}", // 󰟾
+  commandDuration: "\u{F13AB}", // 󱎫
 
   // Kanboard
-  docsCount:       "\uDB81\uDE19", // 󰈙 docs count icon
-  tasksDone:       "\uF0E8", //  tasks done icon
-  tasksTotal:      "\uF0E8", //  tasks total icon
-  taskPct:         "\uF0E8", //  task pct icon
+  docsCount:       "\u{F09EE}", // 󰧮
+  tasksDone:       "\u{F1A9A}", // 󱪚
+  tasksTotal:      "\uF4A0", // 
+  taskPct:         "\uF4A0", // 
 
   // Notify
-  platformsEnabled:"\uF0E0", // nf-fa-envelope
-  lastSent:        "\uF017", // nf-fa-clock_o
+  platformsEnabled:"\uEB9A", // 
+  lastSent:        "\u{F13AB}", // 󱎫
 
   // Extension status
-  extensionStatuses:"\uDBB5\uDEAB", // 󱖫 extension statuses icon
+  extensionStatuses:"\u{F15AB}", // 󱖫
 
   separator:       "\uE0B1", // nf-pl-left_soft_divider
 };
@@ -147,33 +155,38 @@ export const EMOJI_ICONS: IconSet = {
   model:           "🤖",
   apiState:        "🔄",
   toolCount:       "🔧",
-  git:             "⎇",
+  git:             "🔀",
   context:         "🗄️",
   cost:            "💲",
-  tokens:          "⊛",
-  tokensIn:        "→",
-  tokensOut:       "←",
-  session:         "#",
-  hostname:        "⌂",
+  tokens:          "📊",
+  tokensIn:        "⬇️",
+  tokensOut:       "⬆️",
+  session:         "📋",
+  hostname:        "🏠",
   time:            "⏱",
 
+  tps:             "⚡",
+  clock:           "🕔",
+  duration:        "⏱",
+  thinkingLevel:   "💡",
+
   // Compactor
-  sessionEvents:   "⚡",
-  compactions:     "◧",
+  sessionEvents:   "📈",
+  compactions:     "🗜️",
   tokensSaved:     "💲",
-  compressionRatio:"⇄",
-  indexedDocs:     "☰",
-  sandboxRuns:     "▶",
-  searchQueries:   "⊗",
+  compressionRatio:"📐",
+  indexedDocs:     "📑",
+  sandboxRuns:     "▶️",
+  searchQueries:   "🔍",
 
   // Memory
   projectCount:    "🧠",
   totalCount:      "🧠",
-  consolidations:  "🧠",
+  consolidations:  "🔄",
 
   // MCP
   serversTotal:    "🖥️",
-  serversActive:   "●",
+  serversActive:   "🟢",
   toolsTotal:      "🔧",
   serversFailed:   "⚠️",
 
@@ -188,17 +201,17 @@ export const EMOJI_ICONS: IconSet = {
   commandDuration: "⏱",
 
   // Kanboard
-  docsCount:       "☰",
-  tasksDone:       "✓",
-  tasksTotal:      "☐",
-  taskPct:         "%",
+  docsCount:       "📑",
+  tasksDone:       "✅",
+  tasksTotal:      "📋",
+  taskPct:         "📊",
 
   // Notify
-  platformsEnabled:"♮",
+  platformsEnabled:"🔔",
   lastSent:        "⏱",
 
   // Extension status
-  extensionStatuses:"▦",
+  extensionStatuses:"🧩",
 
   separator:       "|",
 };
@@ -221,6 +234,11 @@ export const TEXT_ICONS: IconSet = {
   hostname:        "HST",
   time:            "TIM",
 
+  tps:             "TPS",
+  clock:           "CLK",
+  duration:        "DUR",
+  thinkingLevel:   "THK",
+
   // Compactor
   sessionEvents:   "EVT",
   compactions:     "CMP",

package/src/rendering/renderer.ts

@@ -7,18 +7,20 @@
  */
 
 import type { Theme } from "@mariozechner/pi-coding-agent";
-import type { PresetDef, FooterSegmentContext, FooterSegment, ColorScheme, RenderedSegment } from "../types.js";
+import type { PresetDef, FooterSegmentContext, FooterSegment, ColorScheme, RenderedSegment, SegmentZone } from "../types.js";
 import type { FooterRegistry } from "../registry/index.js";
 import { visibleWidth as piVisibleWidth, truncateToWidth } from "@mariozechner/pi-tui";
 import { getSeparator, separatorVisibleWidth } from "./separators.js";
 import { getDefaultColors } from "./theme.js";
 import { setIconStyle } from "./icons.js";
 import { getPreset } from "../presets.js";
-import { isSegmentEnabled, loadFooterSettings } from "../config.js";
+import { isSegmentEnabled, isSegmentExplicitlyEnabled, loadFooterSettings } from "../config.js";
 
 /** Segment lookup by ID across all groups */
 interface SegmentLookup {
   get(id: string): FooterSegment | undefined;
+  /** All known segment IDs */
+  allIds(): string[];
 }
 
 /** Rendered segment with width info */
@@ -143,8 +145,8 @@ export class FooterRenderer {
   }
 
   /**
-   * Compute responsive layout for the given width.
-   * Segments that don't fit in the top row overflow to the secondary row.
+   * Compute responsive zone-based layout for the given width.
+   * Segments are grouped by zone (left/center/right) and rendered with alignment.
    */
   computeLayout(width: number): { topContent: string; secondaryContent: string } {
     // Return cached layout if still valid
@@ -155,41 +157,58 @@ export class FooterRenderer {
 
     const presetDef = getPreset(this.presetName);
     const colors = presetDef.colors ?? getDefaultColors();
+    const settings = loadFooterSettings();
+    const labelMode = settings.showFullLabels ? "labeled" as const : "compact" as const;
+
+    // Collect all segment IDs from preset
+    const primaryIds = [...presetDef.leftSegments, ...presetDef.rightSegments];
+    const secondaryIds = [...presetDef.secondarySegments];
+
+    // Also include segments explicitly enabled by user that are NOT in the preset.
+    // This ensures toggling a segment "on" in the settings TUI makes it visible
+    // even when the active preset doesn't include it.
+    if (this.segmentLookup.allIds) {
+      for (const segId of this.segmentLookup.allIds()) {
+        if (primaryIds.includes(segId) || secondaryIds.includes(segId)) continue;
+        const groupId = this.getGroupForSegment(segId);
+        if (isSegmentExplicitlyEnabled(groupId, segId)) {
+          primaryIds.push(segId);
+        }
+      }
+    }
 
-    // Render all segments
-    const allSegmentIds = [
-      ...presetDef.leftSegments,
-      ...presetDef.rightSegments,
-      ...presetDef.secondarySegments,
-    ];
-
-    const renderedSegments: RenderedSegmentWithWidth[] = [];
-    for (const segId of allSegmentIds) {
-      if (!isSegmentEnabled(this.getGroupForSegment(segId), segId)) continue;
+    // Render segments grouped by their zone
+    const zones: Record<SegmentZone, RenderedSegmentWithWidth[]> = {
+      left: [],
+      center: [],
+      right: [],
+    };
+    const overflowZones: Record<SegmentZone, RenderedSegmentWithWidth[]> = {
+      left: [],
+      center: [],
+      right: [],
+    };
 
+    // Render primary segments and group by zone
+    for (const segId of primaryIds) {
+      const rendered = this.renderSegment(segId, colors, width, labelMode);
+      if (!rendered) continue;
       const segment = this.segmentLookup.get(segId);
-      if (!segment) continue;
-
-      const ctx: FooterSegmentContext = {
-        theme: this.getThemeLike(),
-        colors,
-        data: this.registry.getGroupData(this.getGroupForSegment(segId)),
-        width,
-        piContext: this.piContext,
-        footerData: this.footerData,
-      };
-
-      const rendered = segment.render(ctx);
-      if (!rendered.visible || !rendered.content) continue;
-
-      renderedSegments.push({
-        content: rendered.content,
-        width: visibleWidth(rendered.content),
-        visible: true,
-      });
+      const zone = segment?.zone ?? "center";
+      zones[zone].push(rendered);
     }
 
-    if (renderedSegments.length === 0) {
+    // Render secondary segments
+    const secondaryRendered: RenderedSegmentWithWidth[] = [];
+    for (const segId of secondaryIds) {
+      const rendered = this.renderSegment(segId, colors, width, labelMode);
+      if (!rendered) continue;
+      secondaryRendered.push(rendered);
+    }
+
+    // Check if we have any content
+    const totalSegments = zones.left.length + zones.center.length + zones.right.length;
+    if (totalSegments === 0 && secondaryRendered.length === 0) {
       this.lastLayoutResult = { topContent: "", secondaryContent: "" };
       this.lastLayoutWidth = width;
       this.lastLayoutTimestamp = now;
@@ -197,53 +216,70 @@ export class FooterRenderer {
       return this.lastLayoutResult;
     }
 
-    // Separate primary (left+right) from secondary
-    const primaryIds = new Set([...presetDef.leftSegments, ...presetDef.rightSegments]);
-    const primarySegments: RenderedSegmentWithWidth[] = [];
-    const secondarySegments: RenderedSegmentWithWidth[] = [];
-
-    for (const seg of renderedSegments) {
-      // Check if this segment's content matches a primary or secondary segment
-      // We'll do a simpler approach: fit what fits in top row, overflow to secondary
-      primarySegments.push(seg);
+    const sepDef = getSeparator(settings.separator);
+    const sepWidth = visibleWidth(sepDef.left) + 2;
+    const rawZoneSep = presetDef.zoneSeparator ?? settings.zoneSeparator ?? "\u2502";
+    const zoneSepHidden = !rawZoneSep || rawZoneSep === "none";
+    const zoneSep = zoneSepHidden ? "" : rawZoneSep;
+    const zoneSepWidth = zoneSepHidden ? 0 : visibleWidth(zoneSep) + 2; // +2 for spaces around zone sep
+    const dimZoneSep = zoneSepHidden ? "" : `\x1b[2m${zoneSep}\x1b[0m`; // dimmed zone separator
+
+    // Calculate widths per zone
+    const leftWidth = this.measureZoneWidth(zones.left, sepWidth);
+    const rightWidth = this.measureZoneWidth(zones.right, sepWidth);
+    const numZoneSeps = (leftWidth > 0 ? 1 : 0) + (rightWidth > 0 ? 1 : 0);
+    const availableForCenter = width - leftWidth - rightWidth - numZoneSeps * zoneSepWidth - 2; // -2 for margins
+
+    // Progressive segment dropping: if left + right already exceed width,
+    // drop right-zone segments from the end until they fit.
+    const marginWidth = 2; // leading + trailing space
+    let adjustedRightWidth = rightWidth;
+    while (zones.right.length > 0 && leftWidth + adjustedRightWidth + marginWidth > width) {
+      const dropped = zones.right.pop()!;
+      adjustedRightWidth = this.measureZoneWidth(zones.right, sepWidth);
+      overflowZones.right.push(dropped);
     }
-
-    // Compute responsive layout
-    const sepDef = getSeparator(presetDef.separator);
-    const sepWidth = visibleWidth(sepDef.left) + 2; // separator + spaces
-
-    const baseOverhead = 2; // leading + trailing space
-    let currentWidth = baseOverhead;
-    let topParts: string[] = [];
-    let overflowParts: RenderedSegmentWithWidth[] = [];
-    let overflow = false;
-
-    for (const seg of primarySegments) {
-      const needed = seg.width + (topParts.length > 0 ? sepWidth : 0);
-      if (!overflow && currentWidth + needed <= width) {
-        topParts.push(seg.content);
-        currentWidth += needed;
-      } else {
-        overflow = true;
-        overflowParts.push(seg);
-      }
+    // If left zone alone exceeds width, drop segments from the end until it fits.
+    let adjustedLeftWidth = leftWidth;
+    while (zones.left.length > 1 && adjustedLeftWidth + marginWidth > width) {
+      const dropped = zones.left.pop()!;
+      adjustedLeftWidth = this.measureZoneWidth(zones.left, sepWidth);
+      overflowZones.left.push(dropped);
     }
-
-    // Fit overflow into secondary row
-    let secondaryWidth = baseOverhead;
-    let secondaryParts: string[] = [];
-    for (const seg of overflowParts) {
-      const needed = seg.width + (secondaryParts.length > 0 ? sepWidth : 0);
-      if (secondaryWidth + needed <= width) {
-        secondaryParts.push(seg.content);
-        secondaryWidth += needed;
-      } else {
-        break; // Stop at first non-fitting segment
+    // Recalculate available center after possible right-zone dropping
+    const adjLeftWidth = zones.left.length > 0 ? this.measureZoneWidth(zones.left, sepWidth) : 0;
+    const adjNumZoneSeps = (zones.left.length > 0 ? 1 : 0) + (zones.right.length > 0 ? 1 : 0);
+    const adjAvailableForCenter = width - adjLeftWidth - adjustedRightWidth - adjNumZoneSeps * zoneSepWidth - marginWidth;
+
+    // Overflow check: if center doesn't fit, move excess to overflow
+    const centerWidth = this.measureZoneWidth(zones.center, sepWidth);
+    if (centerWidth > Math.max(0, adjAvailableForCenter)) {
+      // Move overflow center segments to secondary
+      let fitWidth = 0;
+      let cutoffIdx = 0;
+      for (let i = 0; i < zones.center.length; i++) {
+        const needed = zones.center[i].width + (i > 0 ? sepWidth : 0);
+        if (fitWidth + needed <= Math.max(0, adjAvailableForCenter)) {
+          fitWidth += needed;
+          cutoffIdx = i + 1;
+        } else {
+          break;
+        }
       }
+      const overflow = zones.center.splice(cutoffIdx);
+      overflowZones.center.push(...overflow);
     }
 
-    const topContent = this.buildContentFromParts(topParts, sepDef);
-    const secondaryContent = this.buildContentFromParts(secondaryParts, sepDef);
+    // Build top row with zones
+    const topContent = this.buildZoneRow(zones, width, sepDef, dimZoneSep);
+
+    // Build secondary row with overflow + preset secondary segments
+    const allSecondary = [...overflowZones.left, ...overflowZones.center, ...overflowZones.right, ...secondaryRendered];
+    const secondaryContent = this.buildContentFromParts(
+      allSecondary.map(s => s.content),
+      sepDef,
+      width,
+    );
 
     this.lastLayoutResult = { topContent, secondaryContent };
     this.lastLayoutWidth = width;
@@ -253,23 +289,153 @@ export class FooterRenderer {
     return this.lastLayoutResult;
   }
 
+  /** Render a single segment by ID, returns null if not visible */
+  private renderSegment(
+    segId: string,
+    colors: ColorScheme,
+    fullWidth: number,
+    labelMode: "compact" | "labeled",
+  ): RenderedSegmentWithWidth | null {
+    if (!isSegmentEnabled(this.getGroupForSegment(segId), segId)) return null;
+
+    const segment = this.segmentLookup.get(segId);
+    if (!segment) return null;
+
+    const ctx: FooterSegmentContext = {
+      theme: this.getThemeLike(),
+      colors,
+      data: this.registry.getGroupData(this.getGroupForSegment(segId)),
+      width: fullWidth,
+      piContext: this.piContext,
+      footerData: this.footerData,
+      labelMode,
+    };
+
+    const rendered = segment.render(ctx);
+    if (!rendered.visible || !rendered.content) return null;
+
+    return {
+      content: rendered.content,
+      width: visibleWidth(rendered.content),
+      visible: true,
+    };
+  }
+
+  /** Measure total width of a zone's rendered segments */
+  private measureZoneWidth(segments: RenderedSegmentWithWidth[], sepWidth: number): number {
+    if (segments.length === 0) return 0;
+    let total = 0;
+    for (let i = 0; i < segments.length; i++) {
+      total += segments[i].width + (i > 0 ? sepWidth : 0);
+    }
+    return total;
+  }
+
+  /** Build a zone-based row string */
+  private buildZoneRow(
+    zones: Record<SegmentZone, RenderedSegmentWithWidth[]>,
+    fullWidth: number,
+    sepDef: { left: string },
+    dimZoneSep: string,
+  ): string {
+    const parts: string[] = [];
+
+    // Left zone
+    const leftContent = this.buildContentFromPartsRaw(
+      zones.left.map(s => s.content),
+      sepDef,
+    );
+
+    // Center zone
+    const centerContent = this.buildContentFromPartsRaw(
+      zones.center.map(s => s.content),
+      sepDef,
+    );
+
+    // Right zone
+    const rightContent = this.buildContentFromPartsRaw(
+      zones.right.map(s => s.content),
+      sepDef,
+    );
+
+    // Assemble zones with alignment
+    const leftWidth = zones.left.length > 0 ? this.measureZoneWidth(zones.left, visibleWidth(sepDef.left) + 2) : 0;
+    const rightWidth = zones.right.length > 0 ? this.measureZoneWidth(zones.right, visibleWidth(sepDef.left) + 2) : 0;
+
+    // Simple case: no zones → return empty
+    if (!leftContent && !centerContent && !rightContent) return "";
+
+    // Build with zone separators
+    let result = " "; // leading margin
+
+    if (leftContent) {
+      result += leftContent;
+    }
+
+    if (centerContent) {
+      if (leftContent && dimZoneSep) result += ` ${dimZoneSep} `;
+      result += centerContent;
+    }
+
+    if (rightContent) {
+      const currentLen = visibleWidth(result);
+      const rightStart = fullWidth - rightWidth - 1; // -1 for trailing margin
+      const gap = rightStart - currentLen;
+
+      if (gap > 0) {
+        // Pad to right-align the right zone
+        result += " ".repeat(gap);
+      }
+
+      // If gap is negative, right zone doesn't fit — skip it to prevent overflow.
+      // truncateToWidth below is the safety net for any remaining excess.
+      if (gap > visibleWidth(dimZoneSep) + 2) {
+        // Enough room for zone separator aesthetic
+      }
+
+      // Only append right zone if it fits within terminal width
+      if (gap >= 0) {
+        result += rightContent;
+      }
+    }
+
+    result += " "; // trailing margin
+
+    // Safety net: never exceed terminal width
+    return truncateToWidth(result, fullWidth);
+  }
+
+  /** Build content from parts array (raw strings) */
+  private buildContentFromPartsRaw(parts: string[], sepDef: { left: string }): string {
+    if (parts.length === 0) return "";
+    const sep = sepDef.left;
+    const sepAnsi = getFgAnsiCode(getPreset(this.presetName).colors ?? getDefaultColors(), "separator");
+    return parts.join(` ${sepAnsi}${sep}${ANSI_RESET} `);
+  }
+
   // ─── Helpers ─────────────────────────────────────────────────────────────
 
-  private buildContentFromParts(parts: string[], sepDef: { left: string }): string {
+  private buildContentFromParts(parts: string[], sepDef: { left: string }, maxWidth?: number): string {
     if (parts.length === 0) return "";
     const sep = sepDef.left;
     const sepAnsi = getFgAnsiCode(getPreset(this.presetName).colors ?? getDefaultColors(), "separator");
-    return " " + parts.join(` ${sepAnsi}${sep}${ANSI_RESET} `) + ANSI_RESET + " ";
+    const result = " " + parts.join(` ${sepAnsi}${sep}${ANSI_RESET} `) + ANSI_RESET + " ";
+    // Safety net: never exceed maxWidth if provided
+    if (maxWidth != null && maxWidth > 0) {
+      return truncateToWidth(result, maxWidth);
+    }
+    // If no maxWidth, truncate to a reasonable default to prevent unbounded output
+    return truncateToWidth(result, 200);
   }
 
   /** Map a segment ID to its group ID */
   private getGroupForSegment(segId: string): string {
     // Core segments
-    const coreIds = ["model", "api_state", "tool_count", "git", "context_pct", "cost", "tokens_total", "tokens_in", "tokens_out", "session", "hostname", "time"];
+    const coreIds = ["model", "api_state", "tool_count", "git", "context_pct", "cost", "tokens_total", "tokens_in", "tokens_out", "session", "hostname", "time", "tps", "clock", "duration", "thinking_level"];
     if (coreIds.includes(segId)) return "core";
 
     // Compactor segments
-    const compactorIds = ["session_events", "compactions", "tokens_saved", "compression_ratio", "indexed_docs", "sandbox_runs", "search_queries"];
+    const compactorIds = ["session_events", "compactions", "tokens_saved", "compression_ratio", "cocoindex_status", "sandbox_runs", "search_queries"];
     if (compactorIds.includes(segId)) return "compactor";
 
     // Memory segments