@erichll/pi-statusline 0.0.0-stage → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+## 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.
+- Place context immediately after the model in preset layouts and add a configurable context progress bar (`contextDisplay: "bar"`).
+- Hide the cost segment by default in every preset; it can still be enabled in settings.
+- Use an independent rainbow palette so themes with repeated semantic colors still display distinct thinking-level hues.
+- Use `` as the default model glyph and append the thinking level in parentheses, coloring the entire `(level)` with per-level colors and rainbow high/xhigh/max.
+- Move thinking controls into the model settings; retain existing `thinking` enablement/color settings for compatibility.
+- Move configuration to `extensions/pi-statusline/config.json` under Pi's agent directory.
+- Compact context usage to `used/capacity(percent%)`, removing separator padding.
+- Add `modelDisplay: "last"` to show only the final component of a slash-separated model ID, configurable in the preview panel.
+- Add a native Pi footer with configurable presets.
+- Add configurable segments, Unicode/Nerd Font/ASCII icons, colors and path display.
+- Add a keyboard-driven configuration panel using the same renderer as the live footer.
+- Add asynchronous Git state, native session usage accounting and extension-status display.
+- Handle narrow terminals, session replacement, compaction and non-interactive modes.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,196 @@
-# Temporary Holding Version
+# @erichll/pi-statusline
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+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.
+
+```text
+ Model(high) | ◉ [█░░░░░░░░░]11.9% | ▸ pi-packages | ⑂ main ● *2 ↑2
+extension status text, when available
+```
+
+## Install
+
+```sh
+pi install npm:@erichll/pi-statusline
+```
+
+Requires Node.js >=22.19, Pi >=1.0.0, and optionally Git. 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.
+
+## Local use
+
+From this repository, try the extension for one invocation:
+
+```sh
+npm install
+pi --no-extensions --extension ./packages/pi-statusline/src/index.ts
+```
+
+`--no-extensions` disables other auto-discovered extensions for this invocation.
+To use your other extensions, disable `pi-powerline-footer` in `pi config`
+before starting Pi with `--extension ./packages/pi-statusline/src/index.ts`.
+Only one extension should own the footer. The previous package can remain
+installed for rollback. Loading this repository as a whole also discovers the
+security extensions; use the statusline entrypoint to try it on its own.
+
+This checkout is for development only. For a persistent install use the
+published package, `npm:@erichll/pi-statusline`.
+
+## Commands
+
+| Command | Behavior |
+| --- | --- |
+| `/statusline` | Open configuration and live preview |
+| `/statusline on` | Enable for this session |
+| `/statusline off` | Restore Pi's native footer for this session |
+| `/statusline reload` | Reload saved configuration, including startup enablement |
+
+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.
+**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
+configuration unchanged and keeps the panel open.
+
+## Configuration
+
+Settings live in `extensions/pi-statusline/config.json` under Pi's agent directory,
+normally `~/.pi/agent/extensions/pi-statusline/config.json`;
+`PI_CODING_AGENT_DIR` is respected. The extension
+does not write Pi's general `settings.json`. Configuration is global, with no
+project override or file watcher. After manual changes use `/statusline reload`.
+The configuration directory is created automatically when saving from the panel.
+When upgrading from the previous `~/.pi/agent/statusline.json` location, move the
+existing file to the new path before running `/reload`; the old path is no longer read.
+
+```json
+{
+  "version": 1,
+  "enabled": true,
+  "preset": "cometix",
+  "icons": "unicode",
+  "separator": "pipe",
+  "pathMode": "basename",
+  "modelDisplay": "name",
+  "contextDisplay": "bar"
+}
+```
+
+- 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
+  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.
+- 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.
+- 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.
+  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 `-`.
+  Unknown usage shows `[??????????]?%`; values above 100% fill
+  the bar completely and retain the reported percentage. Both modes use the
+  existing context warning colors. Text mode includes token counts and capacity;
+  bar mode shows progress and percentage.
+- `segments`: optional ordered array of `{ id, enabled, icon?, color?, iconColor?, background? }`.
+  An explicit list is authoritative: omitted segments are disabled but remain
+  available in the panel. The `statuses` segment always occupies the second row.
+  Preset layouts place context immediately after the model, before directory
+  and Git. Explicit saved segment order is respected and can be changed in the panel.
+- Thinking is appended to the model as `(level)`, with no separate icon or
+  separator. In the panel, edit **model → Thinking level / Thinking color**.
+  The existing `thinking` configuration entry controls suffix enablement and an
+  optional color override; its position, icon and background are ignored. It
+  does not render on its own when the model is hidden or non-reasoning.
+  By default, `off`, `minimal`, `low`, and `medium` use their respective Pi theme
+  colors; `high`, `xhigh`, and `max` use a fixed violet/pink/orange/yellow/green/cyan/blue
+  palette independent of the Pi theme, distributed across the available characters.
+  The color or rainbow covers the entire `(level)`, including parentheses, and
+  the model's background covers the whole item.
+- Icon `""` hides a glyph. In the panel, enter `:default` to restore its default.
+  Color fields accept `#RRGGBB` or `text`, `accent`, `muted`, `dim`, `success`,
+  `warning`, `error`, `border`, `borderAccent`, `borderMuted`, and Pi's
+  `thinkingOff/Minimal/Low/Medium/High/Xhigh/Max` tokens. Empty color input in the
+  panel restores the default. Explicit colors override automatic warning colors.
+
+Available segments:
+
+| ID | Data | Default |
+| --- | --- | --- |
+| `model` | Display name/full ID, or final ID component via `modelDisplay` | On |
+| `thinking` | Controls the colored `(level)` suffix inside the model item | On |
+| `context` | Text usage/capacity or a progress bar, followed by percentage | On |
+| `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 |
+| `cacheRead`, `cacheWrite` | Cumulative cache token counts | Off |
+| `statuses` | Other extensions' `setStatus()` text, with terminal controls stripped | On |
+
+The minimal preset enables directory, Git, context, and extension statuses.
+See [examples/statusline.json](examples/statusline.json) for an explicit layout.
+Unknown 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.
+
+## Statistics and refresh behavior
+
+Context comes from Pi's `getContextUsage()`. It is distinct from cumulative
+token consumption. Unknown values, including immediately after compaction, show
+`?` until Pi can provide an estimate. Yellow begins above 70%, red above 90%.
+Pi 1.0 bases context estimates on persisted messages; in-flight usage updates
+the cumulative token/cost segments while context refreshes after persistence.
+
+Session totals include all usage already recorded in the current session file:
+assistant messages, explicit usage entries, tool-result usage, compaction and
+branch summaries, including pre-compaction and abandoned-branch consumption.
+Streaming responses are provisional and counted once when persisted. The total
+token segment sums input, output, cache-read and cache-write, matching Pi's
+native session totals. Costs are **Pi-reported values, not provider invoices**;
+zero means no cost recorded by Pi. No subscription-quota API or child-session
+log is queried, and private `pi-subagents` result details are not parsed.
+
+Git queries run asynchronously every two seconds and after tool/branch changes,
+with a one-second timeout and optional index locks disabled. No repository hides
+the segment; failures show `?`, never a false clean state. Large output above
+8 MiB also falls back to unknown. Worktrees, detached HEAD, unborn branches and
+filenames containing newlines are supported. Disabling the Git segment stops
+its polling.
+
+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
+release timers and subscriptions. RPC, JSON and print mode do not install UI
+components or start polling.
+
+## Development and rollback
+
+```sh
+npm run check --workspace @erichll/pi-statusline
+npm test --workspace @erichll/pi-statusline
+# Optional: POSIX PTY integration, using an offline simulated model
+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
+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.
+
+The initial implementation is independently written, with design references to
+[pi-powerline-footer](https://github.com/nicobailon/pi-powerline-footer).
+
+MIT licensed.

package/examples/statusline.json

@@ -0,0 +1,19 @@
+{
+  "version": 1,
+  "enabled": true,
+  "preset": "cometix",
+  "icons": "unicode",
+  "separator": "pipe",
+  "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 }
+  ]
+}

