@erichll/pi-statusline 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.2.0 - 2026-10-04
+
+- Use the same muted color for No content and Avg; default modelDisplay to name while preserving explicit last preferences.
+- Remove Minimal and the preset selector; support only Powerline, without migration for retired preset values.
+- Make Powerline the default with Nerd icons, Powerline separators, model display name, basename paths, context bar and total tokens enabled; ship the layout as the example configuration.
+- Omit the startup/idle footer label and its separator.
+- Lead the second row with one Elapsed duration; reuse explicit `tps` Elapsed display text without an extra Running/Done duration.
+- Track monotonic runs through retries, tools, UI waits and compaction until `agent_settled`; retain the final run's footer summary.
+- Add ID-based concurrent/nested tool activity, UI-wait precedence and configurable non-empty-content observation warnings (ten seconds by default).
+- Add assistant-only per-run usage, whole-run average output rate and cache-read ratio without changing cumulative session totals.
+- Add compaction activity/result and whole-session successful compaction counts.
+- Remove the Until compact metric, its runtime setting and compaction-capacity calculation.
+- Add runtime settings with draft preview, numeric validation and backward-compatible version-1 partial configuration.
+- Keep statistics limited to existing provider statuses and Pi public events/usage; do not expose unsupported request-level metrics or require provider changes. Ignore and drop obsolete experimental request/integration configuration on save.
+- Remove the read-only run details command/panel; retain footer statistics, configuration and live preview.
+- Expand lifecycle/configuration/render tests and isolated offline PTY smoke across regular/fullscreen layouts.
+
 ## 0.1.0 - 2026-10-03
 
 - Make bar mode the default and use whole cells to avoid visual gaps from partial glyphs; non-zero usage fills at least one cell.

package/README.md

@@ -1,10 +1,10 @@
 # @erichll/pi-statusline
 
-A configurable footer for Pi 1.0 with Git status, session usage, themes, and live configuration preview. Uses Pi's native footer and leaves the editor intact.
+A configurable footer for Pi 1.0 with Git status, session usage, runtime/tool activity, themes, and live configuration preview. Uses Pi's native footer and leaves the editor intact.
 
 ```text
- Model(high) | ◉ [█░░░░░░░░░]11.9% | ▸ pi-packages | ⑂ main ● *2 ↑2
-extension status text, when available
+  Example model(high)  󰆼 [█░░░░░░░░░]11.9%  󰉋 pi-packages   main ● *2 ↑2  󰊄 49.4k
+Elapsed 5m 42s · Avg 45 tok/s · Cache 86% · Turns 3 · Compactions 1
 ```
 
 ## Install
@@ -13,7 +13,9 @@ extension status text, when available
 pi install npm:@erichll/pi-statusline
 ```
 
-Requires Node.js >=22.19, Pi >=1.0.0, and optionally Git. The package has no
+Requires Node.js >=22.19, Pi >=1.0.0, a Nerd Font for the default Powerline layout,
+and optionally Git. Switch icons/separators in the panel for a font-independent
+layout. The package has no
 other runtime dependencies and makes no network requests or credential lookups.
 Only one extension should own Pi's footer, so disable any other footer
 extension in `pi config` before enabling this one.
@@ -49,6 +51,8 @@ published package, `npm:@erichll/pi-statusline`.
 The panel supports arrow navigation, Space to toggle a segment, Alt+Up/Down to
 reorder it, and Enter to edit its properties. Choose **Save and apply globally**
 to persist the draft. Esc backs out of a property editor or cancels the panel.
+**Runtime options** edits the same draft; Space toggles booleans and Enter edits
+the no-content threshold.
 **Restore defaults in preview** changes only the draft until saved.
 Preview uses the real footer renderer and current session data, or clearly
 labelled example data for an empty session. A save error leaves the active
@@ -69,32 +73,93 @@ existing file to the new path before running `/reload`; the old path is no longe
 {
   "version": 1,
   "enabled": true,
-  "preset": "cometix",
-  "icons": "unicode",
-  "separator": "pipe",
+  "preset": "powerline",
+  "icons": "nerd",
+  "separator": "powerline",
   "pathMode": "basename",
   "modelDisplay": "name",
-  "contextDisplay": "bar"
+  "contextDisplay": "bar",
+  "segments": [
+    {
+      "id": "model",
+      "enabled": true
+    },
+    {
+      "id": "thinking",
+      "enabled": true
+    },
+    {
+      "id": "context",
+      "enabled": true
+    },
+    {
+      "id": "directory",
+      "enabled": true
+    },
+    {
+      "id": "git",
+      "enabled": true
+    },
+    {
+      "id": "cost",
+      "enabled": false
+    },
+    {
+      "id": "input",
+      "enabled": false
+    },
+    {
+      "id": "output",
+      "enabled": false
+    },
+    {
+      "id": "tokens",
+      "enabled": true
+    },
+    {
+      "id": "cacheRead",
+      "enabled": false
+    },
+    {
+      "id": "cacheWrite",
+      "enabled": false
+    },
+    {
+      "id": "statuses",
+      "enabled": true
+    }
+  ],
+  "runtime": {
+    "enabled": true,
+    "status": true,
+    "tools": true,
+    "noContent": true,
+    "noContentSeconds": 10,
+    "avg": true,
+    "cache": true,
+    "counts": true,
+    "retainSummary": true
+  }
 }
 ```
 
-- Presets: `cometix` (default), `minimal`, `powerline`. Choosing a preset in the
-  panel resets segment order and style overrides. Pi's current light/dark theme
-  supplies semantic colors; Powerline backgrounds adapt to its appearance.
-- Icons: `unicode` (default), `nerd` (requires a Nerd Font), `ascii`. ASCII mode
+- Layout: `powerline` is the only preset; there is no preset selector.
+  Customize segments and styles directly, or restore defaults in preview.
+  Pi's current light/dark theme supplies semantic colors; Powerline backgrounds
+  adapt to its appearance.
+- Icons: `nerd` (default; requires a Nerd Font), `unicode`, `ascii`. ASCII mode
   replaces built-in decorative glyphs, not user-provided names or custom icons.
   Both graphical modes use `` for the model by default; this glyph requires a
   Nerd Font. A custom model icon still overrides the default.
-- Separators: `pipe`, `dot`, `space`, `powerline`. ASCII mode uses plain separators.
+- Separators: `powerline` (default), `pipe`, `dot`, `space`. ASCII mode uses plain separators.
 - Paths: `basename`, `abbreviated`, `full` (home directory abbreviated as `~`).
-- Model display: `name` (default, display name with full ID fallback) or `last`
-  (the final non-empty `/`-separated component of the **model ID**, even when a
-  display name is configured). For example, `provider/a/b/c/d` becomes `d`.
-  Set `"modelDisplay": "last"` or select **Model display: last** in the panel.
-  Switching presets preserves this preference; restoring defaults resets it.
+- Model display: `name` (default) uses the display name with full ID fallback.
+  Choose `last` for the final non-empty `/`-separated component of the **model ID**,
+  even when a display name is configured. For example, `provider/a/b/c/d` becomes `d`.
+  Restoring defaults resets this preference to `name`.
 - Context display: `bar` (default, `[██░░░░░░░░]20%`) or `text`
   (`12.7k/272k(4.7%)`). Choose **Context display: bar** in the panel or set
