@openlines/opl-pi-sht 0.2.12 → 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,8 +233,9 @@ 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;
@@ -278,23 +395,20 @@ 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;
@@ -324,14 +438,26 @@ 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);
@@ -408,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();
@@ -432,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.
@@ -497,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,
@@ -559,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";
 

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

@@ -13,6 +13,7 @@ import { planModeSegment } from "./plan-mode.js";
 import { chatModeSegment } from "./chat-mode.js";
 import { modeSwitcherSegment } from "./mode-switcher.js";
 import { sessionStatsSegment, perfStatsSegment } from "./session-stats.js";
+import { compactionsSegment } from "./compactions.js";
 import { statusSegment } from "./status.js";
 import { codexUsageSegment } from "./codex-usage.js";
 import { openRouterUsageSegment } from "./openrouter-usage.js";
@@ -37,6 +38,7 @@ const SEGMENTS = {
   chat_mode: chatModeSegment,
   mode_switcher: modeSwitcherSegment,
   session_stats: sessionStatsSegment,
+  compactions: compactionsSegment,
   perf_stats: perfStatsSegment,
   status: statusSegment,
   codex_usage: codexUsageSegment,

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

@@ -6,8 +6,21 @@ interface AgentModeState {
   appearance?: { modeColor?: string };
 }
 
+/**
+ * Written by `opl-modes`, which may not be installed, and may be written by anything else
+ * that claims the name. Only a `{ mode: string }` is honoured; anything else renders nothing
+ * rather than throwing inside the footer's render loop.
+ */
 function readAgentModeState(): AgentModeState | undefined {
-  return (globalThis as Record<string, unknown>).__agentMode as AgentModeState | undefined;
+  const state = (globalThis as Record<string, unknown>).__agentMode as unknown;
+  if (!state || typeof state !== "object") return undefined;
+  const { mode, appearance } = state as { mode?: unknown; appearance?: unknown };
+  if (typeof mode !== "string" || !mode) return undefined;
+  const modeColor =
+    appearance && typeof appearance === "object"
+      ? (appearance as { modeColor?: unknown }).modeColor
+      : undefined;
+  return { mode, ...(typeof modeColor === "string" ? { appearance: { modeColor } } : {}) };
 }
 
 export const modeSwitcherSegment = {

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

@@ -8,7 +8,7 @@ export const pathSegment = {
     const opts = ctx.options.path ?? {};
     const mode = opts.mode ?? "basename";
 
-    let pwd = process.cwd();
+    let pwd = ctx.cwd || process.cwd();
     const home = process.env.HOME || process.env.USERPROFILE;
 
     if (mode === "basename") {

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

@@ -6,8 +6,15 @@ interface PlanModeState {
   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 readPlanModeState(): PlanModeState | undefined {
-  return (globalThis as Record<string, unknown>).__planMode as PlanModeState | undefined;
+  const state = (globalThis as Record<string, unknown>).__planMode as unknown;
+  if (!state || typeof state !== "object") return undefined;
+  const mode = (state as { mode?: unknown }).mode;
+  return typeof mode === "string" ? { mode } : undefined;
 }
 
 export const planModeSegment = {

package/extensions/opl-footer/theme.ts

@@ -5,7 +5,8 @@ import type { ColorScheme, ColorValue, SemanticColor } from "./types.js";
 // their absence signals "use rainbow" in thinking.ts.
 const DEFAULT_COLORS: ColorScheme = {
   pi: "accent",
-  model: "#c07898",
+  // model: "#c07898",
+  model: "accent",
   path: "dim",
   git: "success",
   gitDirty: "warning",
@@ -128,5 +129,7 @@ export function resolveColorToRgb(
   }
   const match = probed.match(/\x1b\[38;2;(\d+);(\d+);(\d+)m/);
   if (!match) return null;
-  return { r: parseInt(match[1]), g: parseInt(match[2]), b: parseInt(match[3]) };
+  const [r, g, b] = [match[1], match[2], match[3]];
+  if (r === undefined || g === undefined || b === undefined) return null;
+  return { r: parseInt(r, 10), g: parseInt(g, 10), b: parseInt(b, 10) };
 }

package/extensions/opl-footer/types.ts

@@ -54,6 +54,7 @@ export type StatusLineSegmentId =
   | "chat_mode"
   | "mode_switcher"
   | "session_stats"
+  | "compactions"
   | "perf_stats"
   | "status"
   | "codex_usage"
@@ -127,6 +128,8 @@ export interface SegmentContext {
   contextWindow: number;
   usingSubscription: boolean;
   sessionStartTime: number;
+  /** Session directory (`ExtensionContext.cwd`): the base the Path segment renders. */
+  cwd: string;
   git: GitStatus;
   options: StatusLineSegmentOptions;
   width: number;
@@ -134,6 +137,7 @@ export interface SegmentContext {
   colors: ColorScheme;
   icons: IconSet;
   sessionStats: SessionStats;
+  compactions: number;
   agentStatus: AgentStatus;
   codexUsage: CodexUsageSnapshot | null;
   openRouterUsage: OpenRouterUsageSnapshot | null;