@sreetej510/pi-usage 0.1.1 → 0.1.4

package/src/codex-reset-credits.ts

@@ -1,131 +0,0 @@
-import { randomUUID } from "node:crypto";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { resolvePiCodexWhamAuth } from "./codex-auth.js";
-import { CODEX_CONSUME_RESET_CREDITS_URL, CODEX_RESET_CREDITS_URL } from "./constants.js";
-import { throwUsageEndpointError } from "./errors.js";
-import { fetchWithTimeout } from "./http.js";
-import type {
-  CodexResetCredit,
-  CodexResetCreditList,
-  CodexResetCreditPayload,
-  CodexResetCreditRowPayload,
-} from "./types.js";
-import { asNumber, asString, assertObject, parseJsonObject, redactErrorBody } from "./utils.js";
-
-export async function fetchCodexResetCredits(ctx: ExtensionContext, timeoutMs: number): Promise<CodexResetCreditList> {
-  const auth = await resolvePiCodexWhamAuth(ctx);
-  if (!auth) {
-    throw new Error(
-      "No Pi OpenAI Codex auth was available. Use a Pi OpenAI Codex model or run /login for OpenAI ChatGPT Plus/Pro (Codex).",
-    );
-  }
-  const response = await fetchWithTimeout(
-    CODEX_RESET_CREDITS_URL,
-    { headers: auth.headers },
-    timeoutMs,
-    "Codex banked resets",
-  );
-  const text = await response.text();
-  if (!response.ok) {
-    throwUsageEndpointError("Codex banked resets", response, text);
-  }
-  const payload = parseJsonObject(text, "Codex banked reset credits response");
-  return normalizeCodexResetCreditList(payload as CodexResetCreditPayload);
-}
-
-export async function consumeCodexResetCredit(
-  ctx: ExtensionContext,
-  timeoutMs: number,
-  creditId: string,
-): Promise<void> {
-  const auth = await resolvePiCodexWhamAuth(ctx);
-  if (!auth) {
-    throw new Error(
-      "No Pi OpenAI Codex auth was available. Use a Pi OpenAI Codex model or run /login for OpenAI ChatGPT Plus/Pro (Codex).",
-    );
-  }
-  const redeemRequestId = randomUUID();
-  const bodies = [
-    { id: creditId, redeem_request_id: redeemRequestId },
-    { credit_id: creditId, redeem_request_id: redeemRequestId },
-    { rate_limit_reset_credit_id: creditId, redeem_request_id: redeemRequestId },
-    { id: creditId, redeemRequestId },
-    { credit_id: creditId, redeemRequestId },
-    { rate_limit_reset_credit_id: creditId, redeemRequestId },
-  ];
-  let lastError: Error | undefined;
-  for (const body of bodies) {
-    const response = await fetchWithTimeout(
-      CODEX_CONSUME_RESET_CREDITS_URL,
-      { method: "POST", headers: auth.headers, body: JSON.stringify(body) },
-      timeoutMs,
-      "Codex consume banked reset",
-    );
-    const text = await response.text();
-    if (response.ok) return;
-    lastError = new Error(
-      `Codex consume banked reset returned ${response.status} ${response.statusText}: ${redactErrorBody(text)}`,
-    );
-    if (response.status !== 400 && response.status !== 422) break;
-  }
-  throw lastError ?? new Error("Failed to consume Codex banked reset.");
-}
-
-function normalizeCodexResetCreditList(payload: CodexResetCreditPayload): CodexResetCreditList {
-  const rawCredits = Array.isArray(payload.credits) ? payload.credits : [];
-  const credits = rawCredits
-    .map((value) => normalizeCodexResetCreditRow(value))
-    .filter((value): value is CodexResetCredit => value !== undefined);
-  const availableCount =
-    asNumber(payload.available_count) ??
-    asNumber(payload.availableCount) ??
-    credits.filter((credit) => (credit.status ?? "available") === "available").length;
-  return { availableCount: Math.max(0, Math.trunc(availableCount)), credits };
-}
-
-function normalizeCodexResetCreditRow(value: unknown): CodexResetCredit | undefined {
-  if (!value) return undefined;
-  const credit = assertObject(value, "Codex reset credit") as CodexResetCreditRowPayload;
-  const id = asString(credit.id);
-  if (!id) return undefined;
-  return {
-    id,
-    resetType: asString(credit.reset_type) ?? asString(credit.resetType),
-    status: asString(credit.status),
-    grantedAt: asString(credit.granted_at) ?? asString(credit.grantedAt),
-    expiresAt: asString(credit.expires_at) ?? asString(credit.expiresAt),
-  };
-}
-
-export function formatCodexResetCreditList(list: CodexResetCreditList): string {
-  const lines = ["  >_ Codex Banked Resets", ""];
-  lines.push(`  Banked resets available: ${list.availableCount}`);
-  if (list.credits.length === 0) {
-    lines.push("  No banked reset credits found.");
-    return lines.join("\n");
-  }
-  for (const credit of list.credits) {
-    const status = credit.status ? ` [${credit.status}]` : "";
-    const granted = credit.grantedAt ? `granted ${formatIsoReset(credit.grantedAt)}` : undefined;
-    const expires = credit.expiresAt ? `expires ${formatIsoReset(credit.expiresAt)}` : undefined;
-    const timing = [granted, expires].filter(Boolean).join(" • ");
-    lines.push(`  ${credit.id}${status}${timing ? ` — ${timing}` : ""}`);
-  }
-  return lines.join("\n");
-}
-
-export function formatCodexResetCreditChoice(credit: CodexResetCredit): string {
-  const expires = credit.expiresAt ? `expires ${formatIsoReset(credit.expiresAt)}` : "no expiry shown";
-  return `${credit.id} — ${expires}`;
-}
-
-function formatIsoReset(value: string, showDay = true): string {
-  const reset = new Date(value);
-  if (Number.isNaN(reset.getTime())) return "at an unknown time";
-  const now = new Date();
-  const time = `${reset.getHours().toString().padStart(2, "0")}:${reset.getMinutes().toString().padStart(2, "0")}`;
-  if (!showDay && reset.toDateString() === now.toDateString()) return time;
-  const day = reset.getDate().toString();
-  const month = reset.toLocaleDateString(undefined, { month: "short" });
-  return `${time} on ${day} ${month}`;
-}