package/package.json

@@ -1,6 +1,31 @@
 {
   "name": "@erichll/pi-statusline",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Configurable Pi statusline with live preview, Git and session usage",
+  "type": "module",
+  "license": "MIT",
+  "keywords": ["pi-package", "pi-extension", "pi", "statusline"],
+  "repository": {"type": "git", "url": "git+https://github.com/erichll/pi-packages.git", "directory": "packages/pi-statusline"},
+  "publishConfig": {"access": "public"},
+  "engines": {"node": ">=22.19.0"},
+  "files": ["src", "README.md", "CHANGELOG.md", "LICENSE", "examples"],
+  "exports": {".": "./src/index.ts"},
+  "pi": {"extensions": ["./src/index.ts"]},
+  "scripts": {
+    "check": "tsc -p tsconfig.json --noEmit",
+    "test": "node --experimental-strip-types --test test/*.test.ts",
+    "smoke": "python3 test/pty-smoke.py"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-ai": "^1.0.0",
+    "@earendil-works/pi-coding-agent": "^1.0.0",
+    "@earendil-works/pi-tui": "^1.0.0",
+    "@types/node": "^26.6.4",
+    "typescript": "^7.0.2"
+  }
+}

package/src/config.ts

@@ -0,0 +1,121 @@
+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 { SEGMENT_IDS } from "./types.ts";
+
+// A deliberately small, documented set of Pi semantic foreground colors.
+export const COLORS = ["text", "accent", "muted", "dim", "success", "warning", "error", "border", "borderAccent", "borderMuted", "thinkingOff", "thinkingMinimal", "thinkingLow", "thinkingMedium", "thinkingHigh", "thinkingXhigh", "thinkingMax"] as const;
+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"]);
+  return {
+    version: 1, enabled: true, preset, icons: "unicode",
+    separator: preset === "powerline" ? "powerline" : "pipe", 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" },
+  };
+}
+function record(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function choice<T extends string>(value: unknown, choices: readonly T[], name: string): T {
+  if (typeof value !== "string" || !choices.includes(value as T)) throw new Error(`Invalid ${name}`);
+  return value as T;
+}
+function boolean(value: unknown, name: string): boolean {
+  if (typeof value !== "boolean") throw new Error(`Invalid ${name}`);
+  return value;
+}
+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.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) {
+    if (raw[group] === undefined) continue;
+    if (!record(raw[group])) throw new Error(`Invalid ${group}`);
+    for (const key of Object.keys(config[group])) {
+      const value = raw[group][key];
+      if (value === undefined) continue;
+      if (key === "noContentSeconds") {
+        if (typeof value !== "number" || !Number.isInteger(value) || value < 1 || value > 3600) throw new Error("Invalid runtime.noContentSeconds (1–3600)");
+        config.runtime.noContentSeconds = value;
+      } 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>();
+    config.segments = raw.segments.map((item: unknown) => {
+      if (!record(item)) throw new Error("Invalid segment");
+      const id = choice(item.id, SEGMENT_IDS, "segment id");
+      if (seen.has(id)) throw new Error(`Duplicate segment: ${id}`);
+      seen.add(id);
+      const result = { id, enabled: item.enabled === undefined ? true : boolean(item.enabled, `${id}.enabled`) } as StatuslineConfig["segments"][number];
+      if (item.icon !== undefined) {
+        if (typeof item.icon !== "string" || item.icon.length > 32 || /[\p{Cc}\u202a-\u202e\u2066-\u2069]/u.test(item.icon)) throw new Error(`Invalid icon: ${id}`);
+        result.icon = item.icon;
+      }
+      for (const key of ["color", "iconColor", "background"] as const) {
+        if (item[key] !== undefined) {
+          if (!validColor(item[key])) throw new Error(`Invalid ${id}.${key}`);
+          result[key] = item[key];
+        }
+      }
+      return result;
+    });
+    // An explicit list is authoritative. Omitted segments remain editable but disabled.
+    for (const id of SEGMENT_IDS) if (!seen.has(id)) config.segments.push({ id, enabled: false });
+  }
+  return config;
+}
+
+export class ConfigStore {
+  readonly file: string;
+  private lastWarning = "";
+  constructor(file: string) { this.file = file; }
+  async load(previous = presetConfig()): Promise<{ config: StatuslineConfig; warning?: string }> {
+    try {
+      const config = parseConfig(JSON.parse(await readFile(this.file, "utf8")));
+      this.lastWarning = "";
+      return { config };
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+        this.lastWarning = "";
+        return { config: presetConfig() };
+      }
+      const warning = `Could not load ${this.file}: ${error instanceof Error ? error.message : String(error)}`;
+      const notify = warning !== this.lastWarning;
+      this.lastWarning = warning;
+      return { config: previous, ...(notify ? { warning } : {}) };
+    }
+  }
+  async save(config: StatuslineConfig): Promise<void> {
+    const validated = parseConfig(config);
+    await mkdir(dirname(this.file), { recursive: true });
+    const temporary = `${this.file}.${randomUUID()}.tmp`;
+    try {
+      const handle = await open(temporary, "wx", 0o600);
+      try { await handle.writeFile(`${JSON.stringify(validated, null, 2)}\n`); await handle.sync(); }
+      finally { await handle.close(); }
+      await rename(temporary, this.file);
+      this.lastWarning = "";
+    } finally {
+      await unlink(temporary).catch((error: NodeJS.ErrnoException) => { if (error.code !== "ENOENT") throw error; });
+    }
+  }
+}