-  `"contextDisplay": "bar"`. Switching presets preserves this preference.
+  `"contextDisplay": "bar"`.
   The ten-cell bar uses whole blocks to avoid gaps inside partial glyphs. Fill
   rounds to the nearest cell, with at least one filled cell for non-zero usage;
   the percentage retains the more precise value. ASCII mode uses `#` and `-`.
@@ -133,15 +198,77 @@ Available segments:
 | `directory` | Current working directory | On |
 | `git` | Branch, clean/dirty/conflict, staged `+`, unstaged `*`, untracked `?`, ahead/behind | On |
 | `cost` | Pi-recorded cumulative USD cost; enable in the panel when wanted | Off |
-| `input`, `output`, `tokens` | Cumulative input, output, or total tokens | Off |
+| `tokens` | Cumulative total tokens | On |
+| `input`, `output` | Cumulative input or output tokens | Off |
 | `cacheRead`, `cacheWrite` | Cumulative cache token counts | Off |
-| `statuses` | Other extensions' `setStatus()` text, with terminal controls stripped | On |
+| `statuses` | Other extensions' `setStatus()` text on the runtime row, with terminal controls stripped | On |
 
-The minimal preset enables directory, Git, context, and extension statuses.
+The default Powerline preset enables model/thinking, context, directory, Git, total
+tokens and extension statuses. Cost, input/output and cache token counters stay off.
 See [examples/statusline.json](examples/statusline.json) for an explicit layout.
-Unknown versions, duplicate segments, invalid colors and malformed JSON are
+Unknown presets or versions, duplicate segments, invalid colors and malformed JSON are
 rejected with a notification; reload retains the last working configuration.
 Removing the file restores defaults on reload. Saves use an atomic file replacement.
+Obsolete `runtime.untilCompact`, `providerMetrics` and `integrations` keys are
+ignored and dropped on the next save; they do not require a configuration migration.
+
+## Runtime row and compaction
+
+Runtime metrics use Pi's public events and reported usage, without modifying the
+provider. `Elapsed`
+leads the second row; no additional `Running 342s` or `Done 342s` duration is
+shown. A run starts at the first `agent_start` and ends at `agent_settled`, not
+`agent_end`. Retries, tools, UI waits and compaction do not reset its monotonic
+clock. `retainSummary` keeps the last run's footer summary until the next run
+(disable it to hide the run summary at settlement). The idle
+footer has no Idle label or leading separator.
+
+- `Turns` counts Pi `turn_start` events, not upstream requests. Internal retries
+  may make more than one request in a turn; no request count is inferred from
+  turn events. Compaction does not increase the model-turn count.
+- Tool activity is keyed by tool-call ID, including concurrent/nested calls and
+  updates. It shows `Tool bash 26s` or `Tools 2 active`; tools cannot decide the
+  model run's outcome. Pi UI prompts take precedence with `Awaiting input`.
+- `No content 10s` means **no non-empty text, reasoning or tool-call delta has
+  been observed** for ten seconds. It uses the same muted color as Avg.
+  It is not a server timeout or request phase.
+  Tools, compaction and UI waits suppress it. The integer threshold accepts
+  1–3600 seconds. Empty deltas and usage-only updates do not reset it.
+- Per-run usage includes only actual assistant messages. Streaming counters are
+  replaced, not repeatedly added. `Avg = output tokens / total run seconds`,
+  including tools, UI waits, retries and compaction; it is not inference speed.
+  `Cache = cacheRead / (input + cacheRead + cacheWrite)`. Missing usage/invalid
+  denominators are unavailable, not made-up zeroes. A genuinely reported zero
+  remains zero. These values never replace cumulative session totals.
+- `Compacting… 4s` suppresses rate/cache noise while
+  compaction is active. Success restores the base row; failure/cancellation can
+  show `Compaction failed` / `Compaction cancelled` while no model run is active,
+  until subsequent activity.
+- `Compactions` counts unique successful entries across the **whole session file**,
+  including other branches, not merely the selected tree path.
+`runtime.enabled: false` hides the statusline's runtime metrics. Individual
+options hide their corresponding items; `status` controls the local Elapsed
+and compaction-result labels. The `statuses` segment independently controls other
+extensions' text. If its `tps` entry is precisely a plain `Elapsed …` duration,
+that display text is moved to the front and replaces the local Elapsed item.
+All other statuses remain opaque text: they are never parsed into counters or
+provider metrics. The provider's Elapsed may use its own pause
+semantics; Avg always uses the independent monotonic run clock.
+
+Runtime summaries are in-memory since extension load; reload/new session resets
+them, unlike persisted usage/compaction totals.
+
+## Existing provider statuses
+
+The CLIProxyAPI provider already publishes an Elapsed footer status through
+`setStatus("tps", ...)` and a TPS/token-summary notification at settlement. The
+statusline can reuse the explicit Elapsed text; it does not parse the notification.
+Its own Avg and Cache come from Pi-reported assistant usage and the local run clock.
+
+No provider changes, adapter handshake or private network instrumentation are
+required. Request counts, first-text/reasoning request latency, per-request duration,
+transport reporting and retry associations are not exposed by this package. The
+provider may implement transports/retries internally without exposing these metrics.
 
 ## Statistics and refresh behavior
 
@@ -171,7 +298,9 @@ Rendering performs no file reads, Git queries or full-session scans. Streaming
 refresh requests are coalesced to 100 ms. Narrow terminals shorten model/path
 labels, then hide cost, cache/token counters, the thinking suffix, Git and directory in
 that order, retaining model/context where possible. The secondary status row
-is truncated to fit. Reload, session replacement, disabling and shutdown
+drops extension text and cache/rate first, preserving
+leading Elapsed and compaction status where possible, then truncates by terminal
+cell width. Reload, session replacement, disabling and shutdown
 release timers and subscriptions. RPC, JSON and print mode do not install UI
 components or start polling.
 