package/src/command.ts

@@ -1,184 +0,0 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { fetchRawUsagePayloads } from "./anthropic-query.js";
-import { completeCodexStatusArguments, parseArgs } from "./args.js";
-import {
-  consumeCodexResetCredit,
-  fetchCodexResetCredits,
-  formatCodexResetCreditChoice,
-  formatCodexResetCreditList,
-} from "./codex-reset-credits.js";
-import { CACHE_TTL_MS, COMMAND_NAME } from "./constants.js";
-import { isRateLimitErrorMessage, rateLimitBackoffMs } from "./errors.js";
-import { formatQueryErrors, showReports } from "./format.js";
-import { queryAllUsage } from "./query.js";
-import {
-  clearSharedBackoff,
-  clearSharedUsageReport,
-  readSharedUsageCache,
-  saveSharedBackoff,
-  saveSharedUsageReport,
-} from "./shared-cache.js";
-import {
-  applyCurrentProviderStatusline,
-  clearCodexMemoryCache,
-  clearStatuslineValue,
-  clearUsageStatusline,
-  getCombinedCache,
-  handleStaleContextError,
-  isSessionActive,
-  setCombinedCache,
-  setStatuslineChecking,
-} from "./statusline.js";
-import type { SharedCacheEntry } from "./types.js";
-import { errorMessage } from "./utils.js";
-
-export function registerUsageCommand(pi: ExtensionAPI): void {
-  pi.registerCommand(COMMAND_NAME, {
-    description: "Show usage for all configured providers (Codex and Anthropic)",
-    getArgumentCompletions: completeCodexStatusArguments,
-    handler: async (args, ctx) => {
-      try {
-        const options = parseArgs(args);
-        if (!options.ok) {
-          ctx.ui.notify(options.error, "warning");
-          return;
-        }
-
-        if (options.value.clearStatusline) {
-          clearUsageStatusline(ctx);
-          ctx.ui.notify("Usage statusline cleared.", "info");
-          return;
-        }
-
-        if (options.value.raw) {
-          const rawTimeoutMs = options.value.timeoutMs;
-          void fetchRawUsagePayloads(ctx, rawTimeoutMs)
-            .then((text) => {
-              if (isSessionActive()) ctx.ui.notify(text, "info");
-            })
-            .catch((error: unknown) => {
-              if (!handleStaleContextError(ctx, error)) {
-                ctx.ui.notify(errorMessage(error), "error");
-              }
-            });
-          return;
-        }
-
-        if (options.value.listBankedResets) {
-          const resets = await fetchCodexResetCredits(ctx, options.value.timeoutMs);
-          ctx.ui.notify(formatCodexResetCreditList(resets), "info");
-          return;
-        }
-
-        if (options.value.consumeBankedReset) {
-          const resets = await fetchCodexResetCredits(ctx, options.value.timeoutMs);
-          if (resets.availableCount <= 0 || resets.credits.length === 0) {
-            ctx.ui.notify("No Codex banked resets are available.", "info");
-            return;
-          }
-          let resetId = options.value.consumeBankedResetId;
-          if (!resetId) {
-            if (!ctx.hasUI) {
-              ctx.ui.notify(
-                "Usage: /usage --consume-banked-reset <id> (or run with a TUI to pick interactively)",
-                "warning",
-              );
-              return;
-            }
-            const selected = await ctx.ui.select(
-              "Choose a Codex banked reset to consume",
-              resets.credits.map((credit) => formatCodexResetCreditChoice(credit)),
-            );
-            if (!selected) return;
-            resetId = resets.credits.find((credit) => formatCodexResetCreditChoice(credit) === selected)?.id;
-          }
-          if (!resetId) {
-            ctx.ui.notify("Could not determine which banked reset to consume.", "warning");
-            return;
-          }
-          await consumeCodexResetCredit(ctx, options.value.timeoutMs, resetId);
-          clearCodexMemoryCache();
-          setCombinedCache(undefined);
-          clearSharedUsageReport("codex");
-          ctx.ui.notify(`Consumed Codex banked reset ${resetId}.`, "info");
-          void queryAllUsage(ctx, { timeoutMs: options.value.timeoutMs })
-            .then((result) => {
-              if (result.reports.length > 0) {
-                setCombinedCache({ createdAt: Date.now(), reports: result.reports });
-                for (const report of result.reports) saveSharedUsageReport(report);
-                showReports(ctx, result.reports, false);
-              }
-            })
-            .catch(() => {});
-          return;
-        }
-
-        const combined = getCombinedCache();
-        let cached = combined && Date.now() - combined.createdAt < CACHE_TTL_MS ? combined : undefined;
-        if (!cached) {
-          // Fall back to reports fetched by other pi sessions.
-          const shared = readSharedUsageCache();
-          if (shared) {
-            const entries = Object.values(shared.entries).filter(
-              (entry): entry is SharedCacheEntry => !!entry && Date.now() - entry.createdAt < CACHE_TTL_MS,
-            );
-            if (entries.length > 0) {
-              cached = {
-                createdAt: Math.min(...entries.map((entry) => entry.createdAt)),
-                reports: entries.map((entry) => entry.report),
-              };
-            }
-          }
-        }
-        if (cached && !options.value.refresh) {
-          if (options.value.statusline) applyCurrentProviderStatusline(ctx, cached.reports);
-          showReports(ctx, cached.reports, true);
-          return;
-        }
-
-        // Fire and forget — return immediately so the command doesn't block.
-        // Results arrive as a notification once both providers finish.
-        const cmdOptions = options.value;
-        // Explicit refresh is a manual override — drop any stored backoff.
-        if (cmdOptions.refresh) clearSharedBackoff();
-        if (cmdOptions.statusline) setStatuslineChecking(ctx);
-        void queryAllUsage(ctx, cmdOptions)
-          .then((result) => {
-            if (!isSessionActive()) return;
-            if (result.reports.length === 0) {
-              if (cmdOptions.statusline) clearStatuslineValue(ctx);
-              ctx.ui.notify(formatQueryErrors(result.errors), "error");
-              return;
-            }
-            setCombinedCache({ createdAt: Date.now(), reports: result.reports });
-            for (const report of result.reports) saveSharedUsageReport(report);
-            for (const error of result.errors) {
-              if (isRateLimitErrorMessage(error.message)) {
-                saveSharedBackoff(
-                  error.source === "anthropic-oauth" ? "anthropic" : "codex",
-                  Date.now() + rateLimitBackoffMs([error]),
-                );
-              }
-            }
-            const kept = cmdOptions.statusline ? applyCurrentProviderStatusline(ctx, result.reports) : false;
-            if (cmdOptions.statusline && !kept) clearStatuslineValue(ctx);
-            showReports(ctx, result.reports, false);
-            // Surface partial failures (e.g. one provider worked, the other didn't).
-            if (result.errors.length > 0) {
-              ctx.ui.notify(formatQueryErrors(result.errors), "warning");
-            }
-          })
-          .catch((error: unknown) => {
-            if (cmdOptions.statusline) clearStatuslineValue(ctx);
-            if (!handleStaleContextError(ctx, error)) {
-              ctx.ui.notify(errorMessage(error), "error");
-            }
-          });
-        // Return right away — the fetch continues in the background.
-      } catch (error) {
-        if (handleStaleContextError(ctx, error)) return;
-        throw error;
-      }
-    },
-  });
-}