package/src/git.ts

@@ -0,0 +1,105 @@
+import { spawn } from "node:child_process";
+import type { GitState } from "./types.ts";
+
+export function emptyGit(kind: GitState["kind"] = "unknown"): GitState {
+  return { kind, branch: null, detached: false, staged: 0, unstaged: 0, untracked: 0, conflicts: 0, ahead: 0, behind: 0 };
+}
+export function parseGitStatus(output: string): GitState {
+  const state = emptyGit("repository");
+  let oid = "";
+  const records = output.split("\0");
+  for (let i = 0; i < records.length; i++) {
+    const line = records[i]!;
+    if (line.startsWith("# branch.head ")) {
+      const name = line.slice(14);
+      state.detached = name === "(detached)";
+      if (!state.detached) state.branch = name;
+    } else if (line.startsWith("# branch.oid ")) oid = line.slice(13);
+    else if (line.startsWith("# branch.ab ")) {
+      const match = /^# branch.ab \+(\d+) -(\d+)$/.exec(line);
+      if (match) { state.ahead = Number(match[1]); state.behind = Number(match[2]); }
+    } else if (line.startsWith("? ")) state.untracked++;
+    else if (line.startsWith("u ")) state.conflicts++;
+    else if (line.startsWith("1 ") || line.startsWith("2 ")) {
+      const fields = line.split(" ", 4);
+      const xy = fields[1] ?? "..";
+      const sub = fields[2] ?? "N...";
+      if (xy[0] !== ".") state.staged++;
+      if (xy[1] !== "." || (sub.startsWith("S") && sub.slice(1) !== "...")) state.unstaged++;
+      if (line.startsWith("2 ")) i++; // Rename source is a separate NUL record, not another status.
+    }
+  }
+  if (state.detached) state.branch = oid && oid !== "(initial)" ? oid.slice(0, 7) : "HEAD";
+  return state;
+}
+export type GitReader = (cwd: string, signal: AbortSignal) => Promise<GitState>;
+export const readGit: GitReader = (cwd, signal) => new Promise((resolve) => {
+  if (signal.aborted) { resolve(emptyGit()); return; }
+  const child = spawn("git", ["--no-optional-locks", "status", "--porcelain=v2", "--branch", "-z"], {
+    cwd, env: { ...process.env, GIT_OPTIONAL_LOCKS: "0", LC_ALL: "C" }, stdio: ["ignore", "pipe", "pipe"], windowsHide: true,
+  });
+  const chunks: Buffer[] = [];
+  let bytes = 0, stderr = "", stopped = false;
+  const stop = () => { stopped = true; child.kill("SIGKILL"); };
+  const timer = setTimeout(stop, 1000);
+  timer.unref();
+  signal.addEventListener("abort", stop, { once: true });
+  const finish = (state: GitState) => { clearTimeout(timer); signal.removeEventListener("abort", stop); resolve(state); };
+  child.stdout.on("data", (chunk: Buffer) => { bytes += chunk.length; if (bytes > 8 * 1024 * 1024) stop(); else chunks.push(chunk); });
+  child.stderr.on("data", (chunk: Buffer) => { if (stderr.length < 4096) stderr += chunk.toString(); });
+  child.on("error", () => finish(emptyGit()));
+  child.on("close", (code) => {
+    if (stopped || signal.aborted) finish(emptyGit());
+    else if (code === 0) finish(parseGitStatus(Buffer.concat(chunks).toString("utf8")));
+    else finish(emptyGit(stderr.includes("not a git repository") ? "none" : "unknown"));
+  });
+});
+
+/** One query at a time. Disposal cancels work and prevents stale completion callbacks. */
+export class GitPoller {
+  private controller: AbortController | undefined;
+  private timer: ReturnType<typeof setInterval> | undefined;
+  private state = emptyGit();
+  private disposed = false;
+  private pending = false;
+  private lastStart = 0;
+  private deferred: ReturnType<typeof setTimeout> | undefined;
+  private readonly cwd: string;
+  private readonly changed: (state: GitState) => void;
+  private readonly reader: GitReader;
+  constructor(cwd: string, changed: (state: GitState) => void, reader: GitReader = readGit) {
+    this.cwd = cwd; this.changed = changed; this.reader = reader;
+  }
+  start(): void {
+    if (this.timer || this.disposed) return;
+    void this.refresh();
+    this.timer = setInterval(() => void this.refresh(), 2000);
+    this.timer.unref();
+  }
+  async refresh(): Promise<void> {
+    if (this.disposed) return;
+    if (this.controller) { this.pending = true; return; }
+    const delay = 250 - (Date.now() - this.lastStart);
+    if (delay > 0) {
+      this.deferred ??= setTimeout(() => { this.deferred = undefined; void this.refresh(); }, delay);
+      this.deferred.unref();
+      return;
+    }
+    this.lastStart = Date.now();
+    const controller = new AbortController();
+    this.controller = controller;
+    try {
+      const state = await this.reader(this.cwd, controller.signal);
+      if (!this.disposed && JSON.stringify(state) !== JSON.stringify(this.state)) { this.state = state; this.changed(state); }
+    } catch {
+      if (!this.disposed && this.state.kind !== "unknown") { this.state = emptyGit(); this.changed(this.state); }
+    } finally {
+      this.controller = undefined;
+      if (this.pending && !this.disposed) { this.pending = false; void this.refresh(); }
+    }
+  }
+  dispose(): void {
+    this.disposed = true;
+    clearInterval(this.timer); clearTimeout(this.deferred); this.controller?.abort();
+  }
+}

package/src/index.ts