@@ -184,8 +313,13 @@ npm test --workspace @erichll/pi-statusline
 npm run smoke --workspace @erichll/pi-statusline
 ```
 
-Tests cover rendering and panel interactions, configuration persistence, session
-usage/lifecycle, and real temporary Git repositories. To roll back a persistent
+Tests cover rendering and panel interactions, configuration persistence, runtime
+and extension-event wiring, compaction, session usage and real temporary Git
+repositories. The POSIX PTY smoke runs **regular and fullscreen**, with isolated
+agent/project directories and an entirely offline provider. It covers streaming, nested tools/UI waits,
+no-content/cancellation, failed/successful compaction, model/theme changes,
+40-column layout, draft cancel/save, off/on, reload and new session. It writes
+`/tmp/pi-statusline-pty-<layout>.log` for diagnosis. To roll back a persistent
 installation, disable this extension in `pi config`, re-enable the previous
 footer and reload Pi. `/statusline off` restores the native footer, not another
 extension's editor or widgets.

package/examples/statusline.json

@@ -1,19 +1,71 @@
 {
   "version": 1,
   "enabled": true,
-  "preset": "cometix",
-  "icons": "unicode",
-  "separator": "pipe",
+  "preset": "powerline",
+  "icons": "nerd",
+  "separator": "powerline",
   "pathMode": "basename",
   "modelDisplay": "name",
   "contextDisplay": "bar",
   "segments": [
-    { "id": "model", "enabled": true, "color": "accent" },
-    { "id": "thinking", "enabled": true },
-    { "id": "context", "enabled": true },
-    { "id": "directory", "enabled": true },
-    { "id": "git", "enabled": true },
-    { "id": "cost", "enabled": false },
-    { "id": "statuses", "enabled": true }
-  ]
+    {
+      "id": "model",
+      "enabled": true
+    },
+    {
+      "id": "thinking",
+      "enabled": true
+    },
+    {
+      "id": "context",
+      "enabled": true
+    },
+    {
+      "id": "directory",
+      "enabled": true
+    },
+    {
+      "id": "git",
+      "enabled": true
+    },
+    {
+      "id": "cost",
+      "enabled": false
+    },
+    {
+      "id": "input",
+      "enabled": false
+    },
+    {
+      "id": "output",
+      "enabled": false
+    },
+    {
+      "id": "tokens",
+      "enabled": true
+    },
+    {
+      "id": "cacheRead",
+      "enabled": false
+    },
+    {
+      "id": "cacheWrite",
+      "enabled": false
+    },
+    {
+      "id": "statuses",
+      "enabled": true
+    }
+  ],
+  "runtime": {
+    "enabled": true,
+    "status": true,
+    "tools": true,
+    "noContent": true,
+    "noContentSeconds": 10,
+    "avg": true,
+    "cache": true,
+    "counts": true,
+    "retainSummary": true
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@erichll/pi-statusline",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Configurable Pi statusline with live preview, Git and session usage",
   "type": "module",
   "license": "MIT",

package/src/compaction.ts

@@ -0,0 +1,32 @@
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
+import type { Clock } from "./runtime.ts";
+import { safeReason } from "./text.ts";
+
+export interface CompactionSnapshot {
+  active: boolean;
+  elapsedMs: number;
+  count: number;
+  last?: { status: "success" | "failed" | "cancelled"; reason?: string };
+  showFailure: boolean;
+}
+export class CompactionState {
+  private clock: Clock;
+  private started: number | null = null;
+  private ids = new Set<string>();
+  private last: CompactionSnapshot["last"];
+  private showFailure = false;
+  constructor(clock: Clock = () => performance.now()) { this.clock = clock; }
+  start(): void { if (this.started === null) this.started = this.clock(); this.showFailure = false; }
+  finish(status: "success" | "failed" | "cancelled", id?: string, reason?: string): void {
+    this.started = null; if (status === "success" && id) this.ids.add(id);
+    this.last = { status, ...(reason ? { reason: safeReason(reason) } : {}) }; this.showFailure = status !== "success";
+  }
+  activity(): void { this.showFailure = false; }
+  update(entries: readonly SessionEntry[]): void {
+    // getEntries contains the entire file, including compactions on other branches.
+    this.ids = new Set(entries.filter((entry) => entry.type === "compaction").map((entry) => entry.id));
+  }
+  snapshot(): CompactionSnapshot {
+    return { active: this.started !== null, elapsedMs: this.started === null ? 0 : Math.max(0, this.clock() - this.started), count: this.ids.size, last: this.last, showFailure: this.showFailure };
+  }
+}

package/src/config.ts

@@ -1,7 +1,7 @@
 import { mkdir, open, readFile, rename, unlink } from "node:fs/promises";
 import { dirname } from "node:path";
 import { randomUUID } from "node:crypto";
-import type { ColorValue, Preset, StatuslineConfig } from "./types.ts";
+import type { ColorValue, StatuslineConfig } from "./types.ts";
 import { SEGMENT_IDS } from "./types.ts";
 
 // A deliberately small, documented set of Pi semantic foreground colors.
@@ -9,15 +9,13 @@ export const COLORS = ["text", "accent", "muted", "dim", "success", "warning", "
 export function validColor(value: unknown): value is ColorValue {
   return typeof value === "string" && (/^#[\da-f]{6}$/i.test(value) || (COLORS as readonly string[]).includes(value));
 }
-export function presetConfig(preset: Preset = "cometix"): StatuslineConfig {
-  const enabled = new Set<string>(preset === "minimal" ? ["directory", "git", "context", "statuses"] : ["model", "thinking", "directory", "git", "context", "statuses"]);
+export function presetConfig(): StatuslineConfig {
+  const enabled = new Set<string>(["model", "thinking", "directory", "git", "context", "tokens", "statuses"]);
   return {
-    version: 1, enabled: true, preset, icons: "unicode",
-    separator: preset === "powerline" ? "powerline" : "pipe", pathMode: "basename", modelDisplay: "name", contextDisplay: "bar",
+    version: 1, enabled: true, preset: "powerline", icons: "nerd",
+    separator: "powerline", pathMode: "basename", modelDisplay: "name", contextDisplay: "bar",
     segments: SEGMENT_IDS.map((id) => ({ id, enabled: enabled.has(id) })),
-    runtime: { enabled: true, status: true, tools: true, noContent: true, noContentSeconds: 10, avg: true, cache: true, counts: true, untilCompact: true, retainSummary: true },
-    providerMetrics: { phase: true, firstText: true, firstReasoning: true, duration: false, transport: false },
-    integrations: { cliproxyapi: "auto" },
+    runtime: { enabled: true, status: true, tools: true, noContent: true, noContentSeconds: 10, avg: true, cache: true, counts: true, retainSummary: true },
   };
 }
 function record(value: unknown): value is Record<string, unknown> {
@@ -34,14 +32,15 @@ function boolean(value: unknown, name: string): boolean {
 export function parseConfig(raw: unknown): StatuslineConfig {
   if (!record(raw)) throw new Error("Configuration must be an object");
   if (raw.version !== undefined && raw.version !== 1) throw new Error("Unsupported configuration version");
-  const config = presetConfig(raw.preset === undefined ? "cometix" : choice(raw.preset, ["cometix", "minimal", "powerline"] as const, "preset"));
+  if (raw.preset !== undefined) choice(raw.preset, ["powerline"] as const, "preset");
+  const config = presetConfig();
   if (raw.enabled !== undefined) config.enabled = boolean(raw.enabled, "enabled");
   if (raw.icons !== undefined) config.icons = choice(raw.icons, ["unicode", "nerd", "ascii"], "icons");
   if (raw.separator !== undefined) config.separator = choice(raw.separator, ["pipe", "dot", "space", "powerline"], "separator");
   if (raw.pathMode !== undefined) config.pathMode = choice(raw.pathMode, ["basename", "abbreviated", "full"], "pathMode");
   if (raw.modelDisplay !== undefined) config.modelDisplay = choice(raw.modelDisplay, ["name", "last"], "modelDisplay");
   if (raw.contextDisplay !== undefined) config.contextDisplay = choice(raw.contextDisplay, ["text", "bar"], "contextDisplay");
-  for (const group of ["runtime", "providerMetrics"] as const) {
+  for (const group of ["runtime"] as const) {
     if (raw[group] === undefined) continue;
     if (!record(raw[group])) throw new Error(`Invalid ${group}`);
     for (const key of Object.keys(config[group])) {
@@ -53,10 +52,6 @@ export function parseConfig(raw: unknown): StatuslineConfig {
       } else (config[group] as unknown as Record<string, unknown>)[key] = boolean(value, `${group}.${key}`);
     }
   }
-  if (raw.integrations !== undefined) {
-    if (!record(raw.integrations)) throw new Error("Invalid integrations");
-    if (raw.integrations.cliproxyapi !== undefined) config.integrations.cliproxyapi = choice(raw.integrations.cliproxyapi, ["auto", "off", "on"], "integrations.cliproxyapi");
-  }
   if (raw.segments !== undefined) {
     if (!Array.isArray(raw.segments)) throw new Error("segments must be an array");
     const seen = new Set<string>();

package/src/index.ts

@@ -24,31 +24,45 @@ export default function statusline(pi: ExtensionAPI): void {
     session.install();
   });
   pi.on("session_shutdown", () => { generation++; session?.dispose(); session = undefined; });
+  pi.on("agent_start", (_event, ctx) => { session?.setContext(ctx); session?.startRun(); session?.schedule(true); });
+  pi.on("turn_start", (_event, ctx) => { session?.setContext(ctx); session?.startTurn(); session?.schedule(true); });
+  pi.on("agent_before_settle", (event) => { session?.runtime.beforeSettle(event.outcome); });
+  pi.on("agent_settled", (_event, ctx) => { session?.setContext(ctx); session?.settle(); session?.schedule(true); });
+  pi.on("ui_prompt_start", () => { session?.runtime.uiStart(); session?.schedule(true); });
+  pi.on("ui_prompt_end", () => { session?.runtime.uiEnd(); session?.schedule(true); });
+  pi.on("tool_execution_start", (event, ctx) => { session?.setContext(ctx); session?.runtime.toolStart(event.toolCallId, event.toolName); session?.schedule(true); });
+  pi.on("session_before_compact", (_event, ctx) => {
+    session?.setContext(ctx); session?.compaction.start(); session?.runtime.compaction(true); session?.schedule(true);
+  });
   pi.on("message_start", (event, ctx) => {
     session?.setContext(ctx);
-    if (event.message.role === "assistant") session?.setLive(undefined);
+    if (event.message.role === "assistant") { session?.setLive(undefined); session?.runtime.messageStart(event.message); }
     session?.schedule(true);
   });
   pi.on("message_update", (event, ctx) => {
     session?.setContext(ctx);
-    if (event.message.role === "assistant") session?.setLive(event.message);
+    if (event.message.role === "assistant") { session?.setLive(event.message); session?.runtime.stream(event.assistantMessageEvent); session?.runtime.message(event.message); }
     session?.schedule();
   });
   pi.on("message_end", (event, ctx) => {
     session?.setContext(ctx);
-    if (event.message.role === "assistant") session?.setLive(event.message);
+    if (event.message.role === "assistant") { session?.setLive(event.message); session?.runtime.message(event.message, true); }
     session?.schedule(true);
   });
   const refresh = (_event: unknown, ctx: ExtensionContext) => { session?.setContext(ctx); session?.schedule(true); };
   const resetLive = (event: unknown, ctx: ExtensionContext) => { session?.setLive(undefined); refresh(event, ctx); };
   pi.on("agent_end", resetLive);
-  pi.on("turn_end", refresh);
+  pi.on("turn_end", (event, ctx) => { if (event.message.role === "assistant") session?.runtime.message(event.message, true); session?.runtime.turnEnd(); refresh(event, ctx); });
   pi.on("model_select", refresh);
   pi.on("thinking_level_select", refresh);
-  pi.on("session_compact", resetLive);
-  pi.on("session_compact_failed", refresh);
+  pi.on("session_compact", (event, ctx) => {
+    session?.compaction.finish("success", event.compactionEntry.id); session?.runtime.compaction(false); resetLive(event, ctx);
+  });
+  pi.on("session_compact_failed", (event, ctx) => {
+    session?.compaction.finish(event.aborted ? "cancelled" : "failed", undefined, event.errorMessage); session?.runtime.compaction(false); refresh(event, ctx);
+  });
   pi.on("session_tree", resetLive);
-  pi.on("tool_execution_end", (_event, ctx) => { session?.setContext(ctx); session?.requestGit(); session?.schedule(true); });
+  pi.on("tool_execution_end", (event, ctx) => { session?.setContext(ctx); session?.runtime.toolEnd(event.toolCallId); session?.requestGit(); session?.schedule(true); });
   pi.on("user_bash", (_event, ctx) => { session?.setContext(ctx); session?.requestGit(); });
 
   pi.registerCommand("statusline", {
@@ -67,7 +81,9 @@ export default function statusline(pi: ExtensionAPI): void {
         if (token !== generation) return;
         config = loaded.config;
         if (loaded.warning) ctx.ui.notify(loaded.warning, "warning");
-        current.apply(config);
+        current.dispose();
+        session = new FooterSession(ctx, config);
+        session.refresh(true); session.install();
         return;
       }
       if (command) { ctx.ui.notify("Usage: /statusline [on|off|reload]", "info"); return; }

package/src/panel.ts

@@ -26,6 +26,7 @@ export class StatuslinePanel implements Component, Focusable {
   private disposed = false;
   private hasFocus = false;
   private listHeight = 0;
+  private section: "runtime" | undefined;
 
   constructor(options: PanelOptions) { this.options = options; this.draft = structuredClone(options.config); this.rebuild(); }
   get focused(): boolean { return this.hasFocus; }
@@ -39,6 +40,10 @@ export class StatuslinePanel implements Component, Focusable {
     return thinking;
   }
   private items(): SelectItem[] {
+    if (this.section) {
+      const labels: Record<string, string> = { enabled: "Runtime metrics", status: "Elapsed / compaction status", tools: "Tool activity", noContent: "No content warning", noContentSeconds: "No content threshold (seconds)", avg: "Average output speed", cache: "Cache read ratio", counts: "Turns and compactions", retainSummary: "Retain last run summary" };
+      return [...Object.entries(this.draft[this.section]).map(([key, value]) => ({ value: `option:${key}`, label: `${labels[key] ?? key}: ${value}` })), { value: "back", label: "Back to settings" }];
+    }
     if (this.editing) {
       const segment = this.editing;
       return [
@@ -52,7 +57,6 @@ export class StatuslinePanel implements Component, Focusable {
       ];
     }
     return [
-      { value: "preset", label: `Preset: ${this.draft.preset}`, description: "Cycles presets and resets segment styles/order" },
       { value: "defaultEnabled", label: `Enable on startup: ${this.draft.enabled ? "yes" : "no"}` },
       { value: "icons", label: `Icons: ${this.draft.icons}` },
       { value: "separator", label: `Separator: ${this.draft.separator}` },
@@ -60,6 +64,7 @@ export class StatuslinePanel implements Component, Focusable {
       { value: "modelDisplay", label: `Model display: ${this.draft.modelDisplay}`, description: "name: display name · last: final model ID component" },
       { value: "contextDisplay", label: `Context display: ${this.draft.contextDisplay}`, description: "text: tokens/capacity(percent) · bar: progress and percent" },
       ...this.draft.segments.filter((segment) => segment.id !== "thinking").map((segment) => ({ value: `segment:${segment.id}`, label: `[${segment.enabled ? "x" : " "}] ${segment.id}`, description: segment.id === "statuses" ? "Secondary row · Space toggles, Enter edits" : "Space toggles · Alt+Up/Down reorders · Enter edits" })),
+      { value: "runtime", label: "Runtime options" },
       { value: "save", label: "Save and apply globally" },
       { value: "reset", label: "Restore defaults in preview" },
       { value: "cancel", label: "Cancel" },
@@ -78,11 +83,29 @@ export class StatuslinePanel implements Component, Focusable {
   }
   private cancel(): void {
     if (this.input) { this.input = undefined; this.error = ""; }
+    else if (this.section) { const section = this.section; this.section = undefined; this.rebuild(section); }
     else if (this.editing) { const id = this.editing.id; this.editing = undefined; this.rebuild(`segment:${id}`); }
     else this.options.done();
   }
   private activate(value: string): void {
     this.error = "";
+    if (this.section) {
+      if (value === "back") { this.cancel(); return; }
+      const key = value.slice("option:".length);
+      if (key === "noContentSeconds") {
+        this.input = new Input(); this.input.focused = this.hasFocus; this.input.setValue(String(this.draft.runtime.noContentSeconds));
+        this.inputLabel = "No content threshold (1–3600 seconds)";
+        this.input.onEscape = () => this.cancel();
+        this.input.onSubmit = (text) => {
+          try { this.draft = parseConfig({ ...this.draft, runtime: { ...this.draft.runtime, noContentSeconds: Number(text) } }); this.input = undefined; this.error = ""; this.rebuild(value); }
+          catch (error) { this.error = error instanceof Error ? error.message : String(error); }
+        };
+      } else {
+        const group = this.draft[this.section] as unknown as Record<string, unknown>;
+        if (typeof group[key] === "boolean") group[key] = !group[key];
+      }
+      this.rebuild(value); return;
+    }
     if (this.editing) {
       if (value === "back") this.cancel();
       else if (value === "enabled") { this.editing.enabled = !this.editing.enabled; this.rebuild(value); }
@@ -92,22 +115,13 @@ export class StatuslinePanel implements Component, Focusable {
     }
     const cycle = <T,>(current: T, options: readonly T[]): T => options[(options.indexOf(current) + 1) % options.length]!;
     switch (value) {
-      case "preset": {
-        const enabled = this.draft.enabled;
-        const modelDisplay = this.draft.modelDisplay;
-        const contextDisplay = this.draft.contextDisplay;
-        this.draft = presetConfig(cycle(this.draft.preset, ["cometix", "minimal", "powerline"]));
-        this.draft.enabled = enabled;
-        this.draft.modelDisplay = modelDisplay;
-        this.draft.contextDisplay = contextDisplay;
-        break;
-      }
       case "defaultEnabled": this.draft.enabled = !this.draft.enabled; break;
       case "icons": this.draft.icons = cycle(this.draft.icons, ["unicode", "nerd", "ascii"]); break;
       case "separator": this.draft.separator = cycle(this.draft.separator, ["pipe", "dot", "space", "powerline"]); break;
       case "pathMode": this.draft.pathMode = cycle(this.draft.pathMode, ["basename", "abbreviated", "full"]); break;
       case "modelDisplay": this.draft.modelDisplay = cycle(this.draft.modelDisplay, ["name", "last"]); break;
       case "contextDisplay": this.draft.contextDisplay = cycle(this.draft.contextDisplay, ["text", "bar"]); break;
+      case "runtime": this.section = value; this.rebuild(); return;
       case "reset": this.draft = presetConfig(); break;
       case "cancel": this.options.done(); return;
       case "save": void this.save(); return;
@@ -160,7 +174,8 @@ export class StatuslinePanel implements Component, Focusable {
           [this.draft.segments[segmentIndex], this.draft.segments[next]] = [this.draft.segments[next]!, this.draft.segments[segmentIndex]!];
           this.rebuild(selected);
         }
-      } else this.list.handleInput(data);
+      } else if (this.section && matchesKey(data, "space") && selected?.startsWith("option:")) this.activate(selected);
+      else this.list.handleInput(data);
     }
     if (!this.disposed) this.options.requestRender();
   }
@@ -172,7 +187,7 @@ export class StatuslinePanel implements Component, Focusable {
     const { data, example } = this.options.snapshot();
     const preview = renderFooter(width, data, this.draft, this.options.theme());
     const lines = [
-      this.paint(`Statusline settings${this.editing ? ` / ${this.editing.id}` : ""}`, "accent"),
+      this.paint(`Statusline settings${this.editing ? ` / ${this.editing.id}` : this.section ? ` / ${this.section}` : ""}`, "accent"),
       this.paint(example ? "Preview · example data" : "Preview · current session", "muted"),
       ...(preview.length ? preview : [this.paint("(all segments hidden)", "muted")]),
       this.paint("Changes are a draft until Save. Fees are Pi-reported USD.", "muted"),

package/src/render.ts

@@ -6,6 +6,7 @@ export { cleanText } from "./text.ts";
 import type { ColorValue, SegmentConfig, SegmentId, StatuslineConfig, StatuslineSnapshot } from "./types.ts";
 import { emptyGit } from "./git.ts";
 import { emptyUsage } from "./usage.ts";
+import { renderRuntime } from "./runtime-render.ts";
 
 export type RenderTheme = Pick<Theme, "style" | "colors" | "appearance">;
 // Keep rainbow hues independent of semantic theme colors, which can repeat.
@@ -77,7 +78,7 @@ function segmentText(id: SegmentId, data: StatuslineSnapshot, config: Statusline
     case "statuses": return [...data.statuses.values()].map(cleanText).filter(Boolean).join(" · ") || undefined;
   }
 }
-function defaultColor(id: SegmentId, data: StatuslineSnapshot, config: StatuslineConfig): ColorValue {
+function defaultColor(id: SegmentId, data: StatuslineSnapshot): ColorValue {
   if (id === "context") {
     if ((data.context.percent ?? 0) > 90) return "error";
     if ((data.context.percent ?? 0) > 70) return "warning";
@@ -91,7 +92,6 @@ function defaultColor(id: SegmentId, data: StatuslineSnapshot, config: Statuslin
     const colors: Record<string, ColorValue> = { off: "thinkingOff", minimal: "thinkingMinimal", low: "thinkingLow", medium: "thinkingMedium", high: "thinkingHigh", xhigh: "thinkingXhigh", max: "thinkingMax" };
     return colors[data.thinking] ?? "muted";
   }
-  if (config.preset === "minimal") return "muted";
   if (id === "model") return "accent";
   if (id === "directory") return "success";
   if (id === "context") return "#c678dd";
@@ -154,19 +154,23 @@ export function renderFooter(width: number, data: StatuslineSnapshot, config: St
   if (width === 0) return [];
   const parts: Part[] = [];
   let secondary: Part | undefined;
+  // CLIProxyAPI's published `tps` status is display text only.
+  const tps = cleanText(data.statuses.get("tps") ?? "");
+  const elapsedStatus = config.segments.some((s) => s.id === "statuses" && s.enabled) && /^Elapsed \d+[dhms](?: \d+[hms])*$/.test(tps) ? tps : undefined;
+  const statuses = elapsedStatus ? new Map([...data.statuses].filter(([key]) => key !== "tps")) : data.statuses;
   const thinking = config.segments.find((segment) => segment.id === "thinking");
   for (const segment of config.segments) {
     if (!segment.enabled) continue;
-    const raw = segmentText(segment.id, data, config);
+    const raw = segmentText(segment.id, segment.id === "statuses" ? { ...data, statuses } : data, config);
     if (raw === undefined) continue;
     let text = cleanText(raw);
     if (config.icons === "ascii") text = text.replaceAll(" · ", " / ").replaceAll("…", "...");
     const background = segment.background ?? (config.preset === "powerline" ? (theme.appearance === "light" ? (parts.length % 2 ? "#e4e9f2" : "#d6dde9") : (parts.length % 2 ? "#283447" : "#202938")) : undefined);
-    const part: Part = { config: segment, text, icon: cleanText(segment.icon ?? ICONS[config.icons][segment.id] ?? ""), foreground: segment.color ?? defaultColor(segment.id, data, config), background };
+    const part: Part = { config: segment, text, icon: cleanText(segment.icon ?? ICONS[config.icons][segment.id] ?? ""), foreground: segment.color ?? defaultColor(segment.id, data), background };
     if (segment.id === "model" && data.reasoning && thinking?.enabled) {
       part.thinking = {
         text: cleanText(data.thinking || "off"),
-        foreground: thinking.color ?? (["high", "xhigh", "max"].includes(data.thinking) ? "rainbow" : defaultColor("thinking", data, config)),
+        foreground: thinking.color ?? (["high", "xhigh", "max"].includes(data.thinking) ? "rainbow" : defaultColor("thinking", data)),
       };
     }
     if (segment.id === "statuses") secondary = part;
@@ -194,7 +198,8 @@ export function renderFooter(width: number, data: StatuslineSnapshot, config: St
   }
   const lines: string[] = [];
   if (parts.length) lines.push(truncateToWidth(line, width, ellipsis));
-  if (secondary) lines.push(truncateToWidth(renderPart(secondary, theme), width, ellipsis));
+  const secondLine = renderRuntime(width, data, config, theme, secondary ? renderPart(secondary, theme) : undefined, elapsedStatus);
+  if (secondLine) lines.push(secondLine);
   return lines;
 }
 
@@ -205,5 +210,7 @@ export function sampleSnapshot(): StatuslineSnapshot {
     usage: { ...emptyUsage(), input: 32000, output: 5400, cacheRead: 12000, cost: 0.12 },
     git: { ...emptyGit("repository"), branch: "main", unstaged: 2, ahead: 2 },
     statuses: new Map([["example", "Example extension status"]]),
+    runtime: { runId: "example", status: "Running", elapsedMs: 28000, turns: 3, toolCalls: 2, tools: [], awaitingInput: false, noContentMs: 0, usage: { ...emptyUsage(), output: 1260 }, avg: 45, cache: 0.86 },
+    compaction: { active: false, elapsedMs: 0, count: 1, showFailure: false },
   };
 }

package/src/runtime-render.ts

@@ -0,0 +1,62 @@
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import type { RenderTheme } from "./render.ts";
+import { cleanText } from "./text.ts";
+import type { StatuslineConfig, StatuslineSnapshot } from "./types.ts";
+
+export function seconds(ms: number): string { return `${Math.floor(ms / 1000)}s`; }
+export function elapsed(ms: number): string {
+  let remaining = Math.max(0, Math.floor(ms / 1000));
+  const parts: string[] = [];
+  for (const [unit, size] of [["d", 86400], ["h", 3600], ["m", 60], ["s", 1]] as const) {
+    const value = Math.floor(remaining / size); remaining %= size;
+    if (value || parts.length || unit === "s") parts.push(`${value}${unit}`);
+  }
+  return parts.join(" ");
+}
+interface Part { id: string; text: string; color?: "text" | "muted" | "warning" | "error" | "success"; styled?: string }
+
+/** Layout consumes snapshots only; width decisions use terminal cells, including ANSI. */
+export function renderRuntime(width: number, data: StatuslineSnapshot, config: StatuslineConfig, theme: RenderTheme, extensionStatus?: string, elapsedStatus?: string): string | undefined {
+  const parts: Part[] = [];
+  const runtime = data.runtime, compact = data.compaction;
+  const enabled = config.runtime.enabled;
+  const add = (id: string, text: string, color?: Part["color"]) => parts.push({ id, text, color });
+  if (elapsedStatus) add("elapsed", elapsedStatus);
+  else if (enabled && config.runtime.status && runtime?.runId) add("elapsed", `Elapsed ${elapsed(runtime.elapsedMs)}`);
+  if (enabled && compact?.active) {
+    add("status", `${config.icons === "ascii" ? "Compacting..." : "Compacting…"} ${seconds(compact.elapsedMs)}`, "warning");
+    if (config.runtime.counts) add("compactions", `Compactions ${compact.count}`);
+  } else {
+    if (enabled && runtime) {
+      if (config.runtime.status) {
+        const failure = compact?.showFailure && runtime.status !== "Running" ? `Compaction ${compact.last?.status}` : undefined;
+        if (failure) add("status", failure, "error");
+      }
+      let busy = false;
+      if (runtime.awaitingInput) { add("activity", "Awaiting input", "warning"); busy = true; }
+      else if (config.runtime.tools && runtime.tools.length) {
+        add("activity", runtime.tools.length > 1 ? `Tools ${runtime.tools.length} active` : `Tool ${cleanText(runtime.tools[0]!.name).slice(0, 40)} ${seconds(runtime.tools[0]!.elapsedMs)}`);
+        busy = true;
+      } else if (config.runtime.noContent && runtime.noContentMs !== null && runtime.noContentMs >= config.runtime.noContentSeconds * 1000) {
+        add("activity", `No content ${seconds(runtime.noContentMs)}`); busy = true;
+      }
+      if (!busy) {
+        if (config.runtime.avg && runtime.avg !== null) add("avg", `Avg ${Math.round(runtime.avg)} tok/s`);
+        if (config.runtime.cache && runtime.cache !== null) add("cache", `Cache ${Math.round(runtime.cache * 100)}%`);
+      }
+      if (config.runtime.counts && runtime.runId) add("turns", `Turns ${runtime.turns}`);
+    }
+    if (enabled && config.runtime.counts && compact) add("compactions", `Compactions ${compact.count}`);
+    if (extensionStatus) parts.push({ id: "statuses", text: extensionStatus, styled: extensionStatus });
+  }
+  const separator = config.icons === "ascii" ? " | " : " · ";
+  const draw = () => parts.map((part) => part.styled ?? theme.style(part.text, { fg: theme.colors[part.color ?? "muted"] })).join(theme.style(separator, { fg: theme.colors.dim }));
+  let line = draw();
+  for (const id of ["statuses", "cache", "avg", "compactions", "turns", "activity"]) {
+    if (visibleWidth(line) <= width) break;
+    const index = parts.findIndex((part) => part.id === id);
+    if (index !== -1) parts.splice(index, 1);
+    line = draw();
+  }
+  return parts.length ? truncateToWidth(line, width, config.icons === "ascii" ? "..." : "…") : undefined;
+}

package/src/runtime.ts

@@ -0,0 +1,130 @@
+import { randomUUID } from "node:crypto";
+import type { AssistantMessage, AssistantMessageEvent } from "@earendil-works/pi-ai";
+import type { AgentActivityOutcome } from "@earendil-works/pi-coding-agent";
+import { cleanText } from "./text.ts";
+import { emptyUsage, readUsage } from "./usage.ts";
+import type { UsageTotals } from "./types.ts";
+
+export type Clock = () => number;
+export interface RuntimeSnapshot {
+  runId: string | null;
+  status: "Idle" | "Running" | "Done" | "Cancelled" | "Failed";
+  elapsedMs: number;
+  turns: number;
+  toolCalls: number;
+  tools: { name: string; elapsedMs: number }[];
+  awaitingInput: boolean;
+  noContentMs: number | null;
+  usage: UsageTotals | null;
+  avg: number | null;
+  cache: number | null;
+}
+
+/** A run survives agent_end, retries and boundary continuations until agent_settled. */
+export class RuntimeState {
+  private clock: Clock;
+  private startMs = 0;
+  private endMs = 0;
+  private runId: string | null = null;
+  private state: RuntimeSnapshot["status"] = "Idle";
+  private outcome: AgentActivityOutcome = "completed";
+  private aborted = false;
+  private turns = 0;
+  private tools = new Map<string, { name: string; start: number }>();
+  private seenTools = new Set<string>();
+  private prompts = 0;
+  private modelActive = false;
+  private compacting = false;
+  private lastContent = 0;
+  private messages = new Map<string, UsageTotals>();
+  private activeMessage: string | undefined;
+  private messageAliases = new Map<string, string>();
+  private sequence = 0;
+  constructor(clock: Clock = () => performance.now()) { this.clock = clock; }
+  get running(): boolean { return this.state === "Running"; }
+  get id(): string | null { return this.runId; }
+  reset(): void {
+    this.runId = null; this.state = "Idle"; this.startMs = 0; this.endMs = 0;
+    this.outcome = "completed"; this.aborted = false; this.turns = 0; this.tools.clear(); this.seenTools.clear();
+    this.prompts = 0; this.modelActive = false; this.compacting = false;
+    this.messages.clear(); this.messageAliases.clear(); this.activeMessage = undefined; this.sequence = 0;
+  }
+  start(): boolean {
+    if (this.running) return false;
+    const prompts = this.prompts;
+    this.reset(); this.prompts = prompts;
+    this.runId = randomUUID(); this.startMs = this.clock(); this.lastContent = this.startMs; this.state = "Running";
+    return true;
+  }
+  beforeSettle(outcome: AgentActivityOutcome): void { if (this.running && !this.aborted) this.outcome = outcome; }
+  observeAbort(): void { if (this.running) { this.aborted = true; this.outcome = "aborted"; } }
+  settle(): void {
+    if (!this.running) return;
+    this.endMs = this.clock();
+    this.state = { completed: "Done", aborted: "Cancelled", error: "Failed" }[this.outcome] as RuntimeSnapshot["status"];
+    this.modelActive = false; this.tools.clear(); this.activeMessage = undefined;
+  }
+  turnStart(): void {
+    if (!this.running) return;
+    // A continuation/retry supersedes the previous attempt's observed outcome.
+    this.outcome = "completed"; this.aborted = false;
+    this.turns++; this.modelActive = true; this.lastContent = this.clock(); this.activeMessage = undefined;
+  }
+  turnEnd(): void { this.modelActive = false; }
+  content(): void { if (this.running && !this.compacting) this.lastContent = this.clock(); }
+  stream(event: AssistantMessageEvent): void {
+    if ((event.type === "text_delta" || event.type === "thinking_delta" || event.type === "toolcall_delta") && event.delta.length > 0) this.content();
+    // A tool name/ID in the initial block is content even before JSON deltas arrive.
+    if (event.type === "toolcall_start") {
+      const block = event.partial.content[event.contentIndex];
+      if (block?.type === "toolCall" && (block.name || block.id)) this.content();
+    }
+  }
+  private alias(message: AssistantMessage): string { return `${message.provider}/${message.model}/${message.timestamp}`; }
+  messageStart(message: AssistantMessage): void {
+    if (!this.running || this.compacting) return;
+    this.activeMessage = String(++this.sequence);
+    this.messageAliases.set(this.alias(message), this.activeMessage);
+  }
+  message(message: AssistantMessage, final = false): void {
+    if (!this.running || this.compacting) return;
+    const alias = this.alias(message);
+    const responseAlias = message.responseId ? `${message.provider}/${message.model}/response:${message.responseId}` : undefined;
+    const key = (responseAlias ? this.messageAliases.get(responseAlias) : undefined) ?? this.messageAliases.get(alias) ?? this.activeMessage ?? String(++this.sequence);
+    this.messageAliases.set(alias, key);
+    if (responseAlias) this.messageAliases.set(responseAlias, key);
+    // Missing usage stays unavailable. Zeroes explicitly supplied by Pi are valid.
+    if (message.usage && [message.usage.input, message.usage.output, message.usage.cacheRead, message.usage.cacheWrite].every((n) => Number.isFinite(n) && n >= 0)) {
+      this.messages.set(key, readUsage(message.usage));
+    }
+    if (final) {
+      this.modelActive = false;
+      if (!this.aborted) this.outcome = message.stopReason === "aborted" ? "aborted" : message.stopReason === "error" ? "error" : "completed";
+    }
+  }
+  toolStart(id: string, name: string): void {
+    if (!this.running || this.seenTools.has(id)) return;
+    this.seenTools.add(id); this.tools.set(id, { name: cleanText(name).slice(0, 40) || "unknown", start: this.clock() });
+  }
+  toolEnd(id: string): void { this.tools.delete(id); }
+  uiStart(): void { this.prompts++; }
+  uiEnd(): void { this.prompts = Math.max(0, this.prompts - 1); this.lastContent = this.clock(); }
+  compaction(active: boolean): void { this.compacting = active; this.lastContent = this.clock(); }
+  snapshot(retainSummary = true): RuntimeSnapshot {
+    const now = this.clock();
+    const hidden = !retainSummary && !this.running;
+    const elapsedMs = hidden || !this.runId ? 0 : Math.max(0, (this.running ? now : this.endMs) - this.startMs);
+    const usage = !hidden && this.messages.size ? emptyUsage() : null;
+    if (usage) for (const contribution of this.messages.values()) for (const key of Object.keys(usage) as (keyof UsageTotals)[]) usage[key] += contribution[key];
+    const denominator = usage ? usage.input + usage.cacheRead + usage.cacheWrite : 0;
+    return {
+      runId: hidden ? null : this.runId, status: hidden ? "Idle" : this.state, elapsedMs,
+      turns: hidden ? 0 : this.turns, toolCalls: hidden ? 0 : this.seenTools.size,
+      tools: [...this.tools.values()].map((tool) => ({ name: tool.name, elapsedMs: Math.max(0, now - tool.start) })),
+      awaitingInput: this.prompts > 0,
+      noContentMs: this.running && this.modelActive && !this.tools.size && !this.prompts && !this.compacting ? Math.max(0, now - this.lastContent) : null,
+      usage, avg: usage && elapsedMs > 0 ? usage.output / (elapsedMs / 1000) : null,
+      cache: usage && denominator > 0 ? usage.cacheRead / denominator : null,
+    };
+  }
+}

package/src/session.ts

@@ -6,8 +6,12 @@ import { emptyGit, GitPoller, type GitReader } from "./git.ts";
 import { renderFooter } from "./render.ts";
 import type { StatuslineConfig, StatuslineSnapshot } from "./types.ts";
 import { UsageCache } from "./usage.ts";
+import { RuntimeState } from "./runtime.ts";
+import { CompactionState } from "./compaction.ts";
 
 export class FooterSession {
+  readonly runtime = new RuntimeState();
+  readonly compaction = new CompactionState();
   private ctx: ExtensionContext;
   private config: StatuslineConfig;
   private usage = new UsageCache();
@@ -24,22 +28,43 @@ export class FooterSession {
   private displayKey = "";
   private context: StatuslineSnapshot["context"] = { tokens: null, contextWindow: 0, percent: null };
   private readonly gitReader: GitReader | undefined;
+  private signal: AbortSignal | undefined;
+  private readonly onAbort = () => { this.runtime.observeAbort(); this.schedule(true); };
 
   constructor(ctx: ExtensionContext, config: StatuslineConfig, gitReader?: GitReader) {
     this.ctx = ctx; this.config = config; this.gitReader = gitReader;
   }
   get active(): boolean { return this.ownsFooter && !this.closed; }
-  setContext(ctx: ExtensionContext): void { this.ctx = ctx; }
+  setContext(ctx: ExtensionContext): void { this.ctx = ctx; this.watchSignal(); }
+  private watchSignal(): void {
+    if (this.closed || !this.ownsFooter || !this.runtime.running) return;
+    const signal = this.ctx.signal;
+    if (!signal || signal === this.signal) return;
+    this.clearSignal(); this.signal = signal;
+    if (signal.aborted) this.onAbort();
+    else signal.addEventListener("abort", this.onAbort, { once: true });
+  }
+  private clearSignal(): void { this.signal?.removeEventListener("abort", this.onAbort); this.signal = undefined; }
+  startRun(): void {
+    this.compaction.activity();
+    this.runtime.start();
+    this.watchSignal();
+  }
+  startTurn(): void {
+    this.compaction.activity(); this.runtime.turnStart(); this.watchSignal();
+  }
+  settle(): void { this.runtime.settle(); this.clearSignal(); }
   install(): void {
     if (this.closed || this.ctx.mode !== "tui" || !this.config.enabled) return;
     this.ctx.ui.setFooter((tui, _theme, provider) => {
       this.ownsFooter = true; this.tui = tui; this.provider = provider;
+      this.watchSignal();
       this.poller = new GitPoller(this.ctx.cwd, (git) => { this.git = git; this.repaint(); }, this.gitReader);
       this.unsubscribe = provider.onBranchChange(() => this.requestGit());
       if (this.config.segments.some((segment) => segment.id === "git" && segment.enabled)) this.poller.start();
       this.refresh(true);
       // Covers usage entries appended outside normal message events (e.g. cache warming).
-      this.timer = setInterval(() => this.refresh(), 2000);
+      this.timer = setInterval(() => this.refresh(), 1000);
       this.timer.unref();
       return {
         render: (width: number) => renderFooter(width, this.snapshot(), this.config, this.ctx.ui.theme),
@@ -49,6 +74,7 @@ export class FooterSession {
     });
   }
   private stopResources(): void {
+    this.clearSignal();
     clearInterval(this.timer); clearTimeout(this.scheduled);
     this.timer = undefined; this.scheduled = undefined;
     this.poller?.dispose(); this.poller = undefined;
@@ -60,7 +86,7 @@ export class FooterSession {
     this.stopResources();
     if (restore && !this.closed) this.ctx.ui.setFooter(undefined);
   }
-  dispose(): void { this.stopResources(); this.closed = true; }
+  dispose(): void { this.stopResources(); this.clearSignal(); this.closed = true; }
   apply(config: StatuslineConfig): void {
     if (this.closed) return;
     this.disable(); this.config = config;
@@ -83,11 +109,13 @@ export class FooterSession {
     const manager = this.ctx.sessionManager;
     const key = `${manager.getSessionId()}:${manager.getLeafId()}:${this.ctx.model?.provider}/${this.ctx.model?.id}/${this.ctx.model?.contextWindow}`;
     if (force || key !== this.statsKey) {
-      this.usage.update(manager.getEntries());
+      const entries = manager.getEntries();
+      this.usage.update(entries);
+      this.compaction.update(entries);
       const context = this.ctx.getContextUsage();
       this.context = context ?? { tokens: null, contextWindow: this.ctx.model?.contextWindow ?? 0, percent: null };
-      this.statsKey = key;
     }
+    this.statsKey = key;
     this.repaint();
   }
   private repaint(): void {
@@ -103,6 +131,7 @@ export class FooterSession {
       thinking: this.ctx.thinkingLevel ?? "off", cwd: this.ctx.cwd, home: homedir(),
       context: this.context, usage: this.usage.snapshot(), git: this.git,
       statuses: this.provider?.getExtensionStatuses() ?? new Map(),
+      runtime: this.runtime.snapshot(this.config.runtime.retainSummary), compaction: this.compaction.snapshot(),
     };
   }
 }

package/src/types.ts

@@ -3,7 +3,7 @@ import type { ThemeColor } from "@earendil-works/pi-coding-agent";
 export const SEGMENT_IDS = ["model", "thinking", "context", "directory", "git", "cost", "input", "output", "tokens", "cacheRead", "cacheWrite", "statuses"] as const;
 export type SegmentId = typeof SEGMENT_IDS[number];
 export type ColorValue = ThemeColor | `#${string}`;