package/src/constants.ts

@@ -1,56 +0,0 @@
-import { homedir } from "node:os";
-import { join } from "node:path";
-import type { CommandArgumentCompletion } from "./types.js";
-
-export const COMMAND_NAME = "usage";
-export const CODEX_PROVIDER_ID = "openai-codex";
-export const ANTHROPIC_PROVIDER_ID = "anthropic";
-export const CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
-export const CODEX_RESET_CREDITS_URL = "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits";
-export const CODEX_CONSUME_RESET_CREDITS_URL = "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits/consume";
-export const CODEX_OPENAI_BETA = "codex-1";
-export const ANTHROPIC_OAUTH_USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
-export const DEFAULT_TIMEOUT_MS = 15_000;
-export const CACHE_TTL_MS = 3 * 60 * 1000;
-export const STATUSLINE_RETRY_ATTEMPTS = 3;
-export const STATUSLINE_RETRY_DELAY_MS = 1_000;
-/** Default backoff after a 429 when the server doesn't say when to retry. */
-export const RATE_LIMIT_BACKOFF_MS = 15 * 60 * 1000;
-/** Bounds for server-provided Retry-After values. */
-export const RATE_LIMIT_BACKOFF_MIN_MS = 30 * 1000;
-export const RATE_LIMIT_BACKOFF_MAX_MS = 60 * 60 * 1000;
-/** Shared on-disk usage cache so concurrent pi sessions don't each hit the APIs. */
-export const SHARED_CACHE_FILE = join(homedir(), ".pi", "agent", "usage-cache.json");
-export const SHARED_CACHE_VERSION = 1;
-export const STATUS_KEY = "provider-usage";
-export const BAR_SEGMENTS = 20;
-export const LIMIT_VALUE_COLUMN = 29;
-export const MAX_ERROR_BODY_CHARS = 600;
-export const RESET_FOREGROUND = "\x1b[39m";
-/** Payload keys that are not enterprise budget windows. Everything else that
- * looks like a `{ used_dollars, limit_dollars }` object is treated as one —
- * Anthropic uses rotating codenames (cinder_cove, amber_ladder, …) so we
- * detect windows by shape instead of a hardcoded key list. */
-export const ANTHROPIC_NON_WINDOW_KEYS = new Set(["five_hour", "seven_day", "extra_usage"]);
-
-export const COMMAND_COMPLETIONS: readonly CommandArgumentCompletion[] = [
-  { value: "--refresh", label: "--refresh", description: "Refresh usage instead of cached data" },
-  { value: "--no-statusline", label: "--no-statusline", description: "Do not update the statusline" },
-  {
-    value: "--clear-statusline",
-    label: "--clear-statusline",
-    description: "Clear the usage statusline",
-  },
-  { value: "--timeout ", label: "--timeout", description: "Set query timeout in seconds" },
-  { value: "--raw", label: "--raw", description: "Show raw usage API responses (for debugging)" },
-  {
-    value: "--list-banked-resets",
-    label: "--list-banked-resets",
-    description: "List available Codex banked resets and expiry dates",
-  },
-  {
-    value: "--consume-banked-reset ",
-    label: "--consume-banked-reset",
-    description: "Consume a Codex banked reset by id",
-  },
-];