@@ -0,0 +1,92 @@
+import { join } from "node:path";
+import { getAgentDir, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { ConfigStore, presetConfig } from "./config.ts";
+import { StatuslinePanel } from "./panel.ts";
+import { sampleSnapshot } from "./render.ts";
+import { FooterSession } from "./session.ts";
+
+export default function statusline(pi: ExtensionAPI): void {
+  const store = new ConfigStore(join(getAgentDir(), "extensions", "pi-statusline", "config.json"));
+  let config = presetConfig();
+  let session: FooterSession | undefined;
+  let generation = 0;
+
+  pi.on("session_start", async (_event, ctx) => {
+    const token = ++generation;
+    session?.dispose(); session = undefined;
+    if (ctx.mode !== "tui") return;
+    const loaded = await store.load(config);
+    if (token !== generation) return;
+    config = loaded.config;
+    if (loaded.warning) ctx.ui.notify(loaded.warning, "warning");
+    session = new FooterSession(ctx, config);
+    session.refresh(true);
+    session.install();
+  });
+  pi.on("session_shutdown", () => { generation++; session?.dispose(); session = undefined; });
+  pi.on("message_start", (event, ctx) => {
+    session?.setContext(ctx);
+    if (event.message.role === "assistant") session?.setLive(undefined);
+    session?.schedule(true);
+  });
+  pi.on("message_update", (event, ctx) => {
+    session?.setContext(ctx);
+    if (event.message.role === "assistant") session?.setLive(event.message);
+    session?.schedule();
+  });
+  pi.on("message_end", (event, ctx) => {
+    session?.setContext(ctx);
+    if (event.message.role === "assistant") session?.setLive(event.message);
+    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("model_select", refresh);
+  pi.on("thinking_level_select", refresh);
+  pi.on("session_compact", resetLive);
+  pi.on("session_compact_failed", refresh);
+  pi.on("session_tree", resetLive);
+  pi.on("tool_execution_end", (_event, ctx) => { session?.setContext(ctx); session?.requestGit(); session?.schedule(true); });
+  pi.on("user_bash", (_event, ctx) => { session?.setContext(ctx); session?.requestGit(); });
+
+  pi.registerCommand("statusline", {
+    description: "Configure the statusline, or on | off | reload",
+    handler: async (args, ctx) => {
+      if (ctx.mode !== "tui") { ctx.ui.notify("Statusline configuration requires Pi terminal mode.", "info"); return; }
+      const token = generation;
+      const current = session;
+      if (!current) return;
+      current.setContext(ctx);
+      const command = args.trim();
+      if (command === "off") { current.disable(); return; }
+      if (command === "on") { current.apply({ ...config, enabled: true }); return; }
+      if (command === "reload") {
+        const loaded = await store.load(config);
+        if (token !== generation) return;
+        config = loaded.config;
+        if (loaded.warning) ctx.ui.notify(loaded.warning, "warning");
+        current.apply(config);
+        return;
+      }
+      if (command) { ctx.ui.notify("Usage: /statusline [on|off|reload]", "info"); return; }
+      current.refresh(true);
+      await ctx.ui.custom<void>((tui, _theme, _keys, done) => new StatuslinePanel({
+        config, theme: () => ctx.ui.theme,
+        snapshot: () => {
+          const example = ctx.sessionManager.getLeafId() === null;
+          return { data: example ? sampleSnapshot() : current.snapshot(), example };
+        },
+        requestRender: () => tui.requestRender(), height: () => tui.terminal.rows,
+        done: () => done(),
+        save: async (next) => {
+          if (token !== generation) throw new Error("Session changed; reopen settings");
+          await store.save(next);
+          if (token !== generation) return;
+          config = next; current.apply(config);
+        },
+      }));
+    },
+  });
+}

package/src/panel.ts

@@ -0,0 +1,187 @@
+import { Input, matchesKey, SelectList, truncateToWidth, type Component, type Focusable, type SelectItem } from "@earendil-works/pi-tui";
+import { COLORS, parseConfig, presetConfig } from "./config.ts";
+import { cleanText, renderFooter, type RenderTheme } from "./render.ts";
+import type { SegmentConfig, StatuslineConfig, StatuslineSnapshot } from "./types.ts";
+
+interface PanelOptions {
+  config: StatuslineConfig;
+  theme: () => RenderTheme;
+  snapshot: () => { data: StatuslineSnapshot; example: boolean };
+  requestRender: () => void;
+  height: () => number;
+  save: (config: StatuslineConfig) => Promise<void>;
+  done: () => void;
+}
+
+/** All edits belong to a draft. Only a successful explicit Save changes the running footer. */
+export class StatuslinePanel implements Component, Focusable {
+  private options: PanelOptions;
+  private draft: StatuslineConfig;
+  private list!: SelectList;
+  private editing: SegmentConfig | undefined;
+  private input: Input | undefined;
+  private inputLabel = "";
+  private error = "";
+  private saving = false;
+  private disposed = false;
+  private hasFocus = false;
+  private listHeight = 0;
+
+  constructor(options: PanelOptions) { this.options = options; this.draft = structuredClone(options.config); this.rebuild(); }
+  get focused(): boolean { return this.hasFocus; }
+  set focused(value: boolean) { this.hasFocus = value; if (this.input) this.input.focused = value; }
+  private paint(text: string, color: "text" | "accent" | "muted" | "error" = "text"): string {
+    const theme = this.options.theme(); return theme.style(text, { fg: theme.colors[color] });
+  }
+  private thinkingConfig(): SegmentConfig {
+    let thinking = this.draft.segments.find((segment) => segment.id === "thinking");
+    if (!thinking) { thinking = { id: "thinking", enabled: false }; this.draft.segments.push(thinking); }
+    return thinking;
+  }
+  private items(): SelectItem[] {
+    if (this.editing) {
+      const segment = this.editing;
+      return [
+        { value: "enabled", label: `Enabled: ${segment.enabled ? "yes" : "no"}` },
+        ...(["icon", "color", "iconColor", "background"] as const).map((key) => ({ value: key, label: `${key}: ${segment[key] ?? "(default)"}`, description: key === "icon" ? "Empty text hides the icon; :default restores it" : "Semantic color or #RRGGBB; empty restores default" })),
+        ...(segment.id === "model" ? [
+          { value: "thinking", label: `Thinking level: ${this.thinkingConfig().enabled ? "yes" : "no"}`, description: "Colored level in parentheses after the model name" },
+          { value: "thinkingColor", label: `Thinking color: ${this.thinkingConfig().color ?? "automatic"}`, description: "Automatic uses level colors; high/xhigh/max use rainbow" },
+        ] : []),
+        { value: "back", label: "Back to segments" },
+      ];
+    }
+    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}` },
+      { value: "pathMode", label: `Path: ${this.draft.pathMode}` },
+      { 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: "save", label: "Save and apply globally" },
+      { value: "reset", label: "Restore defaults in preview" },
+      { value: "cancel", label: "Cancel" },
+    ];
+  }
+  private rebuild(selected?: string): void {
+    const items = this.items();
+    this.listHeight = Math.max(1, this.options.height() - 12);
+    this.list = new SelectList(items, this.listHeight, {
+      selectedPrefix: (text) => this.paint(text, "accent"), selectedText: (text) => this.paint(text, "accent"),
+      description: (text) => this.paint(text, "muted"), scrollInfo: (text) => this.paint(text, "muted"), noMatch: (text) => this.paint(text, "muted"),
+    });
+    this.list.onSelect = (item) => this.activate(item.value);
+    this.list.onCancel = () => this.cancel();
+    if (selected) this.list.setSelectedIndex(Math.max(0, items.findIndex((item) => item.value === selected)));
+  }
+  private cancel(): void {
+    if (this.input) { this.input = undefined; this.error = ""; }
+    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.editing) {
+      if (value === "back") this.cancel();
+      else if (value === "enabled") { this.editing.enabled = !this.editing.enabled; this.rebuild(value); }
+      else if (value === "thinking") { const thinking = this.thinkingConfig(); thinking.enabled = !thinking.enabled; this.rebuild(value); }
+      else this.editProperty(value as "icon" | "color" | "iconColor" | "background" | "thinkingColor");
+      return;
+    }
+    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 "reset": this.draft = presetConfig(); break;
+      case "cancel": this.options.done(); return;
+      case "save": void this.save(); return;
+      default: this.editing = this.draft.segments.find((segment) => `segment:${segment.id}` === value); break;
+    }
+    this.rebuild(this.editing ? undefined : value);
+  }
+  private editProperty(property: "icon" | "color" | "iconColor" | "background" | "thinkingColor"): void {
+    const editingId = this.editing!.id;
+    const segment = property === "thinkingColor" ? this.thinkingConfig() : this.editing!;
+    const key = property === "thinkingColor" ? "color" : property;
+    const input = new Input();
+    input.setValue(segment[key] ?? (key === "icon" ? ":default" : ""));
+    input.focused = this.hasFocus;
+    this.input = input;
+    this.inputLabel = key === "icon" ? "Icon (empty hides; :default restores)" : `${key} (#RRGGBB or ${COLORS.slice(0, 7).join(", ")}; empty restores)`;
+    input.onEscape = () => this.cancel();
+    input.onSubmit = (text) => {
+      const candidate = structuredClone(this.draft);
+      const target = candidate.segments.find((item) => item.id === segment.id)!;
+      if ((key === "icon" && text === ":default") || (key !== "icon" && !text.trim())) delete target[key];
+      else (target as unknown as Record<string, unknown>)[key] = key === "icon" ? text : text.trim();
+      try {
+        this.draft = parseConfig(candidate);
+        this.editing = this.draft.segments.find((item) => item.id === editingId);
+        this.input = undefined; this.error = ""; this.rebuild(property);
+      } catch (error) { this.error = error instanceof Error ? error.message : String(error); }
+    };
+  }
+  private async save(): Promise<void> {
+    this.saving = true;
+    this.options.requestRender();
+    try { await this.options.save(structuredClone(this.draft)); if (!this.disposed) this.options.done(); }
+    catch (error) { if (!this.disposed) this.error = `Save failed: ${error instanceof Error ? error.message : String(error)}`; }
+    finally { this.saving = false; if (!this.disposed) this.options.requestRender(); }
+  }
+  handleInput(data: string): void {
+    if (this.saving || this.disposed) return;
+    if (this.input) this.input.handleInput(data);
+    else {
+      const selected = this.list.getSelectedItem()?.value;
+      const segmentIndex = this.draft.segments.findIndex((segment) => `segment:${segment.id}` === selected);
+      if (!this.editing && segmentIndex >= 0 && matchesKey(data, "space")) {
+        const segment = this.draft.segments[segmentIndex]!; segment.enabled = !segment.enabled; this.rebuild(selected);
+      } else if (!this.editing && segmentIndex >= 0 && (matchesKey(data, "alt+up") || matchesKey(data, "alt+down"))) {
+        const direction = matchesKey(data, "alt+up") ? -1 : 1;
+        let next = segmentIndex + direction;
+        while (this.draft.segments[next]?.id === "thinking") next += direction;
+        if (next >= 0 && next < this.draft.segments.length) {
+          [this.draft.segments[segmentIndex], this.draft.segments[next]] = [this.draft.segments[next]!, this.draft.segments[segmentIndex]!];
+          this.rebuild(selected);
+        }
+      } else this.list.handleInput(data);
+    }
+    if (!this.disposed) this.options.requestRender();
+  }
+  invalidate(): void { this.list.invalidate(); this.input?.invalidate(); }
+  dispose(): void { this.disposed = true; }
+  render(width: number): string[] {
+    if (width <= 0) return [];
+    if (this.listHeight !== Math.max(1, this.options.height() - 12)) this.rebuild(this.list.getSelectedItem()?.value);
+    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(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"),
+      "",
+      ...(this.input ? [this.paint(this.inputLabel, "accent"), ...this.input.render(width)] : this.list.render(width)),
+      "",
+      this.paint(this.saving ? "Saving…" : "↑↓ select · Space toggle · Alt+↑↓ reorder · Enter edit · Esc back/cancel", "muted"),
+      ...(this.error ? [this.paint(cleanText(this.error), "error")] : []),
+    ];
+    return lines.map((line) => truncateToWidth(line, width));
+  }
+}

package/src/render.ts

@@ -0,0 +1,209 @@
+import { basename, isAbsolute, relative, sep } from "node:path";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { parseColor, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { cleanText } from "./text.ts";
+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";
+
+export type RenderTheme = Pick<Theme, "style" | "colors" | "appearance">;
+// Keep rainbow hues independent of semantic theme colors, which can repeat.
+const THINKING_RAINBOW = ["#c084fc", "#f472b6", "#fb923c", "#facc15", "#4ade80", "#22d3ee", "#60a5fa"].map((value) => parseColor(value));
+const ICONS: Record<StatuslineConfig["icons"], Partial<Record<SegmentId, string>>> = {
+  unicode: { model: "", directory: "▸", git: "⑂", context: "◉", cost: "$", input: "↑", output: "↓", tokens: "Σ", cacheRead: "R", cacheWrite: "W" },
+  nerd: { model: "", directory: "󰉋", git: "", context: "󰆼", cost: "$", input: "↑", output: "↓", tokens: "󰊄", cacheRead: "R", cacheWrite: "W" },
+  ascii: { model: "", directory: "", git: "git:", context: "ctx:", cost: "$", input: "in:", output: "out:", tokens: "tok:", cacheRead: "R:", cacheWrite: "W:" },
+};
+const DROP_ORDER: SegmentId[] = ["cost", "cacheWrite", "cacheRead", "tokens", "output", "input", "thinking", "git", "directory"];
+export function formatTokens(value: number): string {
+  if (value < 1000) return String(Math.round(value));
+  const divisor = value >= 1e6 ? 1e6 : 1000;
+  return `${Number((value / divisor).toFixed(1))}${divisor === 1e6 ? "M" : "k"}`;
+}
+function contextBar(percent: number | null, ascii: boolean): string {
+  const width = 10;
+  if (percent === null || !Number.isFinite(percent)) return `[${"?".repeat(width)}]?%`;
+  const fill = Math.max(0, Math.min(100, percent)) / 100 * width;
+  // Whole cells avoid the blank right side of fractional glyphs such as ▌.
+  // Keep small, non-zero usage visible; the percentage gives the precise value.
+  const full = fill > 0 ? Math.max(1, Math.round(fill)) : 0;
+  const bar = (ascii ? "#" : "█").repeat(full) + (ascii ? "-" : "░").repeat(width - full);
+  return `[${bar}]${Number(percent.toFixed(1))}%`;
+}
+function displayPath(data: StatuslineSnapshot, mode: StatuslineConfig["pathMode"]): string {
+  if (mode === "basename") return basename(data.cwd) || data.cwd;
+  const rel = data.home ? relative(data.home, data.cwd) : "..";
+  const inside = rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+  const full = inside ? (rel ? `~${sep}${rel}` : "~") : data.cwd;
+  if (mode !== "abbreviated" || visibleWidth(full) <= 36) return full;
+  const parts = full.split(sep);
+  return `…${sep}${parts.slice(-2).join(sep)}`;
+}
+function gitText(data: StatuslineSnapshot, ascii: boolean): string | undefined {
+  const git = data.git;
+  if (git.kind === "none") return undefined;
+  if (git.kind === "unknown") return `${git.branch ?? ""} ?`.trim();
+  const bits = [git.branch ?? "HEAD"];
+  if (git.detached) bits.push(ascii ? "(detached)" : "detached");
+  if (git.conflicts) bits.push(`${ascii ? "!" : "⚠"}${git.conflicts}`);
+  else bits.push(git.staged + git.unstaged + git.untracked ? (ascii ? "*" : "●") : (ascii ? "ok" : "✓"));
+  if (git.staged) bits.push(`+${git.staged}`);
+  if (git.unstaged) bits.push(`*${git.unstaged}`);
+  if (git.untracked) bits.push(`?${git.untracked}`);
+  if (git.ahead) bits.push(`${ascii ? "^" : "↑"}${git.ahead}`);
+  if (git.behind) bits.push(`${ascii ? "v" : "↓"}${git.behind}`);
+  return bits.join(" ");
+}
+function segmentText(id: SegmentId, data: StatuslineSnapshot, config: StatuslineConfig): string | undefined {
+  const usage = data.usage;
+  switch (id) {
+    case "model": return (config.modelDisplay === "last" ? data.modelId.split("/").filter(Boolean).at(-1) : undefined) || data.model || "No model";
+    case "thinking": return undefined; // Its settings now control the model's suffix.
+    case "directory": return displayPath(data, config.pathMode);
+    case "git": return gitText(data, config.icons === "ascii");
+    case "context": {
+      const { tokens, percent, contextWindow } = data.context;
+      if (config.contextDisplay === "bar") return contextBar(percent, config.icons === "ascii");
+      const capacity = contextWindow > 0 ? formatTokens(contextWindow) : "?";
+      return `${tokens === null ? "?" : formatTokens(tokens)}/${capacity}(${percent === null ? "?" : Number(percent.toFixed(1))}%)`;
+    }
+    case "cost": return usage.cost.toFixed(3);
+    case "input": return formatTokens(usage.input);
+    case "output": return formatTokens(usage.output);
+    case "tokens": return formatTokens(usage.input + usage.output + usage.cacheRead + usage.cacheWrite);
+    case "cacheRead": return formatTokens(usage.cacheRead);
+    case "cacheWrite": return formatTokens(usage.cacheWrite);
+    case "statuses": return [...data.statuses.values()].map(cleanText).filter(Boolean).join(" · ") || undefined;
+  }
+}
+function defaultColor(id: SegmentId, data: StatuslineSnapshot, config: StatuslineConfig): ColorValue {
+  if (id === "context") {
+    if ((data.context.percent ?? 0) > 90) return "error";
+    if ((data.context.percent ?? 0) > 70) return "warning";
+  }
+  if (id === "git") {
+    if (data.git.conflicts) return "error";
+    if (data.git.kind === "unknown" || data.git.staged + data.git.unstaged + data.git.untracked) return "warning";
+    return "success";
+  }
+  if (id === "thinking") {
+    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";
+  if (id === "cost") return "text";
+  return "muted";
+}
+function color(value: ColorValue, theme: RenderTheme) {
+  return value.startsWith("#") ? parseColor(value) : theme.colors[value as Exclude<ColorValue, `#${string}`>];
+}
+interface Part {
+  config: SegmentConfig;
+  text: string;
+  icon: string;
+  foreground: ColorValue;
+  background?: ColorValue;
+  thinking?: { text: string; foreground: ColorValue | "rainbow" };
+}
+function renderPart(part: Part, theme: RenderTheme): string {
+  const bg = part.background ? color(part.background, theme) : undefined;
+  const style = { fg: color(part.foreground, theme), ...(bg ? { bg } : {}) };
+  const icon = part.icon ? theme.style(`${part.icon} `, { ...style, fg: color(part.config.iconColor ?? part.foreground, theme) }) : "";
+  const text = theme.style(part.text, style);
+  let suffix = "";
+  if (part.thinking) {
+    const { text: level, foreground } = part.thinking;
+    const label = `(${level})`;
+    const characters = Array.from(label);
+    suffix = foreground === "rainbow"
+      ? characters.map((character, i) => theme.style(character, {
+          ...style,
+          fg: THINKING_RAINBOW[Math.round(i * (THINKING_RAINBOW.length - 1) / Math.max(1, characters.length - 1))]!,
+        })).join("")
+      : theme.style(label, { ...style, fg: color(foreground, theme) });
+  }
+  const content = `${icon}${text}${suffix}`;
+  return bg ? `${theme.style(" ", style)}${content}${theme.style(" ", style)}` : content;
+}
+function joinParts(parts: Part[], config: StatuslineConfig, theme: RenderTheme): string {
+  return parts.map((part, i) => {
+    let separator = "";
+    const previous = parts[i - 1];
+    if (previous) {
+      if (config.separator === "powerline" && config.icons !== "ascii") {
+        separator = theme.style("", {
+          fg: color(previous.background ?? previous.foreground, theme),
+          ...(part.background ? { bg: color(part.background, theme) } : {}),
+        });
+      } else {
+        const sep = config.separator === "space" ? " " : config.separator === "dot" && config.icons !== "ascii" ? " · " : " | ";
+        separator = theme.style(sep, { fg: theme.colors.dim });
+      }
+    }
+    return separator + renderPart(part, theme);
+  }).join("");
+}
+
+/** Pure terminal rendering: no disk reads, processes or session traversal. */
+export function renderFooter(width: number, data: StatuslineSnapshot, config: StatuslineConfig, theme: RenderTheme): string[] {
+  width = Math.max(0, Math.floor(width));
+  if (width === 0) return [];
+  const parts: Part[] = [];
+  let secondary: Part | undefined;
+  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);
+    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 };
+    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)),
+      };
+    }
+    if (segment.id === "statuses") secondary = part;
+    else parts.push(part);
+  }
+  let line = joinParts(parts, config, theme);
+  const ellipsis = config.icons === "ascii" ? "..." : "…";
+  if (visibleWidth(line) > width) {
+    for (const id of ["directory", "model"] as const) {
+      const part = parts.find((p) => p.config.id === id);
+      if (part) part.text = truncateToWidth(part.text, Math.max(6, Math.min(24, Math.floor(width / 4))), ellipsis);
+    }
+    line = joinParts(parts, config, theme);
+    for (const id of DROP_ORDER) {
+      if (visibleWidth(line) <= width) break;
+      if (id === "thinking") {
+        const model = parts.find((p) => p.config.id === "model");
+        if (model) model.thinking = undefined;
+      } else {
+        const index = parts.findIndex((p) => p.config.id === id);
+        if (index !== -1) parts.splice(index, 1);
+      }
+      line = joinParts(parts, config, theme);
+    }
+  }
+  const lines: string[] = [];
+  if (parts.length) lines.push(truncateToWidth(line, width, ellipsis));
+  if (secondary) lines.push(truncateToWidth(renderPart(secondary, theme), width, ellipsis));
+  return lines;
+}
+
+export function sampleSnapshot(): StatuslineSnapshot {
+  return {
+    model: "Example model", modelId: "example/provider/model", reasoning: true, thinking: "high", cwd: "/projects/pi-packages", home: "/home/example",
+    context: { tokens: 23800, contextWindow: 200000, percent: 11.9 },
+    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"]]),
+  };
+}

