@pellux/goodvibes-tui 2.0.21 → 2.1.1

package/src/renderer/shell-surface.ts

@@ -1,98 +1,136 @@
 import type { Line } from '@pellux/goodvibes-sdk/platform/types';
-import { renderProcessIndicator, renderVoiceCaptureIndicator } from './process-indicator.ts';
+import { calcSessionCost, isModelPriced } from '@pellux/goodvibes-sdk/platform/providers';
 import { UIFactory } from './ui-factory.ts';
 import { voiceCaptureRowVisible, type VoiceCaptureIndicatorState } from '../core/voice-capture-status.ts';
+import { activeTokens, activeUiTones } from './theme.ts';
+import { permissionModeLabel } from '../core/permission-mode.ts';
+import { SLEEP_DISABLED_CHIP } from '../core/power-status.ts';
+import { renderComposer, COMPOSER_FIXED_ROWS } from './composer.ts';
+import { renderStatusLine, type StatusChip } from './status-line.ts';
+import { renderThrobberLine, type ThrobberState } from './throbber.ts';
+import { renderBackToBottomPill, type BackToBottomState } from './back-to-bottom.ts';
+import { voiceCaptureChip } from './voice-capture-chip.ts';
+import { tagFooterLine } from './footer-targets.ts';
+
+/**
+ * shell-surface.ts, everything under the transcript, top to bottom:
+ *
+ *   blank row     one full empty row under the transcript, drawn only when a
+ *                 text row follows (a half row cannot be drawn between two
+ *                 rows of plain text). An agent or process view's body
+ *                 already ends with one, so views skip it.
+ *   hint rows     the retry affordance, context pressure, the scriptable
+ *                 status line, when they have something to say
+ *   throbber      what main is doing right now, only while it works
+ *                 (throbber.ts)
+ *   back to bottom  the pill, centered, only while the output is scrolled
+ *                 away from its live bottom (back-to-bottom.ts); a fill row,
+ *                 so a full empty row keeps it off the text above it
+ *   input area    ▄ cap, padding, text, padding, ▀ cap (composer.ts): the
+ *                 caps are the half rows between the input area and the rows
+ *                 above and below it
+ *   status line   one row of session state
+ *
+ * At rest that is 6 rows (input area 5 + status 1), and with the header the
+ * resting chrome is 7. While main works, 2 more: the blank row and the
+ * throbber; while the output is scrolled back, 2 more: an empty row and the
+ * back-to-bottom pill. The input area holds only input (its placeholder,
+ * even while the keyboard is in the work tree). Token totals, the per-turn
+ * history, tool count, notification mode, the session spine and the web
+ * surface address live in the Usage modal and /status, not on the main
+ * screen. What stays always visible is safety: the approval mode and the
+ * auto-approve warning, the live microphone and the sleep-disabled chip (the
+ * left end of the status line), the failover marker (the header, after the
+ * model) and the compaction-pressure hint (a hint row above the input area).
+ */
+
+/**
+ * The work tree's keys, shown on the status line while the keyboard is in it.
+ * Esc leads: the way back to typing is never dropped for lack of room; the
+ * other keys give way from the end (status-line.ts keeps whole keys in order).
+ */
+const WORK_TREE_KEYS: ReadonlyArray<readonly [string, string]> = [
+  ['esc', 'back to typing'], ['↑↓', 'move between beads'], ['←→', 'fold / unfold'], ['enter', 'open'], ['y', 'copy'],
+];
+
+/** What an agent or process view changes under the transcript. */
+export interface ShellFooterView {
+  /** The composer bar: the agent's lane color, or the process color. */
+  readonly barColor: string;
+  readonly placeholder?: string;
+  /** The composer takes no input; this says why. */
+  readonly disabledReason?: string;
+  /** The view's keys on the status line (esc back to main, ctrl+x stop, …). */
+  readonly keys: ReadonlyArray<readonly [string, string]>;
+  /** After the keys: main kept in sight (◐ main · working). */
+  readonly trail?: { readonly text: string; readonly fg: string } | null;
+  /** A notice in place of the keys (press ctrl+x again to stop). */
+  readonly notice?: { readonly text: string; readonly tone: 'error' | 'info' } | null;
+  /** The process view shows no context bar or cost. */
+  readonly noContext?: boolean;
+  /** The cost this view states instead of the session's (an agent's own, when priced). */
+  readonly cost?: string | null;
+}
 
 export interface ShellFooterBuildOptions {
   readonly width: number;
+  /** The keyboard is in the conversation work tree: the status line shows its keys. */
+  readonly workTreeFocused?: boolean;
   readonly promptText: string;
   readonly promptLineCount: number;
   readonly promptCursorPos?: number;
   readonly promptFocused?: boolean;
-  /**
-   * True when the panel workspace owns keyboard focus. Only consulted as a
-   * fallback when `promptFocused` is not supplied, see buildShellFooter's
-   * default expression. Callers that already compute `promptFocused`
-   * themselves (main.ts does) do not need to also pass this.
-   */
-  readonly panelFocused?: boolean;
-  readonly usage: { up: number; down: number; fleetCostUsd?: number | null };
+  readonly usage: { up: number; down: number; cacheRead?: number; cacheWrite?: number; fleetCostUsd?: number | null };
   readonly showExitNotice: boolean;
   readonly lastCopyTime: number;
+  /** The model the session cost is priced against; not drawn (the header names the model). */
   readonly model?: string;
-  /**
-   * Divergence marker appended to the model segment while the serving backend
-   * is not the user's configured selection (core/active-model-identity.ts),
-   * e.g. "failover from abacusai:route-llm". Absent/empty in the normal case,
-   * where the context-info line renders exactly as it always has.
-   */
-  readonly modelNote?: string;
-  readonly toolCount?: number;
   readonly workingDir?: string;
-  readonly provider?: string;
-  readonly contextWindow?: number;
+  /** The home directory, drawn as ~ at the start of the working directory. */
+  readonly homeDirectory?: string;
+  /** An agent or process view is showing (session-focus.ts). */
+  readonly view?: ShellFooterView | null;
+  /** The current branch (and dirty marker), shown beside the directory at rest. */
+  readonly branch?: string;
+  /** The model's context window; null when it is unknown (the meter says "unknown"). */
+  readonly contextWindow?: number | null;
   readonly compactThreshold?: number;
   readonly dangerMode?: boolean;
   readonly lastInputTokens?: number;
   readonly commandArgsHint?: string;
-  readonly hitlMode?: string;
   readonly runningAgentCount: number;
   readonly runningProcessCount: number;
   readonly indicatorFocused: boolean;
   readonly runningAgentProgress?: string;
-  readonly composerMode?: string;
-  readonly composerStatus?: string;
   readonly composerFlags?: readonly string[];
   readonly composerPendingRisk?: 'none' | 'approval-wait' | 'shell' | 'command' | 'remote';
   /**
    * Current session permission mode (config value: 'prompt' | 'allow-all' |
-   * 'custom' | 'plan' | 'accept-edits'). Rendered as a pill in the composer
-   * posture block. Cycled by Shift+Tab and toggled by /plan.
+   * 'custom' | 'plan' | 'accept-edits'). Named by the status line's mode chip
+   * and colors the composer's bar. Cycled by Shift+Tab and toggled by /plan.
    */
   readonly permissionMode?: string;
-  /**
-   * Passive context pressure hint from buildContextStatusHint.
-   * Rendered as a dim informational line above the prompt when non-null.
-   */
+  /** Passive context pressure hint from buildContextStatusHint, a row above the composer. */
   readonly contextStatusHint?: string | null;
-  /**
-   * Output of the user's scriptable status line (`statusline.command`).
-   * Rendered as a dim informational line above the prompt when non-null,
-   * below the context pressure hint.
-   */
+  /** Output of the user's scriptable status line (`statusline.command`), a row above the composer. */
   readonly scriptableStatusLine?: string | null;
-  /**
-   * The one-key retry/switch-model affordance's transient hint text (see
-   * retry-affordance.ts). Rendered as its own line ABOVE the context
-   * pressure hint while armed; present here only means "show it now", the
-   * caller is responsible for passing null the instant it disarms, so this
-   * is a time-bounded status line, never a lingering claim.
-   */
+  /** The one-key retry/switch-model affordance's transient hint, topmost while armed. */
   readonly retryHint?: string | null;
-  /**
-   * Compact footer posture for short terminals (~<30 rows). Collapses the
-   * footer to its essentials (prompt box + token/cost line + help) and drops
-   * the process indicator, context bar, context-info line and posture block.
-   */
-  readonly compact?: boolean;
-  /**
-   * Cross-surface session-spine posture for the context-info segment.
-   * Set ONLY in adopted-daemon mode ('online'/'offline'); left undefined in
-   * local-only mode so no segment renders.
-   */
-  readonly sessionSpineStatus?: 'online' | 'offline';
-  /** The web surface's reachable URL, when that surface is enabled; a persistent footer segment. */
-  readonly webSurfaceUrl?: string;
   /** True while power.keepAwake holds, renders the always-visible "sleep disabled" chip. */
   readonly powerKeepAwake?: boolean;
+  /** Live microphone state; a non-null visible state renders the microphone chip. */
+  readonly voiceCapture?: VoiceCaptureIndicatorState | null;
+  /** What main is doing while it works (a turn, a compaction): the throbber row. Null at rest. */
+  readonly throbber?: ThrobberState | null;
+  /** A main turn is running: the status line leads with what Esc does now (interrupt, or clear input). */
+  readonly turnRunning?: boolean;
   /**
-   * Live microphone state, a push-to-talk recording, or the wake detector for
-   * as long as it runs. Rendered as a persistent row beside the process
-   * indicator, because a capture device held open with nothing on screen saying
-   * so is the one state a voice feature must never be in. Null (or a wake state
-   * with `voice.wake.indicator: off`) renders nothing.
+   * The output is scrolled away from its live bottom: the back-to-bottom pill
+   * shows above the input area, and a running turn's esc hint says "back to
+   * bottom" (Esc returns there and never interrupts while scrolled). Null or
+   * absent at the bottom.
    */
-  readonly voiceCapture?: VoiceCaptureIndicatorState | null;
+  readonly backToBottom?: BackToBottomState | null;
 }
 
 export interface ShellFooterBuildResult {
@@ -100,35 +138,21 @@ export interface ShellFooterBuildResult {
   readonly height: number;
 }
 
-// Fixed rows that createFooter always emits (non-compact): prompt-box top
-// border, prompt-box bottom border, token-usage line, context-info line, and
-// the help/exit line. The composer posture block and context bar are counted
-// separately (they are conditional).
-const FOOTER_BASE_ROWS = 5;
-const CONTEXT_PROGRESS_ROWS = 1;
-const PROCESS_INDICATOR_ROWS = 1;
-/** The live-microphone row, when one is showing (see renderVoiceCaptureIndicator). */
-const VOICE_CAPTURE_ROWS = 1;
-// Compact posture drops the context-info line (and never shows the context
-// bar or process indicator), leaving just: prompt-box top border, bottom
-// border, token-usage line, and the help/exit line.
-const COMPACT_FOOTER_BASE_ROWS = 4;
-
-// Dim slate foreground shared by the passive footer status lines (context
-// pressure hint and the scriptable status line).
-const DIM_STATUS_FG = '#64748b';
+/** The status line under the composer. */
+const STATUS_ROWS = 1;
+
+function blankRow(width: number): Line {
+  const line = UIFactory.stringToLine('', width);
+  for (const cell of line) cell.bg = '';
+  return line;
+}
 
 /**
- * Real height of the most recently rendered footer, tagged with the compact
- * posture it was rendered under. estimateShellFooterHeight prefers this so
- * the pre-prompt viewport math accounts for the composer posture block and
- * context hint that the static formula cannot see. Reset to null before any
- * footer has rendered (cold start), where the formula is exact for the
- * common posture-free, hint-free case. The compact flag is part of the cache
- * key: a cached non-compact height must never answer a compact query (and
- * vice versa), since the two postures differ by several rows.
+ * Real height of the most recently rendered footer. estimateShellFooterHeight
+ * prefers it so the pre-render viewport math accounts for the hint rows the
+ * static formula cannot see. Null before any footer has rendered.
  */
-let lastRenderedFooterHeight: { compact: boolean; height: number } | null = null;
+let lastRenderedFooterHeight: number | null = null;
 
 /**
  * The wrapped-prompt shape the composer reports each frame, the subset
@@ -142,13 +166,8 @@ export interface WrappedPromptCursorInfo {
 
 /**
  * Flatten a wrapped-prompt cursor position (line + column) into the single
- * character offset createFooter's `cursorPos` expects, counting one separator
- * per wrapped line. Returns undefined when the cursor is not on a visible line
- * (scrolled out of the composer's window), which suppresses the cursor overlay
- * rather than drawing it in the wrong place.
- *
- * Lives here rather than inline at the render site so main.ts (a composition
- * root already at the source-line gate) stays a wiring file.
+ * character offset the composer's `cursorPos` expects, counting one separator
+ * per wrapped line. Undefined when the cursor is not on a visible line.
  */
 export function promptCursorOffset(info: WrappedPromptCursorInfo): number | undefined {
   if (info.visibleCursorLine < 0) return undefined;
@@ -158,92 +177,175 @@ export function promptCursorOffset(info: WrappedPromptCursorInfo): number | unde
   return precedingChars + info.visibleCursorCol;
 }
 
-export function estimateShellFooterHeight(
-  promptLineCount: number,
-  contextWindow?: number,
-  compact = false,
-  voiceCapture: VoiceCaptureIndicatorState | null = null,
-): number {
-  if (lastRenderedFooterHeight !== null && lastRenderedFooterHeight.compact === compact) {
-    return lastRenderedFooterHeight.height;
+/** Rows the footer will take for this many prompt rows (exact when no hint rows show). */
+export function estimateShellFooterHeight(promptLineCount: number): number {
+  if (lastRenderedFooterHeight !== null) return lastRenderedFooterHeight;
+  return COMPOSER_FIXED_ROWS + Math.max(1, promptLineCount) + STATUS_ROWS;
+}
+
+/** The composer's bar color: the session mode, or shell while a shell command is typed. */
+function composerBarColor(permissionMode: string | undefined, shell: boolean): string {
+  const t = activeTokens();
+  if (shell) return t.accent;
+  switch (permissionMode) {
+    case 'plan': return t.info;
+    case 'accept-edits':
+    case 'allow-all':
+    case 'custom':
+      return t.warning;
+    default:
+      return t.brand;
   }
-  const safePromptLines = Math.max(1, promptLineCount);
-  if (compact) {
-    return COMPACT_FOOTER_BASE_ROWS + safePromptLines;
+}
+
+/**
+ * The status line's mode chip: the approval mode (muted; plan in the info
+ * color), or "! auto-approve" in the error color while everything is
+ * auto-approved. While the warning shows, only plan keeps its name beside it
+ * (a read-only posture still worth knowing); "normal" or "auto" next to it
+ * would only repeat or contradict it.
+ */
+function modeChips(permissionMode: string | undefined, dangerMode: boolean): StatusChip[] {
+  const t = activeTokens();
+  const chips: StatusChip[] = [];
+  if (!dangerMode || permissionMode === 'plan') {
+    chips.push({ text: permissionModeLabel(permissionMode), fg: permissionMode === 'plan' ? t.info : t.textMuted, bold: permissionMode === 'plan', keep: true });
   }
-  const progressRows = contextWindow && contextWindow > 0 ? CONTEXT_PROGRESS_ROWS : 0;
-  // Counted on the cold-start path too: a shell launched with the wake detector
-  // already listening renders that row in its very first frame, and a viewport
-  // sized one row too tall would draw the transcript's last line under it.
-  const voiceRows = voiceCaptureRowVisible(voiceCapture) ? VOICE_CAPTURE_ROWS : 0;
-  return FOOTER_BASE_ROWS + safePromptLines + progressRows + PROCESS_INDICATOR_ROWS + voiceRows;
+  if (dangerMode) chips.push({ text: '! auto-approve', fg: t.error, bold: true, keep: true });
+  return chips;
+}
+
+/** The chips no view hides: auto-approve, the live microphone, sleep disabled. */
+function safetyChips(options: ShellFooterBuildOptions): StatusChip[] {
+  const t = activeTokens();
+  const chips: StatusChip[] = [];
+  if (options.dangerMode) chips.push({ text: '! auto-approve', fg: t.error, bold: true, keep: true });
+  const voice = options.voiceCapture ?? null;
+  if (voice && voiceCaptureRowVisible(voice)) chips.push(voiceCaptureChip(voice));
+  if (options.powerKeepAwake) chips.push({ text: SLEEP_DISABLED_CHIP, fg: t.warning, bold: true, keep: true });
+  return chips;
+}
+
+/** Format a USD amount with a precision that suits its magnitude. */
+function fmtCost(usd: number): string {
+  if (!(usd > 0)) return '0.00';
+  if (usd < 0.01) return usd.toFixed(4);
+  if (usd < 1) return usd.toFixed(3);
+  return usd.toFixed(2);
+}
+
+/** "~$0.246", or "you ~$0.25 · fleet ~$0.47" once delegated agents have cost something (estimates, hence the ~). */
+export function statusCostText(usage: ShellFooterBuildOptions['usage'], model: string | undefined): string | null {
+  const inp = usage.up;
+  const out = usage.down;
+  const main = model && isModelPriced(model)
+    ? `~$${fmtCost(calcSessionCost(inp, out, usage.cacheRead ?? 0, usage.cacheWrite ?? 0, model))}`
+    : null;
+  const fleet = usage.fleetCostUsd;
+  if (typeof fleet === 'number' && fleet > 0) return `you ${main ?? '~n/a'} · fleet ~$${fmtCost(fleet)}`;
+  return main;
+}
+
+function displayDirectory(workingDir: string | undefined, homeDirectory: string | undefined): string | undefined {
+  if (!workingDir) return undefined;
+  const home = homeDirectory ?? (typeof process !== 'undefined' ? process.env.HOME ?? '' : '');
+  if (!home) return workingDir;
+  if (workingDir === home) return '~';
+  return workingDir.startsWith(home.endsWith('/') ? home : `${home}/`) ? '~' + workingDir.slice(home.replace(/\/$/, '').length) : workingDir;
 }
 
-export function buildShellFooter(
-  options: ShellFooterBuildOptions,
-): ShellFooterBuildResult {
-  const lines = UIFactory.createFooter(
-    options.width,
-    options.promptText,
-    options.usage,
-    options.showExitNotice,
-    options.lastCopyTime,
-    options.model,
-    options.toolCount,
-    options.promptCursorPos,
-    options.workingDir,
-    options.provider,
-    options.contextWindow,
-    options.compactThreshold,
-    options.dangerMode,
-    options.lastInputTokens,
-    options.commandArgsHint,
-    options.hitlMode,
-    options.promptFocused ?? (!options.indicatorFocused && !options.panelFocused),
-    options.composerMode,
-    options.composerStatus,
-    options.composerFlags,
-    options.composerPendingRisk,
-    options.compact ?? false,
-    options.sessionSpineStatus,
-    options.permissionMode,
-    options.webSurfaceUrl,
-    options.powerKeepAwake,
-    options.modelNote,
-  );
-  // Compact posture drops the process indicator and context hint entirely so
-  // the footer fits within ~5 rows on short terminals.
-  if (!options.compact) {
-    const processIndicator = renderProcessIndicator(
-      options.width,
-      options.runningAgentCount,
-      options.runningProcessCount,
-      options.indicatorFocused,
-      options.runningAgentProgress,
-    );
-    const inputBoxRows = Math.max(1, options.promptLineCount) + 2;
-    // The voice row sits directly under the prompt box, ABOVE the process
-    // indicator: an open microphone is a live condition the user is acting inside,
-    // while the process indicator is a background summary.
-    lines.splice(inputBoxRows, 0, ...renderVoiceCaptureIndicator(options.width, options.voiceCapture ?? null), ...processIndicator);
-    // Scriptable status line, dim informational line above the prompt. Unshifted
-    // before the context hint so the context hint (if any) sits above it.
-    if (options.scriptableStatusLine) {
-      lines.unshift(UIFactory.stringToLine(options.scriptableStatusLine, options.width, { fg: DIM_STATUS_FG }));
-    }
-    // Passive context status hint, rendered as a dim informational line before the prompt.
-    if (options.contextStatusHint) {
-      const hintLine = UIFactory.stringToLine(options.contextStatusHint, options.width, { fg: DIM_STATUS_FG });
-      lines.unshift(hintLine);
-    }
-    // Retry affordance, topmost of the passive hint lines while armed (an
-    // actionable, time-bounded prompt outranks the passive status hints
-    // below it); simply absent the instant it disarms.
-    if (options.retryHint) {
-      const retryLine = UIFactory.stringToLine(options.retryHint, options.width, { fg: DIM_STATUS_FG, bold: true });
-      lines.unshift(retryLine);
-    }
+export function buildShellFooter(options: ShellFooterBuildOptions): ShellFooterBuildResult {
+  const t = activeTokens();
+  const lines: Line[] = [];
+  const view = options.view ?? null;
+  // Passive hint rows, topmost first: the retry affordance (actionable, time
+  // bounded), the context pressure hint, then the user's scriptable line.
+  const above: Line[] = [];
+  if (options.retryHint) above.push(UIFactory.stringToLine(`   ${options.retryHint}`, options.width, { fg: t.textMuted, bold: true }));
+  if (options.contextStatusHint) above.push(UIFactory.stringToLine(`   ${options.contextStatusHint}`, options.width, { fg: t.textMuted }));
+  if (options.scriptableStatusLine) above.push(UIFactory.stringToLine(`   ${options.scriptableStatusLine}`, options.width, { fg: t.textMuted }));
+  // The throbber: main's activity, led by "main" inside a view.
+  if (options.throbber) above.push(renderThrobberLine(options.width, view ? { ...options.throbber, owner: 'main' } : options.throbber));
+  // The back-to-bottom pill is a fill row: a full empty row keeps it off any text row above it.
+  if (options.backToBottom) {
+    if (above.length > 0) above.push(blankRow(options.width));
+    above.push(renderBackToBottomPill(options.width, options.backToBottom));
+  }
+  // A full empty row keeps these rows off the transcript (a view's body ends with one already).
+  if (above.length > 0 && !view) lines.push(blankRow(options.width));
+  lines.push(...above);
+
+  const focused = options.promptFocused ?? !options.indicatorFocused;
+  lines.push(...renderComposer({
+    width: options.width,
+    promptText: options.promptText,
+    cursorPos: options.promptCursorPos,
+    focused,
+    argsHint: options.commandArgsHint,
+    modeColor: view ? view.barColor : composerBarColor(options.permissionMode, options.composerPendingRisk === 'shell'),
+    placeholder: view?.placeholder,
+    disabledReason: view?.disabledReason,
+  }));
+
+  // The left end of the status line: mode, auto-approve, microphone and
+  // sleep are kept at any width; the composer flags are dropped first.
+  const chips: StatusChip[] = modeChips(options.permissionMode, options.dangerMode === true);
+  const voice = options.voiceCapture ?? null;
+  if (voice && voiceCaptureRowVisible(voice)) chips.push(voiceCaptureChip(voice));
+  if (options.powerKeepAwake) chips.push({ text: SLEEP_DISABLED_CHIP, fg: t.warning, bold: true, keep: true });
+  for (const flag of options.composerFlags ?? []) {
+    if (flag === 'shell') continue; // the bar's accent color says shell
+    // An orchestration request leaves this terminal: its flag carries the remote color.
+    const remote = flag === 'orchestration' && options.composerPendingRisk === 'remote';
+    chips.push({ text: flag, fg: remote ? activeUiTones().chrome.remote : t.textFaint, bold: remote });
+  }
+
+  const copied = Date.now() - options.lastCopyTime < 2000;
+  if (view) {
+    // Inside an agent or process view: its keys (what Esc does first), then main kept in sight.
+    lines.push(tagFooterLine(renderStatusLine({
+      width: options.width,
+      chips: safetyChips(options),
+      notice: options.showExitNotice ? { text: 'Press Ctrl+C again to exit', tone: 'error' } : view.notice ?? (copied ? { text: 'Copied', tone: 'info' } : null),
+      keys: view.keys,
+      // While main works its throbber names what it does; the trail would only repeat "working".
+      trail: options.throbber ? null : view.trail ?? null,
+      cost: view.noContext ? null : view.cost ?? null,
+      context: null,
+    }), 'usage'));
+    lastRenderedFooterHeight = lines.length;
+    return { lines, height: lines.length };
   }
-  lastRenderedFooterHeight = { compact: options.compact ?? false, height: lines.length };
+  // A click anywhere on the status line (the context bar, the cost) opens Usage.
+  lines.push(tagFooterLine(renderStatusLine({
+    width: options.width,
+    chips,
+    notice: options.showExitNotice
+      ? { text: 'Press Ctrl+C again to exit', tone: 'error' }
+      : copied ? { text: 'Copied', tone: 'info' } : null,
+    // With text in the composer the next Esc clears it; scrolled back, it returns to the
+    // bottom; only an empty composer's Esc at the bottom interrupts.
+    busy: options.turnRunning ? { escAction: options.promptText.trim().length > 0 ? 'clear input' : options.backToBottom ? 'back to bottom' : undefined } : null,
+    keys: options.workTreeFocused ? WORK_TREE_KEYS : null,
+    directory: displayDirectory(options.workingDir, options.homeDirectory),
+    branch: options.branch,
+    background: {
+      agents: options.runningAgentCount,
+      processes: options.runningProcessCount,
+      focused: options.indicatorFocused,
+      progress: options.runningAgentProgress,
+    },
+    cost: statusCostText(options.usage, options.model),
+    // null: the model's window is unknown, and the meter says so; 0 or
+    // undefined: no meter (no model yet).
+    context: options.contextWindow === null || (options.contextWindow !== undefined && options.contextWindow > 0)
+      ? {
+          usedTokens: options.lastInputTokens ?? 0,
+          windowTokens: options.contextWindow,
+          compactFraction: options.compactThreshold && options.compactThreshold > 0 ? options.compactThreshold : 0.85,
+        }
+      : null,
+  }), 'usage'));
+  lastRenderedFooterHeight = lines.length;
   return { lines, height: lines.length };
 }