@openlines/opl-pi-sht 0.2.11 → 0.3.0

package/extensions/opl-footer/index.ts

@@ -11,7 +11,7 @@ import { getGitStatus, invalidateGitStatus, invalidateGitBranch } from "./git-st
 import { getEffectiveConfig } from "./config.js";
 import { getIcons } from "./icons.js";
 import { getDefaultColors, fg } from "./theme.js";
-import { showFooterConfigurator } from "./configure.js";
+import { registerFooterConfiguratorTab } from "./configure.js";
 import { fetchCodexUsage, refreshCodexUsageSnapshot, type CodexUsageSnapshot } from "./codex-usage.js";
 import { fetchOpenRouterUsage, refreshOpenRouterUsageSnapshot, type OpenRouterUsageSnapshot } from "./openrouter-usage.js";
 
@@ -21,6 +21,15 @@ const GIT_BRANCH_PATTERNS: RegExp[] = [
   /\bgit\s+stash\s+(pop|apply)/,
 ];
 
+/**
+ * Only a real string is inspected. A tool call over the wire can carry an array or object
+ * in `input.command`, and `String()` of it is either "[object Object]" (no match, stale
+ * counts) or a joined "git checkout main" that matches by accident.
+ */
+export function mentionsGitBranchChange(command: unknown): boolean {
+  return typeof command === "string" && GIT_BRANCH_PATTERNS.some((pattern) => pattern.test(command));
+}
+
 /** Row keys used to detect whether an optional segment is enabled. */
 const CODEX_USAGE_REFRESH_MS = 30_000;
 