package/src/session.ts

@@ -0,0 +1,108 @@
+import { homedir } from "node:os";
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+import type { ExtensionContext, ReadonlyFooterDataProvider } from "@earendil-works/pi-coding-agent";
+import type { TUI } from "@earendil-works/pi-tui";
+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";
+
+export class FooterSession {
+  private ctx: ExtensionContext;
+  private config: StatuslineConfig;
+  private usage = new UsageCache();
+  private git = emptyGit();
+  private provider: ReadonlyFooterDataProvider | undefined;
+  private tui: Pick<TUI, "requestRender"> | undefined;
+  private poller: GitPoller | undefined;
+  private timer: ReturnType<typeof setInterval> | undefined;
+  private scheduled: ReturnType<typeof setTimeout> | undefined;
+  private unsubscribe: (() => void) | undefined;
+  private closed = false;
+  private ownsFooter = false;
+  private statsKey = "";
+  private displayKey = "";
+  private context: StatuslineSnapshot["context"] = { tokens: null, contextWindow: 0, percent: null };
+  private readonly gitReader: GitReader | undefined;
+
+  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; }
+  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.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.unref();
+      return {
+        render: (width: number) => renderFooter(width, this.snapshot(), this.config, this.ctx.ui.theme),
+        invalidate: () => {}, // Theme and extension statuses are read fresh on every render.
+        dispose: () => this.stopResources(),
+      };
+    });
+  }
+  private stopResources(): void {
+    clearInterval(this.timer); clearTimeout(this.scheduled);
+    this.timer = undefined; this.scheduled = undefined;
+    this.poller?.dispose(); this.poller = undefined;
+    this.unsubscribe?.(); this.unsubscribe = undefined;
+    this.ownsFooter = false; this.tui = undefined; this.provider = undefined;
+  }
+  disable(): void {
+    const restore = this.ownsFooter;
+    this.stopResources();
+    if (restore && !this.closed) this.ctx.ui.setFooter(undefined);
+  }
+  dispose(): void { this.stopResources(); this.closed = true; }
+  apply(config: StatuslineConfig): void {
+    if (this.closed) return;
+    this.disable(); this.config = config;
+    if (config.enabled) this.install();
+  }
+  setLive(message: AssistantMessage | undefined): void { this.usage.setLive(message); }
+  schedule(immediate = false): void {
+    if (!this.active) return;
+    if (immediate) { clearTimeout(this.scheduled); this.scheduled = undefined; }
+    if (this.scheduled) return;
+    // Defer final events too: Pi emits message_end before appending the message.
+    this.scheduled = setTimeout(() => { this.scheduled = undefined; this.refresh(); }, immediate ? 0 : 100);
+    this.scheduled.unref();
+  }
+  requestGit(): void {
+    if (this.active && this.config.segments.some((segment) => segment.id === "git" && segment.enabled)) void this.poller?.refresh();
+  }
+  refresh(force = false): void {
+    if (this.closed) return;
+    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 context = this.ctx.getContextUsage();
+      this.context = context ?? { tokens: null, contextWindow: this.ctx.model?.contextWindow ?? 0, percent: null };
+      this.statsKey = key;
+    }
+    this.repaint();
+  }
+  private repaint(): void {
+    if (!this.active) return;
+    const snapshot = this.snapshot();
+    const key = JSON.stringify({ ...snapshot, statuses: undefined });
+    if (key === this.displayKey) return;
+    this.displayKey = key; this.tui?.requestRender();
+  }
+  snapshot(): StatuslineSnapshot {
+    return {
+      model: this.ctx.model?.name || this.ctx.model?.id || "No model", modelId: this.ctx.model?.id ?? "", reasoning: this.ctx.model?.reasoning ?? false,
+      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(),
+    };
+  }
+}