package/src/errors.ts

@@ -1,49 +0,0 @@
-import { RATE_LIMIT_BACKOFF_MAX_MS, RATE_LIMIT_BACKOFF_MIN_MS, RATE_LIMIT_BACKOFF_MS } from "./constants.js";
-import type { UsageQueryError } from "./types.js";
-import { redactErrorBody } from "./utils.js";
-
-export function isStaleExtensionContextError(error: unknown): boolean {
-  return (
-    error instanceof Error && error.message.includes("This extension ctx is stale after session replacement or reload")
-  );
-}
-
-/** Error thrown for HTTP failures from usage endpoints; carries Retry-After for 429s. */
-export class UsageEndpointError extends Error {
-  retryAfterMs?: number;
-  constructor(message: string, retryAfterMs?: number) {
-    super(message);
-    this.name = "UsageEndpointError";
-    this.retryAfterMs = retryAfterMs;
-  }
-}
-
-export function isRateLimitErrorMessage(message: string): boolean {
-  return /\b429\b|rate_limit_error|rate.?limited/i.test(message);
-}
-
-export function throwUsageEndpointError(provider: string, response: Response, body: string): never {
-  const message = `${provider} usage endpoint returned ${response.status} ${response.statusText}: ${redactErrorBody(body)}`;
-  throw new UsageEndpointError(message, response.status === 429 ? parseRetryAfterMs(response) : undefined);
-}
-
-/** Parse a Retry-After header — either delta-seconds or an HTTP date. */
-export function parseRetryAfterMs(response: Response): number | undefined {
-  const header = response.headers.get("retry-after");
-  if (!header) return undefined;
-  const seconds = Number(header);
-  if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1000;
-  const date = Date.parse(header);
-  if (!Number.isNaN(date)) return Math.max(0, date - Date.now());
-  return undefined;
-}
-
-/** Server-provided Retry-After from a failed query, clamped to sane bounds. */
-export function rateLimitBackoffMs(errors: UsageQueryError[]): number {
-  for (const error of errors) {
-    if (error.cause instanceof UsageEndpointError && error.cause.retryAfterMs !== undefined) {
-      return Math.min(Math.max(error.cause.retryAfterMs, RATE_LIMIT_BACKOFF_MIN_MS), RATE_LIMIT_BACKOFF_MAX_MS);
-    }
-  }
-  return RATE_LIMIT_BACKOFF_MS;
-}