-export type Preset = "cometix" | "minimal" | "powerline";
+export type Preset = "powerline";
 export type IconMode = "unicode" | "nerd" | "ascii";
 export interface RuntimeConfig {
   enabled: boolean;
@@ -14,16 +14,8 @@ export interface RuntimeConfig {
   avg: boolean;
   cache: boolean;
   counts: boolean;
-  untilCompact: boolean;
   retainSummary: boolean;
 }
-export interface ProviderMetricsConfig {
-  phase: boolean;
-  firstText: boolean;
-  firstReasoning: boolean;
-  duration: boolean;
-  transport: boolean;
-}
 export interface SegmentConfig {
   id: SegmentId;
   enabled: boolean;
@@ -43,8 +35,6 @@ export interface StatuslineConfig {
   contextDisplay: "text" | "bar";
   segments: SegmentConfig[];
   runtime: RuntimeConfig;
-  providerMetrics: ProviderMetricsConfig;
-  integrations: { cliproxyapi: "auto" | "off" | "on" };
 }
 export interface UsageTotals {
   input: number;
@@ -77,5 +67,4 @@ export interface StatuslineSnapshot {
   statuses: ReadonlyMap<string, string>;
   runtime?: import("./runtime.ts").RuntimeSnapshot;
   compaction?: import("./compaction.ts").CompactionSnapshot;
-  telemetry?: import("./receiver.ts").TelemetrySnapshot;
 }