package/src/text.ts

@@ -0,0 +1,11 @@
+import { stripTerminalSequences } from "@earendil-works/pi-tui";
+
+export function cleanText(text: string): string {
+  return stripTerminalSequences(text.replace(/[\r\n\t]/g, " ")).replace(/[\p{Cc}\u202a-\u202e\u2066-\u2069]/gu, "").trim();
+}
+/** Details never echo URLs, credentials or unbounded provider errors. */
+export function safeReason(text: string): string {
+  return cleanText(text).replace(/https?:\/\/\S+/gi, "[URL]")
+    .replace(/\b(Bearer|Basic)\s+\S+/gi, "$1 [redacted]")
+    .replace(/\b(api[-_]?key|token|authorization|password|secret)\s*[:=]\s*\S+/gi, "$1=[redacted]").slice(0, 180);
+}

package/src/types.ts

@@ -0,0 +1,81 @@
+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 IconMode = "unicode" | "nerd" | "ascii";
+export interface RuntimeConfig {
+  enabled: boolean;
+  status: boolean;
+  tools: boolean;
+  noContent: boolean;
+  noContentSeconds: number;
+  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;
+  icon?: string;
+  color?: ColorValue;
+  iconColor?: ColorValue;
+  background?: ColorValue;
+}
+export interface StatuslineConfig {
+  version: 1;
+  enabled: boolean;
+  preset: Preset;
+  icons: IconMode;
+  separator: "pipe" | "dot" | "space" | "powerline";
+  pathMode: "basename" | "abbreviated" | "full";
+  modelDisplay: "name" | "last";
+  contextDisplay: "text" | "bar";
+  segments: SegmentConfig[];
+  runtime: RuntimeConfig;
+  providerMetrics: ProviderMetricsConfig;
+  integrations: { cliproxyapi: "auto" | "off" | "on" };
+}
+export interface UsageTotals {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  cost: number;
+}
+export interface GitState {
+  kind: "repository" | "none" | "unknown";
+  branch: string | null;
+  detached: boolean;
+  staged: number;
+  unstaged: number;
+  untracked: number;
+  conflicts: number;
+  ahead: number;
+  behind: number;
+}
+export interface StatuslineSnapshot {
+  model: string;
+  modelId: string;
+  reasoning: boolean;
+  thinking: string;
+  cwd: string;
+  home: string;
+  context: { tokens: number | null; contextWindow: number; percent: number | null };
+  usage: UsageTotals;
+  git: GitState;
+  statuses: ReadonlyMap<string, string>;
+  runtime?: import("./runtime.ts").RuntimeSnapshot;
+  compaction?: import("./compaction.ts").CompactionSnapshot;
+  telemetry?: import("./receiver.ts").TelemetrySnapshot;
+}