@@ -37,12 +46,109 @@ const LAYOUT_ROWS = [
 // Status Line Builder
 // ═══════════════════════════════════════════════════════════════════════════
 
+const isAssistantMessageEvent = (e: SessionEvent): e is AssistantMessageEvent =>
+  e.type === "message" && (e as AssistantMessageEvent).message.role === "assistant";
+
+const isThinkingEvent = (e: SessionEvent): e is ThinkingLevelEvent =>
+  e.type === "thinking_level_change";
+
+/**
+ * Branch-derived footer inputs. Every field is a pass over the whole branch and the
+ * footer re-renders on each keypress, so they are memoised by session, leaf, branch
+ * length, context window and whether canonical usage needs an estimate.
+ */
+export interface BranchFacts {
+  key: string;
+  usageStats: UsageStats;
+  thinkingLevelFromSession: string | null;
+  estimatedContextUsage: { tokens: number; percent: number } | null;
+  branchPrompts: number;
+  branchCompactions: number;
+  branchApiCalls: number;
+  branchToolCalls: number;
+}
+
+function emptyBranchFacts(key: string): BranchFacts {
+  return {
+    key,
+    usageStats: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 },
+    thinkingLevelFromSession: null,
+    estimatedContextUsage: null,
+    branchPrompts: 0,
+    branchCompactions: 0,
+    branchApiCalls: 0,
+    branchToolCalls: 0,
+  };
+}
+
+export function deriveBranchFacts(
+  branch: SessionEvent[],
+  key: string,
+  opts: {
+    contextWindow: number;
+    needsEstimate: boolean;
+    projectedMessages: Parameters<typeof estimateContextUsage>[0] | undefined;
+  },
+): BranchFacts {
+  const completedMessages = branch
+    .filter(isAssistantMessageEvent)
+    .map((e) => e.message as AssistantMessage)
+    .filter((m) => m.stopReason !== "error" && m.stopReason !== "aborted");
+  // Session entries are host data: a missing usage block reads as zero instead of
+  // throwing and blanking every row.
+  const usageStats = completedMessages.reduce<UsageStats>(
+    (acc, m) => {
+      const u = (m.usage ?? {}) as unknown as Partial<UsageStats> & { cost?: { total?: number } };
+      return {
+        input: acc.input + (u.input ?? 0),
+        output: acc.output + (u.output ?? 0),
+        cacheRead: acc.cacheRead + (u.cacheRead ?? 0),
+        cacheWrite: acc.cacheWrite + (u.cacheWrite ?? 0),
+        cost: acc.cost + (u.cost?.total ?? 0),
+      };
+    },
+    { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 },
+  );
+  const thinkingEvents = branch.filter(isThinkingEvent);
+  return {
+    key,
+    usageStats,
+    // Seed null, not "off": a truthy seed made the ?? fallback unreachable, so a branch
+    // with no thinking_level_change entry rendered "off" instead of Pi's real level.
+    thinkingLevelFromSession: thinkingEvents.length
+      ? thinkingEvents.reduce((_, e) => e.thinkingLevel ?? "off", "off")
+      : null,
+    estimatedContextUsage:
+      opts.needsEstimate && opts.contextWindow > 0 && opts.projectedMessages
+        ? estimateContextUsage(opts.projectedMessages, opts.contextWindow)
+        : null,
+    // Prompt/API/tool counts are reconstructed from the branch so they survive quit/resume.
+    // Timing stats (llmMs, toolMs, ttftSamples) are ephemeral — not stored in messages.
+    branchPrompts: branch.filter(
+      (e) => e.type === "message" && (e as AssistantMessageEvent).message?.role === "user",
+    ).length,
+    branchCompactions: branch.filter((entry) => entry.type === "compaction").length,
+    branchApiCalls: completedMessages.length,
+    branchToolCalls: completedMessages.reduce((sum, msg) => {
+      const content = (msg as { content?: unknown }).content;
+      return sum + (Array.isArray(content) ? content.filter((block) => (block as any)?.type === "toolCall").length : 0);
+    }, 0),
+  };
+}
+
 /** Render a single segment and return its content with width */
 function renderSegmentWithWidth(
   segId: StatusLineSegmentId,
   ctx: SegmentContext
 ): { content: string; width: number; visible: boolean } {
-  const rendered = renderSegment(segId, ctx);
+  let rendered;
+  try {
+    rendered = renderSegment(segId, ctx);
+  } catch {
+    // One throwing segment used to blank the whole footer on every frame. Show a
+    // marker in its place so the failure is visible and the rest still renders.
+    return { content: "[?]", width: 3, visible: true };
+  }
   if (!rendered.visible || !rendered.content) {
     return { content: "", width: 0, visible: false };
   }
@@ -58,7 +164,7 @@ function buildFooterContent(
   leftSegments: StatusLineSegmentId[],
   rightSegments: StatusLineSegmentId[],
   availableWidth: number,
-): string {
+): { text: string; visible: boolean } {
   const maxContentWidth = Math.max(0, availableWidth - 2);
 
   // Render left segments
@@ -87,15 +193,25 @@ function buildFooterContent(
   let leftStr = leftParts.join(" ");
   let rightStr = rightParts.join(" ");
 
+  // A row whose segments are all disabled is not padding: report it as invisible so
+  // render() can drop the line and its divider instead of charging the terminal a
+  // fixed six-line footer.
+  if (leftParts.length === 0 && rightParts.length === 0) {
+    return { text: "", visible: false };
+  }
+
   // Handle case with no right segments
   if (rightParts.length === 0) {
     const finalLeft = truncateToWidth(leftStr, maxContentWidth);
-    return " " + finalLeft + " ".repeat(Math.max(0, maxContentWidth - visibleWidth(finalLeft))) + " ";
+    return {
+      text: " " + finalLeft + " ".repeat(Math.max(0, maxContentWidth - visibleWidth(finalLeft))) + " ",
+      visible: true,
+    };
   }
 
   // If right side alone is too big, just show right side
   if (rightWidth >= maxContentWidth) {
-    return " " + truncateToWidth(rightStr, maxContentWidth) + " ";
+    return { text: " " + truncateToWidth(rightStr, maxContentWidth) + " ", visible: true };
   }
 
   // Ensure at least 1 space between left and right
@@ -106,7 +222,7 @@ function buildFooterContent(
   const padding = maxContentWidth - finalLeftWidth - rightWidth;
 
   const result = " " + finalLeft + " ".repeat(padding) + rightStr + " ";
-  return truncateToWidth(result, availableWidth);
+  return { text: truncateToWidth(result, availableWidth), visible: true };
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -117,21 +233,39 @@ export default function footer(pi: ExtensionAPI) {
   let sessionStartTime = Date.now();
   let currentCtx: ExtensionContext | null = null;
   let footerDataRef: ReadonlyFooterDataProvider | null = null;
-  let lastBranchLength = 0;
-  let cachedUsageStats: UsageStats | null = null;
+  // Every field below is a pass over the whole branch. The footer re-renders on each
+  // keypress, so unchanged branch identities reuse the derived inputs instead.
+  let branchFacts: BranchFacts | null = null;
   let tuiRef: TUI | null = null;
   let codexUsage: CodexUsageSnapshot | null = null;
   let codexUsageLastAttempt = 0;
   let codexUsageGeneration = 0;
   let codexUsageInFlight: Promise<void> | null = null;
+  let codexUsageTimer: ReturnType<typeof setTimeout> | null = null;
+  let codexUsagePendingCtx: ExtensionContext | null = null;
+
+  const cancelCodexUsageRefresh = () => {
+    if (codexUsageTimer !== null) clearTimeout(codexUsageTimer);
+    codexUsageTimer = null;
+    codexUsagePendingCtx = null;
+  };
   let openRouterUsage: OpenRouterUsageSnapshot | null = null;
   let openRouterUsageLastAttempt = 0;
   let openRouterUsageGeneration = 0;
   let openRouterUsageInFlight: Promise<void> | null = null;
+  let openRouterUsageTimer: ReturnType<typeof setTimeout> | null = null;
+  let openRouterUsagePendingCtx: ExtensionContext | null = null;
+
+  const cancelOpenRouterUsageRefresh = () => {
+    if (openRouterUsageTimer !== null) clearTimeout(openRouterUsageTimer);
+    openRouterUsageTimer = null;
+    openRouterUsagePendingCtx = null;
+  };
 
   const refreshOpenRouterUsage = (ctx: ExtensionContext, force = false): Promise<void> => {
     const isOpenRouter = ctx.model?.provider === "openrouter";
     if (!isOpenRouter) {
+      cancelOpenRouterUsageRefresh();
       openRouterUsageGeneration++;
       openRouterUsageInFlight = null;
       openRouterUsage = null;
@@ -142,6 +276,7 @@ export default function footer(pi: ExtensionAPI) {
     const config = getEffectiveConfig();
     const enabled = LAYOUT_ROWS.some((row) => config[row]?.includes("openrouter_usage"));
     if (!enabled) {
+      cancelOpenRouterUsageRefresh();
       openRouterUsageGeneration++;
       openRouterUsageInFlight = null;
       openRouterUsage = null;
@@ -149,10 +284,23 @@ export default function footer(pi: ExtensionAPI) {
       tuiRef?.requestRender();
       return Promise.resolve();
     }
-    if (openRouterUsageInFlight) return openRouterUsageInFlight;
+    if (openRouterUsageInFlight) {
+      openRouterUsagePendingCtx = ctx;
+      return openRouterUsageInFlight;
+    }
 
     const now = Date.now();
-    if (!force && now - openRouterUsageLastAttempt < CODEX_USAGE_REFRESH_MS) return Promise.resolve();
+    const remaining = CODEX_USAGE_REFRESH_MS - (now - openRouterUsageLastAttempt);
+    if (!force && remaining > 0) {
+      if (openRouterUsageTimer === null) {
+        openRouterUsageTimer = setTimeout(() => {
+          openRouterUsageTimer = null;
+          void refreshOpenRouterUsage(ctx);
+        }, remaining);
+      }
+      return Promise.resolve();
+    }
+    cancelOpenRouterUsageRefresh();
     openRouterUsageLastAttempt = now;
     const generation = ++openRouterUsageGeneration;
 
@@ -165,6 +313,10 @@ export default function footer(pi: ExtensionAPI) {
       })
       .finally(() => {
         if (openRouterUsageInFlight === request) openRouterUsageInFlight = null;
+        if (generation !== openRouterUsageGeneration) return;
+        const pendingCtx = openRouterUsagePendingCtx;
+        openRouterUsagePendingCtx = null;
+        if (pendingCtx) void refreshOpenRouterUsage(pendingCtx);
       });
     openRouterUsageInFlight = request;
     return request;
@@ -174,6 +326,7 @@ export default function footer(pi: ExtensionAPI) {
     const model = ctx.model;
     const isCodexSubscription = model?.provider === "openai-codex" && ctx.modelRegistry.isUsingOAuth(model);
     if (!isCodexSubscription) {
+      cancelCodexUsageRefresh();
       codexUsageGeneration++;
       codexUsageInFlight = null;
       codexUsage = null;
@@ -184,6 +337,7 @@ export default function footer(pi: ExtensionAPI) {
     const config = getEffectiveConfig();
     const enabled = LAYOUT_ROWS.some((row) => config[row]?.includes("codex_usage"));
     if (!enabled) {
+      cancelCodexUsageRefresh();
       codexUsageGeneration++;
       codexUsageInFlight = null;
       codexUsage = null;
@@ -191,10 +345,23 @@ export default function footer(pi: ExtensionAPI) {
       tuiRef?.requestRender();
       return Promise.resolve();
     }
-    if (codexUsageInFlight) return codexUsageInFlight;
+    if (codexUsageInFlight) {
+      codexUsagePendingCtx = ctx;
+      return codexUsageInFlight;
+    }
 
     const now = Date.now();
-    if (!force && now - codexUsageLastAttempt < CODEX_USAGE_REFRESH_MS) return Promise.resolve();
+    const remaining = CODEX_USAGE_REFRESH_MS - (now - codexUsageLastAttempt);
+    if (!force && remaining > 0) {
+      if (codexUsageTimer === null) {
+        codexUsageTimer = setTimeout(() => {
+          codexUsageTimer = null;
+          void refreshCodexUsage(ctx);
+        }, remaining);
+      }
+      return Promise.resolve();
+    }
+    cancelCodexUsageRefresh();
     codexUsageLastAttempt = now;
     const generation = ++codexUsageGeneration;
 
@@ -207,6 +374,10 @@ export default function footer(pi: ExtensionAPI) {
       })
       .finally(() => {
         if (codexUsageInFlight === request) codexUsageInFlight = null;
+        if (generation !== codexUsageGeneration) return;
+        const pendingCtx = codexUsagePendingCtx;
+        codexUsagePendingCtx = null;
+        if (pendingCtx) void refreshCodexUsage(pendingCtx);
       });
     codexUsageInFlight = request;
     return request;
@@ -224,27 +395,26 @@ export default function footer(pi: ExtensionAPI) {
   let statusTracker = createAgentStatusTracker();
   const toolStartTimes = new Map<string, number>();
 
-  pi.registerCommand("configure-opl", {
-    description: "Interactively configure the OPL footer layout",
-    handler: async (_args, ctx) => {
-      await showFooterConfigurator(ctx, () => {
-        tuiRef?.requestRender();
-        void refreshCodexUsage(ctx, true);
-        void refreshOpenRouterUsage(ctx, true);
-      });
-    },
+  // The footer exposes itself to opl-configurator's generic tabbed shell; the shell owns
+  // the /configurator command, so a session that reloads the config from another tab still
+  // re-renders the footer and refreshes quota usage here.
+  registerFooterConfiguratorTab((ctx) => {
+    tuiRef?.requestRender();
+    void refreshCodexUsage(ctx, true);
+    void refreshOpenRouterUsage(ctx, true);
   });
 
   // Track session start
   pi.on("session_start", async (_event: unknown, ctx: ExtensionContext) => {
     sessionStartTime = Date.now();
     currentCtx = ctx;
-    lastBranchLength = 0;
-    cachedUsageStats = null;
+    branchFacts = null;
+    cancelCodexUsageRefresh();
     codexUsage = null;
     codexUsageLastAttempt = 0;
     codexUsageGeneration++;
     codexUsageInFlight = null;
+    cancelOpenRouterUsageRefresh();
     openRouterUsage = null;
     openRouterUsageLastAttempt = 0;
     openRouterUsageGeneration++;
@@ -267,6 +437,34 @@ export default function footer(pi: ExtensionAPI) {
     }
   });
 
+  pi.on("session_shutdown", async () => {
+    branchFacts = null;
+    cancelCodexUsageRefresh();
+    codexUsageGeneration++;
+    codexUsageInFlight = null;
+    cancelOpenRouterUsageRefresh();
+    openRouterUsageGeneration++;
+    openRouterUsageInFlight = null;
+    // The seam is a closure over this session's TUI. Leaving it installed hands `opl-modes`
+    // a dead component to render into on the next session, so it goes with the footer.
+    delete (globalThis as Record<string, unknown>).__footerRequestRender;
+  });
+
+  const invalidateBranchFacts = (_event: unknown, ctx: ExtensionContext) => {
+    currentCtx = ctx;
+    branchFacts = null;
+    tuiRef?.requestRender();
+  };
+  pi.on("session_tree", invalidateBranchFacts);
+  pi.on("session_compact", invalidateBranchFacts);
+
+  pi.on("message_end", async (event, ctx) => {
+    if (event.message.role === "assistant") {
+      void refreshCodexUsage(ctx);
+      void refreshOpenRouterUsage(ctx);
+    }
+  });
+
   pi.on("model_select", async (_event: unknown, ctx: ExtensionContext) => {
     void refreshCodexUsage(ctx, true);
     void refreshOpenRouterUsage(ctx, true);
@@ -320,6 +518,8 @@ export default function footer(pi: ExtensionAPI) {
     }
     statusTracker.toolEnded(event.toolCallId);
     tuiRef?.requestRender();
+    void refreshCodexUsage(_ctx);
+    void refreshOpenRouterUsage(_ctx);
   });
 
   pi.on("message_update", async (_event: unknown, _ctx: ExtensionContext) => {
@@ -334,19 +534,16 @@ export default function footer(pi: ExtensionAPI) {
     if (event.toolName === "write" || event.toolName === "edit") {
       invalidateGitStatus();
     }
-    if (event.toolName === "bash" && event.input?.command) {
-      const cmd = String(event.input.command);
-      if (GIT_BRANCH_PATTERNS.some(p => p.test(cmd))) {
-        invalidateGitStatus();
-        invalidateGitBranch();
-        setTimeout(() => tuiRef?.requestRender(), 100);
-      }
+    if (event.toolName === "bash" && mentionsGitBranchChange(event.input?.command)) {
+      invalidateGitStatus();
+      invalidateGitBranch();
+      setTimeout(() => tuiRef?.requestRender(), 100);
     }
   });
 
   // Also catch user escape commands (! prefix)
   pi.on("user_bash", async (event: UserBashEvent, _ctx: ExtensionContext) => {
-    if (GIT_BRANCH_PATTERNS.some(p => p.test(event.command))) {
+    if (mentionsGitBranchChange(event.command)) {
       invalidateGitStatus();
       invalidateGitBranch();
       tuiRef?.requestRender();
@@ -358,53 +555,38 @@ export default function footer(pi: ExtensionAPI) {
     const colors = effectiveConfig.colors ?? getDefaultColors();
 
     const branch = (ctx.sessionManager?.getBranch?.() ?? []) as SessionEvent[];
-    const branchLen = branch.length;
-
-    const isAssistantMessageEvent = (e: SessionEvent): e is AssistantMessageEvent =>
-      e.type === "message" && (e as AssistantMessageEvent).message.role === "assistant";
-    const completedMessages = branch
-      .filter(isAssistantMessageEvent)
-      .map(e => e.message as AssistantMessage)
-      .filter(m => m.stopReason !== "error" && m.stopReason !== "aborted");
-
-    // Cache usageStats — only recompute when branch grows
-    let usageStats: UsageStats;
-    if (cachedUsageStats && branchLen === lastBranchLength) {
-      usageStats = cachedUsageStats;
-    } else {
-      usageStats = completedMessages.reduce<UsageStats>(
-        (acc, m) => ({
-          input: acc.input + m.usage.input,
-          output: acc.output + m.usage.output,
-          cacheRead: acc.cacheRead + m.usage.cacheRead,
-          cacheWrite: acc.cacheWrite + m.usage.cacheWrite,
-          cost: acc.cost + m.usage.cost.total,
-        }),
-        { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 },
-      );
-      cachedUsageStats = usageStats;
-      lastBranchLength = branchLen;
-    }
-
-    const isThinkingEvent = (e: SessionEvent): e is ThinkingLevelEvent =>
-      e.type === "thinking_level_change";
-    const thinkingEvents = branch.filter(isThinkingEvent);
-    // Seed null, not "off": a truthy seed made the ?? fallback below unreachable, so a
-    // branch with no thinking_level_change entry rendered "off" instead of Pi's real level.
-    const thinkingLevelFromSession = thinkingEvents.length
-      ? thinkingEvents.reduce((_, e) => e.thinkingLevel ?? "off", "off")
-      : null;
 
     // Prefer Pi's canonical context usage (0.87). Immediately after compaction it is
     // null until the next assistant reply, so estimate the rebuilt projection instead.
     const usage = typeof ctx.getContextUsage === "function" ? ctx.getContextUsage() : undefined;
     const contextWindow = usage?.contextWindow ?? ctx.model?.contextWindow ?? 0;
-    const projectedMessages = ctx.sessionManager?.buildSessionProjection?.().messages;
-    const estimatedContextUsage = usage?.percent === null && contextWindow > 0 && projectedMessages
-      ? estimateContextUsage(projectedMessages, contextWindow)
-      : null;
-    const contextPercent = usage?.percent ?? estimatedContextUsage?.percent ?? null;
-    const contextEstimated = estimatedContextUsage !== null;
+
+    const needsEstimate = usage?.percent === null;
+    const factsKey = JSON.stringify([
+      ctx.sessionManager?.getSessionId?.(), ctx.sessionManager?.getLeafId?.(),
+      branch.length, contextWindow, needsEstimate,
+    ]);
+    let facts = branchFacts;
+    if (!facts || facts.key !== factsKey) {
+      const projectedMessages = needsEstimate
+        ? ctx.sessionManager?.buildSessionProjection?.().messages
+        : undefined;
+      try {
+        facts = deriveBranchFacts(branch, factsKey, {
+          contextWindow,
+          needsEstimate,
+          projectedMessages,
+        });
+      } catch {
+        // The transcript is host data: an unexpected entry should degrade the cells that
+        // read it, not throw and blank every row.
+        facts = emptyBranchFacts(factsKey);
+      }
+      branchFacts = facts;
+    }
+
+    const contextPercent = usage?.percent ?? facts.estimatedContextUsage?.percent ?? null;
+    const contextEstimated = needsEstimate && facts.estimatedContextUsage !== null;
 
     // Get git status (cached). Skip the probes entirely when no visible row renders the
     // git segment — otherwise an unused cell keeps spawning git once per second.
@@ -423,37 +605,36 @@ export default function footer(pi: ExtensionAPI) {
     // This allows litellm proxy to correctly separate local vs cloud models
     const isLocalModel = ctx.model?.id?.startsWith?.("local.") ?? false;
 
-    // Reconstruct prompt/API-call/tool-call counts from the branch so they survive quit/resume.
-    // Timing stats (llmMs, toolMs, ttftSamples) are ephemeral — not stored in messages.
-    const branchPrompts = branch.filter(
-      (e) => e.type === "message" && (e as AssistantMessageEvent).message?.role === "user",
-    ).length;
-    const branchApiCalls = completedMessages.length;
-
-    // Count tool calls from assistant message content
-    const branchToolCalls = completedMessages.reduce((sum, msg) => {
-      const content = (msg as any).content || [];
-      return sum + content.filter((block: any) => block?.type === "toolCall").length;
-    }, 0);
-
     return {
       model: ctx.model,
       isLocalModel,
-      thinkingLevel: thinkingLevelFromSession ?? pi.getThinkingLevel(),
+      thinkingLevel: facts.thinkingLevelFromSession ?? pi.getThinkingLevel(),
       sessionId: ctx.sessionManager?.getSessionId?.(),
-      usageStats,
+      usageStats: facts.usageStats,
       contextPercent,
       contextEstimated,
       contextWindow,
       usingSubscription,
       sessionStartTime,
+      // The session directory, not the directory the harness was launched from: a session opened
+      // elsewhere must show that project's path.
+      cwd: ctx.cwd || process.cwd(),
       git: gitStatus,
       options: effectiveConfig.segmentOptions ?? {},
       width,
       theme,
       colors,
       icons: getIcons(effectiveConfig.icons),
-      sessionStats: { prompts: branchPrompts, apiCalls: branchApiCalls, toolCalls: branchToolCalls, llmMs, toolMs, ttftSamples, lastTurnaroundMs },
+      sessionStats: {
+        prompts: facts.branchPrompts,
+        apiCalls: facts.branchApiCalls,
+        toolCalls: facts.branchToolCalls,
+        llmMs,
+        toolMs,
+        ttftSamples,
+        lastTurnaroundMs,
+      },
+      compactions: facts.branchCompactions,
       agentStatus: statusTracker.status(),
       codexUsage,
       openRouterUsage,
@@ -485,28 +666,25 @@ export default function footer(pi: ExtensionAPI) {
             return [];
           }
 
-          const row1 = buildFooterContent(
-            segmentCtx,
-            effectiveConfig.row1LeftSegments,
-            effectiveConfig.row1RightSegments,
-            width,
-          );
-          const row2 = buildFooterContent(
-            segmentCtx,
-            effectiveConfig.row2LeftSegments,
-            effectiveConfig.row2RightSegments,
-            width,
-          );
-          const row3 = buildFooterContent(
-            segmentCtx,
-            effectiveConfig.row3LeftSegments,
-            effectiveConfig.row3RightSegments,
-            width,
-          );
+          const rowSpecs: Array<[StatusLineSegmentId[], StatusLineSegmentId[]]> = [
+            [effectiveConfig.row1LeftSegments, effectiveConfig.row1RightSegments],
+            [effectiveConfig.row2LeftSegments, effectiveConfig.row2RightSegments],
+            [effectiveConfig.row3LeftSegments, effectiveConfig.row3RightSegments],
+          ];
+          const rows = rowSpecs
+            .map(([left, right]) => buildFooterContent(segmentCtx, left, right, width))
+            .filter((row) => row.visible);
+          if (rows.length === 0) return [];
 
           const divider = fg(theme, "separator", "─".repeat(width), segmentCtx.colors);
-
-          return ["", row1, divider, row2, divider, row3];
+          // The leading blank keeps the transcript off the first footer line. Dividers
+          // only go between rows that exist, so a one-row layout costs two lines, not six.
+          const lines: string[] = [""];
+          rows.forEach((row, index) => {
+            if (index > 0) lines.push(divider);
+            lines.push(row.text);
+          });
+          return lines;
         },
       };
     });

package/extensions/opl-footer/segments/caveman.ts

@@ -7,8 +7,16 @@ interface CavemanState {
   mode: string;
 }
 
+/**
+ * Nothing in this collection writes `__caveman` - a standalone extension does - so the shape
+ * is validated instead of cast: `mode.toUpperCase()` is a crash on a number, and a footer
+ * that throws takes every row down with it.
+ */
 function readCavemanState(): CavemanState | undefined {
-  return (globalThis as Record<string, unknown>).__caveman as CavemanState | undefined;
+  const state = (globalThis as Record<string, unknown>).__caveman as unknown;
+  if (!state || typeof state !== "object") return undefined;
+  const { enabled, mode } = state as { enabled?: unknown; mode?: unknown };
+  return typeof enabled === "boolean" && typeof mode === "string" ? { enabled, mode } : undefined;
 }
 
 export const cavemanSegment = {

package/extensions/opl-footer/segments/chat-mode.ts

@@ -6,8 +6,15 @@ interface ChatModeState {
   mode: string;
 }
 
+/**
+ * Written by `opl-modes`, which may not be installed. Only a `{ mode: string }` is honoured;
+ * anything else reads as "no state", so the segment stays invisible instead of throwing.
+ */
 function readChatModeState(): ChatModeState | undefined {
-  return (globalThis as Record<string, unknown>).__chatMode as ChatModeState | undefined;
+  const state = (globalThis as Record<string, unknown>).__chatMode as unknown;
+  if (!state || typeof state !== "object") return undefined;
+  const mode = (state as { mode?: unknown }).mode;
+  return typeof mode === "string" ? { mode } : undefined;
 }
 
 export const chatModeSegment = {

package/extensions/opl-footer/segments/compactions.ts

@@ -0,0 +1,13 @@
+import type { RenderedSegment, SegmentContext } from "../types.js";
+import { applyColor } from "../theme.js";
+
+export const compactionsSegment = {
+  id: "compactions" as const,
+  render(ctx: SegmentContext): RenderedSegment {
+    if (ctx.compactions === 0) return { content: "", visible: false };
+    return {
+      content: `${ctx.icons.compress} ${applyColor(ctx.theme, "text", `${ctx.compactions}`)}`,
+      visible: true,
+    };
+  },
+};

package/extensions/opl-footer/segments/context.ts

@@ -72,14 +72,15 @@ export const contextPctSegment = {
     const midFrac = barOpts.gradientMidPoint ?? DEFAULT_MID_FRAC;
 
     const filled = Math.round((pct / 100) * barWidth);
+    // Every unfilled cell is identical, so resolve its colour once instead of probing
+    // the theme once per cell on every frame.
+    const unfilledCell = applyColor(ctx.theme, unfilledColor, unfilledChar);
 
     let bar = "";
     for (let i = 0; i < barWidth; i++) {
-      if (i < filled) {
-        bar += positionColor(i, barWidth, start, mid, end, midFrac) + filledChar;
-      } else {
-        bar += applyColor(ctx.theme, unfilledColor, unfilledChar);
-      }
+      bar += i < filled
+        ? positionColor(i, barWidth, start, mid, end, midFrac) + filledChar
+        : unfilledCell;
     }
     bar += "\x1b[0m";