feat: add built-in status line with usage quota, token counts, and cost display

Adds a default built-in status line that shows model name, context usage with
token counts, 5h session and 7d weekly rate limit progress bars with countdowns,
and cumulative cost. No configuration needed — displays automatically when no
external statusLine command is configured. Refactors StatusLine.tsx into routing
component with ExternalStatusLine (existing) and BuiltinStatusLineWrapper (new).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: unraid

src/components/BuiltinStatusLine.tsx

@@ -0,0 +1,152 @@
+import React, { useEffect, useState } from 'react';
+import { formatCost } from '../cost-tracker.js';
+import { Box, Text } from '../ink.js';
+import { formatTokens } from '../utils/format.js';
+import { ProgressBar } from './design-system/ProgressBar.js';
+import { useTerminalSize } from '../hooks/useTerminalSize.js';
+
+type RateLimitBucket = {
+  utilization: number;
+  resets_at: number;
+};
+
+type BuiltinStatusLineProps = {
+  modelName: string;
+  contextUsedPct: number;
+  usedTokens: number;
+  contextWindowSize: number;
+  totalCostUsd: number;
+  rateLimits: {
+    five_hour?: RateLimitBucket;
+    seven_day?: RateLimitBucket;
+  };
+};
+
+/**
+ * Format a countdown from now until the given epoch time (in seconds).
+ * Returns a compact human-readable string like "3h12m", "5d20h", "45m", or "now".
+ */
+export function formatCountdown(epochSeconds: number): string {
+  const diff = epochSeconds - Date.now() / 1000;
+  if (diff <= 0) return 'now';
+
+  const days = Math.floor(diff / 86400);
+  const hours = Math.floor((diff % 86400) / 3600);
+  const minutes = Math.floor((diff % 3600) / 60);
+
+  if (days >= 1) return `${days}d${hours}h`;
+  if (hours >= 1) return `${hours}h${minutes}m`;
+  return `${minutes}m`;
+}
+
+function Separator() {
+  return <Text dimColor>{' \u2502 '}</Text>;
+}
+
+function BuiltinStatusLineInner({
+  modelName,
+  contextUsedPct,
+  usedTokens,
+  contextWindowSize,
+  totalCostUsd,
+  rateLimits,
+}: BuiltinStatusLineProps) {
+  const { columns } = useTerminalSize();
+
+  // Force re-render every 60s so countdowns stay current
+  const [tick, setTick] = useState(0);
+  useEffect(() => {
+    const hasResetTime = rateLimits.five_hour?.resets_at || rateLimits.seven_day?.resets_at;
+    if (!hasResetTime) return;
+    const id = setInterval(() => setTick(t => t + 1), 60_000);
+    return () => clearInterval(id);
+  }, [rateLimits.five_hour?.resets_at, rateLimits.seven_day?.resets_at]);
+
+  // Suppress unused-variable lint for tick (it exists only to trigger re-renders)
+  void tick;
+
+  // Model display: use first two words (e.g. "Opus 4.6") instead of just first word
+  const modelParts = modelName.split(' ');
+  const shortModel = modelParts.length >= 2 ? `${modelParts[0]} ${modelParts[1]}` : modelName;
+
+  const wide = columns >= 100;
+  const narrow = columns < 60;
+
+  const hasFiveHour = rateLimits.five_hour != null;
+  const hasSevenDay = rateLimits.seven_day != null;
+
+  const fiveHourPct = hasFiveHour ? Math.round(rateLimits.five_hour!.utilization * 100) : 0;
+  const sevenDayPct = hasSevenDay ? Math.round(rateLimits.seven_day!.utilization * 100) : 0;
+
+  // Token display: "50k/1M"
+  const tokenDisplay = `${formatTokens(usedTokens)}/${formatTokens(contextWindowSize)}`;
+
+  return (
+    <Box wrap="truncate">
+      {/* Model name */}
+      <Text>{shortModel}</Text>
+
+      {/* Context usage with token counts */}
+      <Separator />
+      <Text dimColor>Context </Text>
+      <Text>{contextUsedPct}%</Text>
+      {!narrow && <Text dimColor> ({tokenDisplay})</Text>}
+
+      {/* 5-hour session rate limit */}
+      {hasFiveHour && (
+        <>
+          <Separator />
+          <Text dimColor>Session </Text>
+          {wide && (
+            <>
+              <ProgressBar
+                ratio={rateLimits.five_hour!.utilization}
+                width={10}
+                fillColor="rate_limit_fill"
+                emptyColor="rate_limit_empty"
+              />
+              <Text> </Text>
+            </>
+          )}
+          <Text>{fiveHourPct}%</Text>
+          {!narrow && rateLimits.five_hour!.resets_at > 0 && (
+            <Text dimColor> {formatCountdown(rateLimits.five_hour!.resets_at)}</Text>
+          )}
+        </>
+      )}
+
+      {/* 7-day weekly rate limit */}
+      {hasSevenDay && (
+        <>
+          <Separator />
+          <Text dimColor>Weekly </Text>
+          {wide && (
+            <>
+              <ProgressBar
+                ratio={rateLimits.seven_day!.utilization}
+                width={10}
+                fillColor="rate_limit_fill"
+                emptyColor="rate_limit_empty"
+              />
+              <Text> </Text>
+            </>
+          )}
+          <Text>{sevenDayPct}%</Text>
+          {!narrow && rateLimits.seven_day!.resets_at > 0 && (
+            <Text dimColor> {formatCountdown(rateLimits.seven_day!.resets_at)}</Text>
+          )}
+        </>
+      )}
+
+      {/* Cost */}
+      {totalCostUsd > 0 && (
+        <>
+          <Separator />
+          <Text>{formatCost(totalCostUsd)}</Text>
+        </>
+      )}
+    </Box>
+  );
+}
+
+export const BuiltinStatusLine = React.memo(BuiltinStatusLineInner);