package/src/usage.ts

@@ -0,0 +1,52 @@
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
+import type { UsageTotals } from "./types.ts";
+
+export function emptyUsage(): UsageTotals { return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 }; }
+const finite = (value: unknown): number => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+export function readUsage(value: unknown): UsageTotals {
+  if (!value || typeof value !== "object") return emptyUsage();
+  const usage = value as Record<string, unknown>;
+  const cost = usage.cost && typeof usage.cost === "object" ? (usage.cost as Record<string, unknown>).total : 0;
+  return { input: finite(usage.input), output: finite(usage.output), cacheRead: finite(usage.cacheRead), cacheWrite: finite(usage.cacheWrite), cost: finite(cost) };
+}
+export function entryUsage(entry: SessionEntry): UsageTotals {
+  if (entry.type === "usage" || entry.type === "compaction" || entry.type === "branch_summary") return readUsage(entry.usage);
+  if (entry.type === "message" && (entry.message.role === "assistant" || entry.message.role === "toolResult")) return readUsage(entry.message.usage);
+  return emptyUsage();
+}
+function add(target: UsageTotals, value: UsageTotals, sign = 1): void {
+  for (const key of Object.keys(target) as (keyof UsageTotals)[]) target[key] += sign * value[key];
+}
+function messageKey(message: AssistantMessage): string { return `${message.provider}/${message.model}/${message.timestamp}`; }
+
+/** Persisted totals plus one replaceable in-flight response, never summed per streaming event. */
+export class UsageCache {
+  private totals = emptyUsage();
+  private contributions = new Map<string, UsageTotals>();
+  private persistedMessages = new Set<string>();
+  private count = 0;
+  private live: AssistantMessage | undefined;
+  reset(): void {
+    this.totals = emptyUsage(); this.contributions.clear(); this.persistedMessages.clear(); this.count = 0; this.live = undefined;
+  }
+  update(entries: readonly SessionEntry[], rebuild = false): void {
+    if (rebuild || entries.length < this.count) this.reset();
+    // SessionManager appends immutable records; revisit the previous tail as a defensive measure.
+    for (const entry of entries.slice(Math.max(0, this.count - 1))) {
+      const previous = this.contributions.get(entry.id);
+      if (previous) add(this.totals, previous, -1);
+      const usage = entryUsage(entry);
+      add(this.totals, usage);
+      this.contributions.set(entry.id, usage);
+      if (entry.type === "message" && entry.message.role === "assistant") this.persistedMessages.add(messageKey(entry.message));
+    }
+    this.count = entries.length;
+  }
+  setLive(message: AssistantMessage | undefined): void { this.live = message; }
+  snapshot(): UsageTotals {
+    const total = { ...this.totals };
+    if (this.live && !this.persistedMessages.has(messageKey(this.live))) add(total, readUsage(this.live.usage));
+    return total;
+  }
+}