package/src/footer.ts

@@ -1,188 +0,0 @@
-import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-import { STATUS_KEY } from "./constants.js";
-import type { FooterDataView, FooterTheme, FooterTui } from "./types.js";
-import { asNumber, sanitizeStatusText } from "./utils.js";
-
-let footerRegistered = false;
-
-export function isFooterRegistered(): boolean {
-  return footerRegistered;
-}
-
-export function setFooterRegistered(value: boolean): void {
-  footerRegistered = value;
-}
-
-export function installUsageFooter(pi: ExtensionAPI, ctx: ExtensionContext): void {
-  // biome-ignore lint/suspicious/noExplicitAny: footer factory params are provided by the host
-  ctx.ui.setFooter((tui: any, theme: any, footerData: any) => {
-    const footerTui = tui as FooterTui;
-    const footerTheme = theme as FooterTheme;
-    const footerView = footerData as FooterDataView;
-    const unsubscribe = footerView.onBranchChange(() => footerTui.requestRender());
-    return {
-      dispose: unsubscribe,
-      invalidate() {},
-      render(width: number): string[] {
-        return renderUsageFooter(pi, ctx, footerTheme, footerView, width);
-      },
-    };
-  });
-}
-
-function renderUsageFooter(
-  pi: ExtensionAPI,
-  ctx: ExtensionContext,
-  theme: FooterTheme,
-  footerData: FooterDataView,
-  width: number,
-): string[] {
-  let totalInput = 0;
-  let totalOutput = 0;
-  let totalCacheRead = 0;
-  let totalCacheWrite = 0;
-  let totalCost = 0;
-  let latestCacheHitRate: number | undefined;
-
-  for (const entry of ctx.sessionManager.getEntries()) {
-    const message = (entry as { type?: string; message?: unknown }).message as
-      | { role?: string; usage?: Record<string, unknown> }
-      | undefined;
-    if ((entry as { type?: string }).type !== "message" || message?.role !== "assistant") continue;
-    const usage = message.usage ?? {};
-    const input = asNumber(usage.input) ?? 0;
-    const output = asNumber(usage.output) ?? 0;
-    const cacheRead = asNumber(usage.cacheRead) ?? 0;
-    const cacheWrite = asNumber(usage.cacheWrite) ?? 0;
-    const cost = usage.cost as { total?: unknown } | undefined;
-    totalInput += input;
-    totalOutput += output;
-    totalCacheRead += cacheRead;
-    totalCacheWrite += cacheWrite;
-    totalCost += asNumber(cost?.total) ?? 0;
-    const prompt = input + cacheRead + cacheWrite;
-    latestCacheHitRate = prompt > 0 ? (cacheRead / prompt) * 100 : undefined;
-  }
-
-  const contextUsage = ctx.getContextUsage();
-  const contextWindow = contextUsage?.contextWindow ?? ctx.model?.contextWindow ?? 0;
-  const contextPercentValue = contextUsage?.percent ?? 0;
-  const contextPercent = contextUsage && contextUsage.percent !== null ? contextPercentValue.toFixed(1) : "?";
-
-  let pwd = formatCwdForFooter(ctx.sessionManager.getCwd(), process.env.HOME || process.env.USERPROFILE);
-  const branch = footerData.getGitBranch();
-  if (branch) pwd = `${pwd} (${branch})`;
-  const sessionName = ctx.sessionManager.getSessionName();
-  if (sessionName) pwd = `${pwd} \u2022 ${sessionName}`;
-
-  const statsParts: string[] = [];
-  if (totalInput) statsParts.push(`\u2191${formatFooterTokens(totalInput)}`);
-  if (totalOutput) statsParts.push(`\u2193${formatFooterTokens(totalOutput)}`);
-  if (totalCacheRead) statsParts.push(`R${formatFooterTokens(totalCacheRead)}`);
-  if (totalCacheWrite) statsParts.push(`W${formatFooterTokens(totalCacheWrite)}`);
-  if ((totalCacheRead > 0 || totalCacheWrite > 0) && latestCacheHitRate !== undefined) {
-    statsParts.push(`CH${latestCacheHitRate.toFixed(1)}%`);
-  }
-  const usingSubscription = ctx.model ? ctx.modelRegistry.isUsingOAuth(ctx.model) : false;
-  if (totalCost || usingSubscription) {
-    statsParts.push(`$${totalCost.toFixed(3)}${usingSubscription ? " (sub)" : ""}`);
-  }
-  const contextDisplay =
-    contextPercent === "?"
-      ? `?/${formatFooterTokens(contextWindow)}`
-      : `${contextPercent}%/${formatFooterTokens(contextWindow)}`;
-  let contextStr = contextDisplay;
-  if (contextPercentValue > 90) contextStr = theme.fg("error", contextDisplay);
-  else if (contextPercentValue > 70) contextStr = theme.fg("warning", contextDisplay);
-  statsParts.push(contextStr);
-
-  let statsLeft = statsParts.join(" ");
-  let statsLeftWidth = visibleWidth(statsLeft);
-  if (statsLeftWidth > width) {
-    statsLeft = truncateToWidth(statsLeft, width, "...");
-    statsLeftWidth = visibleWidth(statsLeft);
-  }
-
-  const modelName = ctx.model?.id || "no-model";
-  let rightSide = modelName;
-  if (ctx.model?.reasoning) {
-    const level = pi.getThinkingLevel?.() ?? "off";
-    rightSide = level === "off" ? `${modelName} \u2022 thinking off` : `${modelName} \u2022 ${level}`;
-  }
-  if (footerData.getAvailableProviderCount() > 1 && ctx.model) {
-    const withProvider = `(${ctx.model.provider}) ${rightSide}`;
-    if (statsLeftWidth + 2 + visibleWidth(withProvider) <= width) rightSide = withProvider;
-  }
-
-  const rightSideWidth = visibleWidth(rightSide);
-  let statsLine: string;
-  if (statsLeftWidth + 2 + rightSideWidth <= width) {
-    statsLine = statsLeft + " ".repeat(width - statsLeftWidth - rightSideWidth) + rightSide;
-  } else {
-    const availableForRight = width - statsLeftWidth - 2;
-    if (availableForRight > 0) {
-      const truncatedRight = truncateToWidth(rightSide, availableForRight, "");
-      const pad = Math.max(0, width - statsLeftWidth - visibleWidth(truncatedRight));
-      statsLine = statsLeft + " ".repeat(pad) + truncatedRight;
-    } else {
-      statsLine = statsLeft;
-    }
-  }
-
-  const dimStatsLeft = theme.fg("dim", statsLeft);
-  const dimRemainder = theme.fg("dim", statsLine.slice(statsLeft.length));
-  const pwdLine = truncateToWidth(theme.fg("dim", pwd), width, theme.fg("dim", "..."));
-  const lines = [pwdLine, dimStatsLeft + dimRemainder];
-
-  const statusLine = renderUsageStatusLine(theme, footerData, width);
-  if (statusLine !== undefined) lines.push(statusLine);
-  return lines;
-}
-
-function renderUsageStatusLine(theme: FooterTheme, footerData: FooterDataView, width: number): string | undefined {
-  const statuses = footerData.getExtensionStatuses();
-  if (statuses.size === 0) return undefined;
-
-  const ours = statuses.get(STATUS_KEY);
-  const others = Array.from(statuses.entries())
-    .filter(([key]) => key !== STATUS_KEY)
-    .sort(([a], [b]) => a.localeCompare(b))
-    .map(([, text]) => sanitizeStatusText(text));
-  const left = others.join(" ");
-
-  if (!ours) {
-    return left ? truncateToWidth(left, width, theme.fg("dim", "...")) : undefined;
-  }
-
-  const right = sanitizeStatusText(ours);
-  const leftWidth = visibleWidth(left);
-  const rightWidth = visibleWidth(right);
-  if (leftWidth + 1 + rightWidth > width) {
-    // Not enough room to right-align cleanly; keep usage visible on its own line.
-    return truncateToWidth(left ? `${left} ${right}` : right, width, theme.fg("dim", "..."));
-  }
-  const padding = " ".repeat(Math.max(1, width - leftWidth - rightWidth));
-  return left + padding + right;
-}
-
-function formatFooterTokens(count: number): string {
-  if (count < 1000) return count.toString();
-  if (count < 10000) return `${(count / 1000).toFixed(1)}k`;
-  if (count < 1000000) return `${Math.round(count / 1000)}k`;
-  if (count < 10000000) return `${(count / 1000000).toFixed(1)}M`;
-  return `${Math.round(count / 1000000)}M`;
-}
-
-function formatCwdForFooter(cwd: string, home: string | undefined): string {
-  if (!home) return cwd;
-  const resolvedCwd = resolve(cwd);
-  const resolvedHome = resolve(home);
-  const relativeToHome = relative(resolvedHome, resolvedCwd);
-  const isInsideHome =
-    relativeToHome === "" ||
-    (relativeToHome !== ".." && !relativeToHome.startsWith(`..${sep}`) && !isAbsolute(relativeToHome));
-  if (!isInsideHome) return cwd;
-  return relativeToHome === "" ? "~" : `~${sep}${relativeToHome}`;
-}