src/components/StatusLine.tsx

@@ -26,12 +26,13 @@ import { getRuntimeMainLoopModel, type ModelName, renderModelName } from '../uti
 import { getCurrentSessionTitle } from '../utils/sessionStorage.js';
 import { doesMostRecentAssistantMessageExceed200k, getCurrentUsage } from '../utils/tokens.js';
 import { getCurrentWorktreeSession } from '../utils/worktree.js';
+import { BuiltinStatusLine } from './BuiltinStatusLine.js';
 import { isVimModeEnabled } from './PromptInput/utils.js';
 export function statusLineShouldDisplay(settings: ReadonlySettings): boolean {
   // Assistant mode: statusline fields (model, permission mode, cwd) reflect the
   // REPL/daemon process, not what the agent child is actually running. Hide it.
   if (feature('KAIROS') && getKairosActive()) return false;
-  return settings?.statusLine !== undefined;
+  return true;
 }
 function buildStatusLineCommandInput(permissionMode: PermissionMode, exceeds200kTokens: boolean, settings: ReadonlySettings, messages: Message[], addedDirs: string[], mainLoopModel: ModelName, vimMode?: VimMode): StatusLineCommandInput {
   const agentType = getMainThreadAgentType();
@@ -139,6 +140,60 @@ function StatusLineInner({
   messagesRef,
   lastAssistantMessageId,
   vimMode
+}: Props): React.ReactNode {
+  const settings = useSettings();
+
+  if (settings?.statusLine) {
+    // External command path — all existing logic lives in ExternalStatusLine
+    return <ExternalStatusLine
+      messagesRef={messagesRef}
+      lastAssistantMessageId={lastAssistantMessageId}
+      vimMode={vimMode}
+    />;
+  }
+
+  // Built-in path
+  return <BuiltinStatusLineWrapper
+    messagesRef={messagesRef}
+    lastAssistantMessageId={lastAssistantMessageId}
+  />;
+}
+
+function BuiltinStatusLineWrapper({ messagesRef, lastAssistantMessageId }: {
+  messagesRef: React.RefObject<Message[]>;
+  lastAssistantMessageId: string | null;
+}): React.ReactNode {
+  const mainLoopModel = useMainLoopModel();
+  const permissionMode = useAppState(s => s.toolPermissionContext.mode);
+
+  // Compute exceeds200k only when message changes
+  const exceeds200kTokens = lastAssistantMessageId
+    ? doesMostRecentAssistantMessageExceed200k(messagesRef.current)
+    : false;
+
+  const runtimeModel = getRuntimeMainLoopModel({ permissionMode, mainLoopModel, exceeds200kTokens });
+  const modelDisplay = renderModelName(runtimeModel);
+  const currentUsage = getCurrentUsage(messagesRef.current);
+  const contextWindowSize = getContextWindowForModel(runtimeModel, getSdkBetas());
+  const contextPercentages = calculateContextPercentages(currentUsage, contextWindowSize);
+  const rawUtil = getRawUtilization();
+  const totalCost = getTotalCost();
+  const usedTokens = getTotalInputTokens() + getTotalOutputTokens();
+
+  return <BuiltinStatusLine
+    modelName={modelDisplay}
+    contextUsedPct={contextPercentages.used}
+    usedTokens={usedTokens}
+    contextWindowSize={contextWindowSize}
+    totalCostUsd={totalCost}
+    rateLimits={rawUtil}
+  />;
+}
+
+function ExternalStatusLine({
+  messagesRef,
+  lastAssistantMessageId,
+  vimMode
 }: Props): React.ReactNode {
   const abortControllerRef = useRef<AbortController | undefined>(undefined);
   const permissionMode = useAppState(s => s.toolPermissionContext.mode);

src/components/__tests__/BuiltinStatusLine.test.ts

@@ -0,0 +1,30 @@
+import { describe, test, expect } from 'bun:test'
+import { formatCountdown } from '../BuiltinStatusLine.js'
+
+describe('formatCountdown', () => {
+  const now = Date.now() / 1000
+
+  test('returns "now" for past time', () => {
+    expect(formatCountdown(now - 60)).toBe('now')
+  })
+
+  test('returns "now" for exactly zero diff', () => {
+    expect(formatCountdown(now)).toBe('now')
+  })
+
+  test('returns minutes for less than 1 hour', () => {
+    expect(formatCountdown(now + 45 * 60)).toBe('45m')
+  })
+
+  test('returns hours and minutes for less than 1 day', () => {
+    expect(formatCountdown(now + 3 * 3600 + 12 * 60)).toBe('3h12m')
+  })
+
+  test('returns hours with 0 minutes', () => {
+    expect(formatCountdown(now + 1 * 3600)).toBe('1h0m')
+  })
+
+  test('returns days and hours for 1+ days', () => {
+    expect(formatCountdown(now + 5 * 86400 + 20 * 3600)).toBe('5d20h')
+  })
+})