osdy-pi 1.11.13 → 1.11.15

package/README.md

@@ -238,7 +238,7 @@ For a project-local installation, run `pi remove -l npm:@juicesharp/rpiv-todo` i
 
 **Quick path:** `/osdyConfig` → **Account** → select a profile → **v** (or **Enter**) for quota bars. Use **r Refresh** to query again or **b Back** / **Esc** to return with the profile selected. From the overview or quota dashboard, **s Switch** opens the same Cancel-first confirmation for the eligible inactive profile; cancelling from quota preserves the view and scroll position. From the overview, **d** sets the default and **c** clears an existing default, also with Cancel-first confirmation. The active profile also supports explicit stored-credential queries.
 
-Preview is **Codex only**, a live query using the selected profile's **stored credentials snapshot**, with no automatic refresh or stored-profile polling. Only **View usage** and the quota view's **Refresh** query; profile navigation does not. It never activates, borrows active credentials, refreshes tokens, writes auth, changes models/session state or overwrites active quota. Missing, malformed, expired or remotely rejected snapshots are unavailable—not zero quota. Even the current profile's stored snapshot may be stale: log in and save through the normal account workflow outside preview. Profile labels and decoded JWT claims do not verify human identity or server validity. Local history remains token/cost estimates, not subscription quota. Legacy `/osdy-account`, `/usage` and `/osdy-usage` remain available; Agents configuration remains normal personal Pi only.
+Preview is **Codex only**, a live query using the selected profile's **stored credentials snapshot**, with no automatic refresh or stored-profile polling. In the Control Center, only **View usage** and the quota view's **Refresh** query; profile navigation does not. `/osdy-account` → **Switch** queries all saved profiles before opening the selector, with up to four previews in parallel. It never activates, borrows active credentials, refreshes tokens, writes auth, changes models/session state or overwrites active quota. Missing, malformed, expired or remotely rejected snapshots are unavailable—not zero quota. Even the current profile's stored snapshot may be stale: log in and save through the normal account workflow outside preview. Profile labels and decoded JWT claims do not verify human identity or server validity. Local history remains token/cost estimates, not subscription quota. Legacy `/osdy-account`, `/usage` and `/osdy-usage` remain available; Agents configuration remains normal personal Pi only.
 
 Osdy Pi can keep multiple ChatGPT Plus/Pro accounts authenticated and let you choose which one starts Pi. `personal` and `work` are only examples—you can create as many named profiles as you need.
 
@@ -248,13 +248,17 @@ Osdy Pi can keep multiple ChatGPT Plus/Pro accounts authenticated and let you ch
 
 | Action | Behavior |
 | --- | --- |
-| **Switch** | Waits for idle, safely replaces Pi's canonical auth with the selected profile, and updates active/default together without restarting Pi. |
+| **Switch** | Lists profile names and active/default markers only. Use arrows to highlight, **v** for `/usage`-style quota details, and **Enter from the list only** to switch the exact profile after idle waiting. |
 | **Add** | Creates an isolated profile without restarting or changing the default. Select it with **Switch**, then run `/login`. |
 | **Default** | Shows, changes, or clears the profile used by future plain installed `pi` and `npm run pi:dev` launches. It does not switch the current process. |
 | **Rename** | Renames an inactive profile. The default follows the new name when applicable. |
 | **Remove** | Permanently deletes an inactive profile after exact-name confirmation. Removing the default requires a replacement. |
 | **Account info** | Shows the available profiles and marks the active and default profiles without reading credentials. |
 
+In **Switch**, press **v** on the highlighted profile to explore its saved preview using the same dashboard as `/usage`, without selecting or activating it. Scroll details with **↑/↓**, **Page Up/Down**, or **Home/End**. **Esc** or **b** returns to the same highlighted profile; **Enter does nothing in details**. **Esc from the list** cancels selection.
+
+Switch previews are read-only and never activate accounts, refresh tokens, use resets or persist auth. Quota and **usage unavailable** messaging appear only in **v** details, never in the Switch list. Failed, expired or unsupported profiles remain selectable, including after viewing unavailable details. Opening details reuses the selector's snapshot without another request; reopening **Switch** queries again (up to four in parallel), never polls saved profiles. Reset timings include relative time and UTC timestamps when supplied by Codex. The detailed selector requires Pi's terminal UI.
+
 Pi does not expose a supported API for extensions to invoke its OAuth login dialog. After switching to a newly created profile, run Pi's native `/login` and choose **ChatGPT Plus/Pro (Codex)**. This is the only step that remains a separate Pi command; it does not require leaving Pi or opening another terminal.
 
 Terminal commands remain available as recovery and automation alternatives:
@@ -414,7 +418,7 @@ Animation is enabled by default with an intro animation. Configure it through `O
 
 In the extended framed editor, the active thinking level is rendered in bold in the top-right model metadata so it remains easy to scan.
 
-The full header and mascot render side by side only when the available width and height permit it without an additional width-limited mascot reduction. Otherwise, only the centered mascot renders—there is no scaled or stacked logo. Small and compact modes trim only fully empty mascot-art and tone-map margins before applying one proportional width-and-height scale; mascot width starts near four-fifths of the available width. The fallback mascot uses the available terminal rows, capped at 32 content rows, without reserving rows for a logo. The small-mode footer places the model and styled bare thinking level above usage, path/branch, and dynamic extension statuses. Pi Lens's footer status is hidden in small mode, but Pi Lens continues running. Usage includes input/output/cache-read/cache-write tokens, cost, and context. Extension statuses are supplied dynamically by Pi/extensions and may include Osdy Pi, MCP, or LSP; they are not hardcoded.
+The full header and mascot render side by side only when the available width and height permit it without an additional width-limited mascot reduction. Otherwise, only the centered mascot renders—there is no scaled or stacked logo. Small and compact modes trim only fully empty mascot-art and tone-map margins before applying one proportional width-and-height scale; mascot width starts near four-fifths of the available width. The fallback mascot uses the available terminal rows, capped at 32 content rows, without reserving rows for a logo. The small-mode footer places the model and styled bare thinking level above usage, path/branch, and dynamic extension statuses. Pi Lens's footer status is hidden in small mode, but Pi Lens continues running. Usage includes response speed, cache-read/cache-write tokens when space permits, cost, and context. Extension statuses are supplied dynamically by Pi/extensions and may include Osdy Pi, MCP, or LSP; they are not hardcoded.
 
 The enabled state, editor mode, working-tree visibility preference, header, and mascot persist globally across Pi reloads and sessions, shared by all projects. They are saved in `$PI_CODING_AGENT_DIR/extensions/osdy-pi/settings.json`, or `~/.pi/agent/extensions/osdy-pi/settings.json` when `PI_CODING_AGENT_DIR` is unset. Existing settings without the new visual fields safely default to `osdy-theme` and `current`; the former `raccoon` mascot value migrates to `bts`. The selected editor mode and working-tree placement are restored when the terminal moves normal → small → normal.
 
@@ -507,7 +511,15 @@ Pi renders the colored user card and assistant Markdown natively. User messages
 
 The default `auto` editor mode preserves the responsive behavior: it uses the framed editor when space permits and Pi's native editor on small terminals. Select `simple` for Pi's native editor at every width, or `extended` to request the framed editor explicitly: `/osdy-pi editor auto|extended|simple`. Simple mode actually unmounts the custom editor component rather than hiding it. Small terminals always use Pi's native editor, including when `extended` is selected. The legacy commands remain compatible where feasible: `on` maps to `extended`, `off` maps to `simple`, and `toggle` switches between extended and simple.
 
-In auto or extended mode at a non-small width, the framed editor shows the model and thinking level in its title and session usage in its footer. For an account-profile launch, the left title shows the active profile name instead of `Osdy-Pi`. When the native editor is effective (simple mode or any small terminal), the Osdy footer instead shows model, active profile when present, thinking, and usage rows before its path/branch and status rows. It uses the currently active Pi/Osdy theme palette; no separate editor theme selector exists. Usage covers input, output, cache read, cache write when present, cost, and context. If Pi supports autocomplete, the editor uses Pi's native autocomplete rendering while the completion UI is visible.
+In auto or extended mode at a non-small width, the framed editor shows the model and thinking level in its title and session usage in its footer. For an account-profile launch, the left title shows the active profile name instead of `Osdy-Pi`. When the native editor is effective (simple mode or any small terminal), the Osdy footer instead shows model, active profile when present, thinking, and usage rows before its path/branch and status rows. It uses the currently active Pi/Osdy theme palette; no separate editor theme selector exists. Usage shows response speed instead of cumulative input/output totals, alongside cache read/write when present, cost, and context. If Pi supports autocomplete, the editor uses Pi's native autocomplete rendering while the completion UI is visible.
+
+### Response speed
+
+The editor usage line (or native-mode footer) shows **`≈42.3 tok/s` while streaming**, estimated as accumulated streamed UTF-16 characters / 4 divided by seconds since the first nonempty output delta. Text, thinking, and tool-call argument deltas count once; snapshots and block-end events do not. This language-dependent heuristic is **not a tokenizer count or server-measured decode speed**. It updates on stream events, with no additional timer or editor remount.
+
+On successful message end, the label becomes **`42.3 tok/s`**: finalized output usage divided by the observed first-output-to-message-end interval. Output already includes reported reasoning tokens; input/cache tokens and subsequent tool execution are excluded. This is an observed response average, not server telemetry. Each assistant message starts a new reading. The completed reading remains until the next response; session replacement/reload clears it.
+
+**`tok/s …`** means pending or insufficient timing while streaming. **`tok/s —`** means idle or an unavailable reading after completion/interruption: missing/zero output usage, no output deltas, intervals under 100 ms, invalid timing, aborts, or errors. Narrow layouts simplify context and clip safely. Status and local analytics retain their existing token accounting; speed is volatile and never saved.
 
 While work is active, Osdy Pi centers an activity label and compact animated glyph above the editor:
 

package/extensions/osdy-pi/account-profile-selector.test.ts

@@ -0,0 +1,186 @@
+import assert from "node:assert/strict";
+import { existsSync } from "node:fs";
+import { registerHooks } from "node:module";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { InteractiveMode, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { TuiAltScreen, visibleWidth, type Component, type OverlayHandle } from "@earendil-works/pi-tui";
+import type { AccountProfileChoice } from "./account-profile-selector.js";
+
+registerHooks({ resolve(specifier, context, next) {
+	if (specifier.startsWith(".") && specifier.endsWith(".js") && context.parentURL?.endsWith(".ts")) {
+		const url = new URL(`${specifier.slice(0, -3)}.ts`, context.parentURL);
+		if (existsSync(fileURLToPath(url))) return { shortCircuit: true, url: url.href };
+	}
+	return next(specifier, context);
+} });
+const { AccountProfileSelector, selectAccountProfile } = await import("./account-profile-selector.js");
+const { renderCodexUsageDashboardContentLines } = await import("./codex-usage-ui.js");
+const theme = { fg: (_color: string, text: string) => text };
+const choice: AccountProfileChoice = { profile: "Work", label: "Work · 5h 75% left", usage: {
+	status: "ready", profile: "Work", checkedAt: 0, quotaSnapshot: {
+		fetchedAt: 0, planType: "plus", credits: undefined, ordinaryUsageAllowed: true,
+		bankedResetCount: 2, bankedResetDetails: [{ id: "one", expiresAt: 86400000 }, { id: "two", expiresAt: undefined }],
+		buckets: [{ id: "codex", label: undefined,
+			primary: { usedPercent: 25, windowMinutes: 300, resetsAt: 3600 },
+			secondary: { usedPercent: 60, windowMinutes: 10080, resetsAt: 86400 } },
+		{ id: "extra", label: "Extra quota", primary: { usedPercent: 5, windowMinutes: 60, resetsAt: 100 }, secondary: undefined }],
+	},
+} };
+
+// Exercise the installed SDK's actual custom lifecycle and fullscreen input router,
+// without a real terminal, session, auth, or network. Only its host editor is stubbed.
+async function mountedSelector(choices: readonly AccountProfileChoice[]) {
+	let input: (data: string) => void = () => {};
+	let resize: () => void = () => {};
+	const terminal = {
+		columns: 80, rows: 8, kittyProtocolActive: false,
+		start: (onInput: (data: string) => void, onResize: () => void) => { input = onInput; resize = onResize; },
+		stop() {}, async drainInput() {}, write() {}, moveBy() {}, hideCursor() {},
+		showCursor() {}, clearLine() {}, clearFromCursor() {}, clearScreen() {},
+		setTitle() {}, setProgress() {},
+	};
+	const tui = new TuiAltScreen(terminal);
+	let component: Component | undefined;
+	let handle: OverlayHandle | undefined;
+	let options: Parameters<ExtensionContext["ui"]["custom"]>[1];
+	const host = {
+		ui: tui, editor: { getText: () => "preserved", setText() {} },
+		editorContainer: { clear() {}, addChild(value: Component) { component = value; } },
+		keybindings: {}, disposeActiveSelector() {},
+	};
+	// This private SDK method is the implementation behind ctx.ui.custom.
+	const custom = (InteractiveMode.prototype as unknown as {
+		showExtensionCustom: ExtensionContext["ui"]["custom"];
+	}).showExtensionCustom;
+	const ui = { custom: ((factory, opts) => {
+		options = opts;
+		return custom.call(host, (sdkTui, sdkTheme, keys, done) => {
+			// Inject a deterministic theme instead of initializing user theme discovery.
+			const result = factory(sdkTui, theme as typeof sdkTheme, keys, done);
+			if (!(result instanceof Promise)) component = result;
+			return result;
+		}, { ...opts, onHandle: value => { handle = value; opts?.onHandle?.(value); } });
+	}) as ExtensionContext["ui"]["custom"] };
+	const result = selectAccountProfile(ui, choices);
+	await Promise.resolve();
+	tui.start();
+	tui.renderNow();
+	assert(component);
+	return { tui, terminal, result, component, options,
+		bounds: () => handle?.getBounds(),
+		screen: () => (tui as unknown as { previousScreen: string[] }).previousScreen.join("\n"),
+		input: (key: string) => { input(key); tui.renderNow(); },
+		resize: (columns: number, rows: number) => { terminal.columns = columns; terminal.rows = rows; resize(); tui.renderNow(); },
+	};
+}
+
+void test("custom selector mounts a capturing fullscreen overlay and receives viewport navigation", async () => {
+	const choices = Array.from({ length: 30 }, (_value, index) => ({ ...choice, profile: `Profile-${index}`, label: `Profile-${index}`, usage: undefined }));
+	const mounted = await mountedSelector(choices);
+	try {
+		assert.equal(mounted.options?.overlay, true);
+		assert(mounted.tui.hasOverlay());
+		mounted.input("\u001b[F");
+		assert.match(mounted.screen(), /> Profile-29/);
+		mounted.input("\u001b[H");
+		assert.match(mounted.screen(), /> Profile-0/);
+		mounted.input("\u001b[6~");
+		assert.match(mounted.screen(), /> Profile-6/);
+		mounted.input("\u001b[5~");
+		assert.match(mounted.screen(), /> Profile-0/);
+		mounted.input("v");
+		mounted.input("\r");
+		assert(mounted.tui.hasOverlay(), "Enter in details must not complete");
+		mounted.input("b");
+		mounted.input("\r");
+		assert.equal(await mounted.result, "Profile-0");
+		assert.equal(mounted.tui.hasOverlay(), false);
+	} finally { mounted.tui.stop(); }
+});
+
+void test("SDK overlay and component share a responsive viewport at short heights and resize", async () => {
+	const mounted = await mountedSelector([choice]);
+	try {
+		assert.equal(mounted.options?.overlay, true);
+		const options = typeof mounted.options?.overlayOptions === "function" ? mounted.options.overlayOptions() : mounted.options?.overlayOptions;
+		assert.deepEqual(options, { width: "100%", maxHeight: "100%", margin: 0, nonCapturing: false });
+		mounted.input("v");
+		for (const [width, height] of [[80, 8], [12, 4], [1, 1], [32, 3], [100, 24], [80, 8]] as const) {
+			mounted.resize(width, height);
+			mounted.input("\u001b[F");
+			const lines = mounted.component.render(width);
+			assert(lines.length <= height);
+			assert(lines.every(line => visibleWidth(line) <= width));
+			assert.deepEqual(mounted.bounds(), { row: 0, col: 0, width, height: lines.length });
+			if (height >= 3) {
+				assert.equal(lines.length, height, "use exactly the SDK viewport, without invisible content");
+				assert.match(lines.at(-1)!, /esc\/b/);
+			}
+		}
+		assert.match(mounted.screen(), /Banked resets: 2/);
+		mounted.input("\u001b[H");
+		assert.match(mounted.screen(), /Checked:/);
+		mounted.input("\u001b");
+		mounted.input("\u001b");
+		assert.equal(await mounted.result, undefined);
+	} finally { mounted.tui.stop(); }
+});
+
+void test("details reuse the complete dashboard without active-model attribution or action controls", () => {
+	const results: (string | undefined)[] = [];
+	const panel = new AccountProfileSelector([choice], theme, () => 500, () => {}, value => results.push(value));
+	panel.handleInput("v");
+	assert(choice.usage?.status === "ready");
+	const dashboard = renderCodexUsageDashboardContentLines(theme, choice.usage.quotaSnapshot,
+		{ profile: "Work", provider: "openai-codex" }, 0, 100);
+	assert.deepEqual(panel.render(100).slice(3, -1), dashboard);
+	assert.match(dashboard.join("\n"), /Banked resets: 2/);
+	assert.match(dashboard.join("\n"), /Extra quota/);
+	for (const key of ["\r", "r", "u", "s"]) panel.handleInput(key);
+	assert.deepEqual(results, []);
+	panel.handleInput("\u001b");
+	panel.handleInput("\r");
+	panel.handleInput("\r");
+	assert.deepEqual(results, ["Work"]);
+});
+
+void test("details scrolling and resizing bound every line and reach the final dashboard fields", () => {
+	let height = 8;
+	let renders = 0;
+	const panel = new AccountProfileSelector([choice], theme, () => height, () => { renders++; }, () => assert.fail("details cannot finish"));
+	panel.handleInput("v");
+	for (const width of [1, 3, 12, 32, 100]) {
+		for (const key of ["\u001b[H", "\u001b[B", "\u001b[6~", "\u001b[5~", "\u001b[F"]) {
+			panel.render(width);
+			panel.handleInput(key);
+			const lines = panel.render(width);
+			assert(lines.length <= height);
+			assert(lines.every(line => visibleWidth(line) <= width));
+		}
+	}
+	assert.match(panel.render(100).join("\n"), /Banked resets: 2/);
+	height = 4;
+	assert(panel.render(12).length <= height);
+	height = 500;
+	const expanded = panel.render(100).join("\n");
+	assert.match(expanded, /Checked:/);
+	assert.match(expanded, /Extra quota/);
+	assert(renders > 0);
+});
+
+void test("long lists keep highlight visible, back preserves identity, and cancellation returns undefined", () => {
+	const choices = Array.from({ length: 30 }, (_value, index) => ({ profile: `Profile-${index}`, label: `Profile-${index}`, usage: undefined }));
+	const results: (string | undefined)[] = [];
+	const panel = new AccountProfileSelector(choices, theme, () => 5, () => {}, value => results.push(value));
+	panel.handleInput("\u001b[F");
+	assert.match(panel.render(80).join("\n"), /> Profile-29/);
+	panel.handleInput("v");
+	assert.match(panel.render(80).join("\n"), /usage unavailable/i);
+	panel.handleInput("\u001b[B"); // Scroll, never change the profile in details.
+	panel.handleInput("\u001b");
+	assert.match(panel.render(80).join("\n"), /> Profile-29/);
+	panel.handleInput("\u001b");
+	panel.handleInput("\r");
+	assert.deepEqual(results, [undefined]);
+});

package/extensions/osdy-pi/account-profile-selector.ts

@@ -0,0 +1,124 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Key, matchesKey, truncateToWidth, type Component } from "@earendil-works/pi-tui";
+import { renderCodexUsageDashboardContentLines } from "./codex-usage-ui.js";
+import type { ProfileCodexUsageResult } from "./profile-codex-usage.js";
+import type { SimpleTheme } from "./types.js";
+
+export interface AccountProfileChoice {
+	profile: string;
+	label: string;
+	usage: ProfileCodexUsageResult | undefined;
+}
+
+/** Snapshot-only explorer: completion is possible only from the profile list. */
+export class AccountProfileSelector implements Component {
+	private index = 0;
+	private details = false;
+	private scroll = 0;
+	private width = 80;
+	private closed = false;
+
+	private readonly choices: readonly AccountProfileChoice[];
+	private readonly theme: SimpleTheme;
+	private readonly height: () => number;
+	private readonly requestRender: () => void;
+	private readonly done: (profile: string | undefined) => void;
+
+	constructor(
+		choices: readonly AccountProfileChoice[],
+		theme: SimpleTheme,
+		height: () => number,
+		requestRender: () => void,
+		done: (profile: string | undefined) => void,
+	) {
+		this.choices = choices;
+		this.theme = theme;
+		this.height = height;
+		this.requestRender = requestRender;
+		this.done = done;
+	}
+
+	private capacity(): number { return Math.max(1, this.height() - 2); }
+
+	private detailLines(width: number): string[] {
+		const choice = this.choices[this.index];
+		const usage = choice?.usage;
+		if (!choice || usage?.status !== "ready" || usage.profile.toLowerCase() !== choice.profile.toLowerCase()) {
+			return [this.theme.fg("muted", "Profile usage unavailable. You can still switch from the list.")];
+		}
+		return [
+			this.theme.fg("muted", `Checked: ${new Date(usage.checkedAt).toLocaleString()} (local time)`),
+			this.theme.fg("muted", `Updated: ${new Date(usage.quotaSnapshot.fetchedAt).toLocaleString()} (local time)`),
+			...renderCodexUsageDashboardContentLines(this.theme, usage.quotaSnapshot,
+				{ profile: choice.profile, provider: "openai-codex" }, usage.checkedAt, width),
+		];
+	}
+
+	handleInput(data: string): void {
+		if (this.closed) return;
+		if (matchesKey(data, Key.escape) || (this.details && matchesKey(data, "b"))) {
+			if (this.details) { this.details = false; this.scroll = 0; }
+			else { this.closed = true; this.done(undefined); }
+		} else if (!this.details && matchesKey(data, Key.enter)) {
+			this.closed = true;
+			this.done(this.choices[this.index]?.profile);
+		} else if (!this.details && matchesKey(data, "v")) {
+			this.details = true;
+			this.scroll = 0;
+		} else {
+			const maximum = this.details ? Math.max(0, this.detailLines(this.width).length - this.capacity())
+				: Math.max(0, this.choices.length - 1);
+			let position = this.details ? this.scroll : this.index;
+			if (matchesKey(data, Key.up)) position--;
+			else if (matchesKey(data, Key.down)) position++;
+			else if (matchesKey(data, Key.pageUp)) position -= this.capacity();
+			else if (matchesKey(data, Key.pageDown)) position += this.capacity();
+			else if (matchesKey(data, Key.home)) position = 0;
+			else if (matchesKey(data, Key.end)) position = maximum;
+			else return; // Enter, refresh and reset controls never act in details.
+			position = Math.max(0, Math.min(maximum, position));
+			if (this.details) this.scroll = position;
+			else this.index = position;
+		}
+		this.requestRender();
+	}
+
+	render(width: number): string[] {
+		this.width = Math.max(1, Math.floor(width));
+		const capacity = this.capacity();
+		let content: string[];
+		let hint: string;
+		if (this.details) {
+			const lines = this.detailLines(this.width);
+			this.scroll = Math.min(this.scroll, Math.max(0, lines.length - capacity));
+			content = lines.slice(this.scroll, this.scroll + capacity);
+			hint = `esc/b back · ↑/↓ PgUp/PgDn Home/End scroll · ${this.scroll + 1}–${Math.min(lines.length, this.scroll + capacity)}/${lines.length}`;
+		} else {
+			const start = Math.max(0, this.index - capacity + 1);
+			content = this.choices.slice(start, start + capacity).map((choice, offset) =>
+				this.theme.fg(start + offset === this.index ? "accent" : "text",
+					`${start + offset === this.index ? ">" : " "} ${choice.label}`));
+			hint = "↑/↓ highlight · v usage details · enter switch · esc cancel";
+		}
+		return [
+			this.theme.fg("accent", this.details ? `Usage: ${this.choices[this.index]?.profile ?? "unknown"} (read-only)` : "Switch OpenAI account"),
+			...content,
+			this.theme.fg("muted", hint),
+		].slice(0, Math.max(1, this.height())).map(line => truncateToWidth(line, this.width, ""));
+	}
+
+	invalidate(): void {} // Output is recomputed with the current theme and viewport.
+}
+
+export function selectAccountProfile(
+	ui: Pick<ExtensionContext["ui"], "custom">,
+	choices: readonly AccountProfileChoice[],
+): Promise<string | undefined> {
+	return ui.custom<string | undefined>((tui, theme, _keys, done) => new AccountProfileSelector(
+		// Match the SDK's 100%-height, zero-margin overlay viewport on every resize.
+		choices, theme, () => Math.max(1, tui.terminal.rows), () => tui.requestRender(), done,
+	), {
+		overlay: true,
+		overlayOptions: { width: "100%", maxHeight: "100%", margin: 0, nonCapturing: false },
+	});
+}

package/extensions/osdy-pi/account-profiles.test.ts

@@ -1,9 +1,22 @@
 import assert from "node:assert/strict";
 import { mkdtemp, mkdir, realpath, symlink } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { registerHooks } from "node:module";
+import { fileURLToPath } from "node:url";
+import type { ProfileCodexUsageResult } from "./profile-codex-usage.js";
+import type { ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
+import { type Component, type TUI } from "@earendil-works/pi-tui";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import test from "node:test";
-import {
+registerHooks({ resolve(specifier, context, next) {
+	if (specifier.startsWith(".") && specifier.endsWith(".js") && context.parentURL?.endsWith(".ts")) {
+		const url = new URL(`${specifier.slice(0, -3)}.ts`, context.parentURL);
+		if (existsSync(fileURLToPath(url))) return { shortCircuit: true, url: url.href };
+	}
+	return next(specifier, context);
+} });
+const {
 	availableProfiles,
 	manageAccountProfile,
 	manageAccountProfiles,
@@ -14,7 +27,214 @@ import {
 	switchAccountInPlace,
 	// eslint-disable-next-line @typescript-eslint/ban-ts-comment
 	// @ts-ignore Node's native TypeScript runner resolves test-only TypeScript source imports.
-} from "./account-profiles.ts";
+} = await import("./account-profiles.ts");
+
+const down = "\u001b[B";
+const escape = "\u001b";
+
+function customHarness(exercise: (panel: Component) => void): ExtensionContext["ui"]["custom"] {
+	return (factory) => new Promise(resolve => {
+		let completed = false;
+		let renders = 0;
+		const panel = factory(
+			{ terminal: { rows: 30 }, requestRender: () => { renders++; } } as unknown as TUI,
+			{ fg: (_color: string, text: string) => text } as unknown as Theme,
+			{} as Parameters<typeof factory>[2],
+			value => { completed = true; resolve(value); },
+		);
+		assert(!(panel instanceof Promise));
+		exercise(panel);
+		assert(completed, "custom selector must finish through done");
+		assert(renders > 0, "input changes request a render");
+	});
+}
+
+void test("Switch previews every profile but lists only names and markers, with quota details through V", async () => {
+	const previous = process.env.OSDY_PI_PROFILE_NAME;
+	const profiles = ["Work", "work-alt", "expired", "unsupported", "failed"];
+	const requests: string[] = [];
+	const activated: string[] = [];
+	const switchEffects: string[] = [];
+	const usage = async (profile: string): Promise<ProfileCodexUsageResult> => {
+		requests.push(profile);
+		await Promise.resolve();
+		if (profile === "failed") throw new Error("private auth token");
+		if (profile === "expired" || profile === "unsupported")
+			return { status: "unavailable", profile, checkedAt: 0, reason: "stored-credentials-unavailable" };
+		return { status: "ready", profile, checkedAt: 0, quotaSnapshot: {
+			fetchedAt: 0, planType: undefined, credits: undefined, ordinaryUsageAllowed: undefined,
+			buckets: [{ id: "codex", label: undefined,
+				primary: { usedPercent: 25, windowMinutes: 300, resetsAt: 3600 },
+				secondary: { usedPercent: 60, windowMinutes: 10080, resetsAt: 86400 } }],
+		} };
+	};
+	try {
+		await manageAccountProfiles({ isIdle: () => true, ui: {
+			notify: () => undefined, input: () => Promise.resolve(undefined),
+			select: title => {
+				assert.equal(title, "OpenAI account manager", "profile picker must use custom UI");
+				return Promise.resolve("Switch");
+			},
+			custom: customHarness(panel => {
+				assert.deepEqual(requests, profiles);
+				const rows = panel.render(300);
+				assert.deepEqual(rows.slice(1, -1), [
+					"> Work (active) (default)", "  work-alt", "  expired", "  unsupported", "  failed",
+				]);
+				assert.doesNotMatch(rows.join("\n"), /%|resets|unavailable|private|token/);
+				panel.handleInput?.(down);
+				panel.handleInput?.("v");
+				assert.match(panel.render(100).join("\n"), /work-alt/);
+				const details = panel.render(100).join("\n");
+				assert.match(details, /Session/);
+				assert.match(details, /75%/);
+				assert.match(details, /Weekly/);
+				assert.match(details, /40%/);
+				assert.match(details, /reset/i);
+				panel.handleInput?.("\r");
+				panel.handleInput?.("r");
+				panel.handleInput?.("u");
+				assert.deepEqual(activated, []);
+				assert.deepEqual(switchEffects, []);
+				assert.equal(process.env.OSDY_PI_PROFILE_NAME, previous);
+				assert.deepEqual(requests, profiles);
+				panel.handleInput?.(escape);
+				assert.match(panel.render(300).join("\n"), /> work-alt/);
+				panel.handleInput?.("\r");
+			}),
+		} }, { profiles: () => Promise.resolve(profiles), activeProfile: "WORK",
+			run: () => Promise.resolve({ code: 0, stdout: "work", stderr: "" }),
+			previewUsage: usage, activate: profile => { activated.push(profile); return Promise.resolve(); },
+			refreshUsage: () => { switchEffects.push("refresh"); return Promise.resolve(); },
+			requestRender: () => { switchEffects.push("active render"); },
+		});
+		assert.deepEqual(activated, ["work-alt"]);
+		assert.deepEqual(switchEffects, ["active render", "refresh"]);
+	} finally {
+		if (previous === undefined) delete process.env.OSDY_PI_PROFILE_NAME;
+		else process.env.OSDY_PI_PROFILE_NAME = previous;
+	}
+});
+
+void test("Switch cancellation never activates; unavailable details stay safe and selectable", async () => {
+	const previous = process.env.OSDY_PI_PROFILE_NAME;
+	try {
+		for (const choice of ["cancel", "unavailable"] as const) {
+			let menus = 0;
+			const activated: string[] = [];
+			await manageAccountProfiles({ isIdle: () => true, ui: {
+				notify: () => undefined, input: () => Promise.resolve(undefined),
+				select: () => Promise.resolve(menus++ === 0 ? "Switch" : "Cancel"),
+				custom: customHarness(panel => {
+					assert.deepEqual(panel.render(100).slice(1, -1), ["> Work"]);
+					assert.doesNotMatch(panel.render(100).join("\n"), /%|resets|unavailable/);
+					panel.handleInput?.("v");
+					assert.match(panel.render(100).join("\n"), /Work/);
+					assert.match(panel.render(100).join("\n"), /usage unavailable/i);
+					panel.handleInput?.("\r");
+					assert.deepEqual(activated, []);
+					panel.handleInput?.("b");
+					assert.deepEqual(panel.render(100).slice(1, -1), ["> Work"]);
+					panel.handleInput?.(choice === "cancel" ? escape : "\r");
+				}),
+			} }, { profiles: () => Promise.resolve(["Work"]),
+				run: () => Promise.resolve({ code: 0, stdout: "No default account.", stderr: "" }),
+				previewUsage: profile => Promise.resolve({ status: "unavailable", profile, checkedAt: 0, reason: "remote-usage-unavailable" }),
+				activate: profile => { activated.push(profile); return Promise.resolve(); },
+				refreshUsage: () => { assert.equal(choice, "unavailable"); return Promise.resolve(); },
+			});
+			assert.deepEqual(activated, choice === "unavailable" ? ["Work"] : []);
+		}
+	} finally {
+		if (previous === undefined) delete process.env.OSDY_PI_PROFILE_NAME;
+		else process.env.OSDY_PI_PROFILE_NAME = previous;
+	}
+});
+
+void test("Switch bounds concurrent previews and safely handles empty, cancelled and mismatched results", async () => {
+	const profiles = ["one", "two", "three", "four", "five"];
+	const pending: (() => void)[] = [];
+	let active = 0;
+	let maximum = 0;
+	let queried = 0;
+	let menu = 0;
+	const work = manageAccountProfiles({ isIdle: () => true, ui: {
+		notify: () => undefined, input: () => Promise.resolve(undefined),
+		select: () => Promise.resolve(menu++ === 0 ? "Switch" : "Cancel"),
+		custom: customHarness(panel => {
+			assert.equal(queried, profiles.length);
+			assert.equal(active, 0);
+			const rows = panel.render(100);
+			assert.deepEqual(rows.slice(1, -1), profiles.map((profile, index) => `${index === 0 ? ">" : " "} ${profile}`));
+			assert.doesNotMatch(rows.join("\n"), /%|resets|unavailable/);
+			panel.handleInput?.(down);
+			panel.handleInput?.("v");
+			assert.match(panel.render(100).join("\n"), /usage unavailable/i);
+			assert.doesNotMatch(panel.render(100).join("\n"), /other/);
+			panel.handleInput?.(escape);
+			panel.handleInput?.(escape);
+		}),
+	} }, { profiles: () => Promise.resolve(profiles),
+		run: () => Promise.resolve({ code: 0, stdout: "No default account.", stderr: "" }),
+		activate: () => Promise.resolve(assert.fail("preview/cancel cannot activate")),
+		previewUsage: profile => new Promise<ProfileCodexUsageResult>(resolve => {
+			queried++;
+			maximum = Math.max(maximum, ++active);
+			pending.push(() => {
+				active--;
+				resolve(profile === "one" ? { status: "cancelled", profile, checkedAt: 0, reason: "cancelled" }
+					: { status: "ready", profile: profile === "two" ? "other" : profile, checkedAt: 0,
+						quotaSnapshot: { fetchedAt: 0, buckets: [], planType: undefined, credits: undefined, ordinaryUsageAllowed: undefined } });
+			});
+		}),
+	});
+	for (let i = 0; i < 8; i++) await Promise.resolve();
+	assert.equal(queried, 4);
+	while (pending.length) {
+		pending.shift()!();
+		for (let i = 0; i < 8; i++) await Promise.resolve();
+	}
+	await work;
+	assert.equal(maximum, 4);
+});
+
+void test("Switch details remain read-only while busy and confirmation retains idle guarding", async () => {
+	let menu = 0;
+	let waits = 0;
+	const notices: string[] = [];
+	await manageAccountProfiles({ isIdle: () => false,
+		waitForIdle: () => { waits++; return Promise.resolve(); }, ui: {
+			notify: message => notices.push(message), input: () => Promise.resolve(undefined),
+			select: () => Promise.resolve(menu++ === 0 ? "Switch" : "Cancel"),
+			custom: customHarness(panel => {
+				panel.handleInput?.("v");
+				panel.handleInput?.("\r");
+				assert.equal(waits, 0);
+				panel.handleInput?.(escape);
+				panel.handleInput?.("\r");
+			}),
+		} }, { profiles: () => Promise.resolve(["Work"]),
+			run: () => Promise.resolve({ code: 0, stdout: "No default account.", stderr: "" }),
+			activate: () => Promise.resolve(assert.fail("busy confirmation cannot activate")),
+			refreshUsage: () => Promise.resolve(assert.fail("busy confirmation cannot refresh")),
+		});
+	assert.equal(waits, 1);
+	assert.match(notices.join(" "), /require Pi to be idle/);
+});
+
+void test("non-terminal Switch is rejected before reading preview snapshots", async () => {
+	let menu = 0;
+	const notices: string[] = [];
+	await manageAccountProfiles({ mode: "rpc", isIdle: () => true, ui: {
+		notify: message => notices.push(message), input: () => Promise.resolve(undefined),
+		select: () => Promise.resolve(menu++ === 0 ? "Switch" : "Cancel"),
+		custom: () => Promise.resolve(assert.fail("RPC cannot open custom UI")),
+	} }, { profiles: () => Promise.resolve(["Work"]),
+		run: () => Promise.resolve({ code: 0, stdout: "No default account.", stderr: "" }),
+		previewUsage: () => Promise.resolve(assert.fail("RPC cannot query previews")),
+	});
+	assert.match(notices.join(" "), /terminal UI/);
+});
 
 void test("stored credential adapter narrows unknown data and conceals reader paths", async () => {
 	const credential = { profile: "Work", access: "synthetic", expires: 2_000_000_000_000 };

package/extensions/osdy-pi/account-profiles.ts

@@ -5,6 +5,9 @@ import type {
 	ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
 
+import type { ProfileCodexUsageResult } from "./profile-codex-usage.js";
+import { selectAccountProfile, type AccountProfileChoice } from "./account-profile-selector.js";
+
 const PROFILE_NAME = /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,62})$/;
 const RESERVED_PROFILE_NAMES = new Set(["default", "profiles", "auth.json"]);
 
@@ -20,10 +23,12 @@ export type AccountContext = Pick<ExtensionContext, "isIdle"> & {
 		ExtensionCommandContext["sessionManager"],
 		"getSessionFile"
 	>;
-	ui: Pick<ExtensionContext["ui"], "notify" | "select" | "input">;
+	mode?: ExtensionContext["mode"];
+	ui: Pick<ExtensionContext["ui"], "notify" | "select" | "input"> & Partial<Pick<ExtensionContext["ui"], "custom">>;
 };
 
 export interface AccountManagementDependencies {
+	previewUsage?: ((profile: string) => Promise<ProfileCodexUsageResult>) | undefined;
 	profiles(): Promise<string[]>;
 	run(args: string[]): Promise<{ code: number; stdout: string; stderr: string }>;
 	activeProfile?: string | undefined;
@@ -33,6 +38,7 @@ export interface AccountManagementDependencies {
 }
 
 export interface AccountProfilesCommandDependencies {
+	previewUsage?: AccountManagementDependencies["previewUsage"];
 	refreshUsage?: (() => Promise<void>) | undefined;
 	requestRender?: (() => void) | undefined;
 }
@@ -226,6 +232,31 @@ function markedProfiles(
 	);
 }
 
+/** Keep identity separate from display text and bound simultaneous stored-profile requests. */
+async function switchProfileChoices(
+	profiles: string[],
+	dependencies: AccountManagementDependencies,
+	defaultProfile: string | undefined,
+): Promise<AccountProfileChoice[]> {
+	const labels = markedProfiles(profiles, dependencies.activeProfile, defaultProfile);
+	const choices: AccountProfileChoice[] = profiles.map((profile, index) => ({ profile, label: labels[index]!, usage: undefined }));
+	let next = 0;
+	await Promise.all(Array.from({ length: Math.min(4, profiles.length) }, async () => {
+		while (next < profiles.length) {
+			const index = next++;
+			const profile = profiles[index]!;
+			try {
+				const result = await dependencies.previewUsage?.(profile);
+				if (result && sameProfile(result.profile, profile)) choices[index]!.usage = result;
+			} catch {
+				// Preview failure never blocks activation or exposes credential/network errors.
+			}
+		}
+		return undefined;
+	}));
+	return choices;
+}
+
 async function currentDefault(
 	dependencies: AccountManagementDependencies,
 ): Promise<DefaultAccountState> {
@@ -464,18 +495,13 @@ export async function manageAccountProfiles(
 			ctx.ui.notify("No account profiles are available.", "warning");
 			continue;
 		}
-		const target = await ctx.ui.select(
-			"Switch OpenAI account",
-			markedProfiles(
-				profiles,
-				dependencies.activeProfile,
-				defaultProfile ?? undefined,
-			),
-		);
-		if (target === undefined) continue;
-		const marker = target.indexOf(" (");
-		const profile = marker === -1 ? target : target.slice(0, marker);
-		if (!profiles.includes(profile)) continue;
+		if (!ctx.ui.custom || (ctx.mode !== undefined && ctx.mode !== "tui")) {
+			ctx.ui.notify("Account switching requires Pi's terminal UI.", "warning");
+			continue;
+		}
+		const choices = await switchProfileChoices(profiles, dependencies, defaultProfile);
+		const profile = await selectAccountProfile({ custom: ctx.ui.custom.bind(ctx.ui) }, choices);
+		if (profile === undefined || !profiles.includes(profile)) continue;
 		if (sameProfile(profile, dependencies.activeProfile)) {
 			ctx.ui.notify("That account is already active.", "info");
 			continue;
@@ -528,6 +554,7 @@ export function createAccountManagementDependencies(
 		profiles: async () => availableProfiles(await sharedAgentDir(process.env)),
 		run: runBundledCommand,
 		activeProfile: process.env.OSDY_PI_PROFILE_NAME,
+		previewUsage: options.previewUsage,
 		refreshUsage: options.refreshUsage,
 		requestRender: options.requestRender,
 		activate: async (profile) => {

package/extensions/osdy-pi/context-usage-ui.test.ts

@@ -56,7 +56,7 @@ void test("formats the selected single-line usage shape", () => {
 			percent: 60,
 			contextWindow: 272_000,
 		}),
-		"tok ↑0 ↓0 · $0.0000 · ctx <warning>[██████░░░░]</warning> 60%/272.0k",
+		"tok/s — · $0.0000 · ctx <warning>[██████░░░░]</warning> 60%/272.0k",
 	);
 });
 
@@ -76,14 +76,16 @@ void test("selects the full or compact usage line at the ANSI-aware width bounda
 		contextWindow: 272_000,
 	};
 	const full =
-		"tok ↑0 ↓0 · $0.0000 · ctx \u001B[33m[██████░░░░]\u001B[39m 60%/272.0k";
+		"tok/s — · $0.0000 · ctx \u001B[33m[██████░░░░]\u001B[39m 60%/272.0k";
 
-	assert.equal(visibleWidth(full), 49);
-	assert.equal(formatContextUsage(ansiTheme, usage, 49), full);
-	assert.equal(
-		formatContextUsage(ansiTheme, usage, 48),
-		"$0.0000 · ctx \u001B[33m[██████░░░░]\u001B[39m 60%",
-	);
+	const width = visibleWidth(full);
+	assert.equal(formatContextUsage(ansiTheme, usage, width), full);
+	const compact = formatContextUsage(ansiTheme, usage, width - 1);
+	assert.match(compact, /tok\/s —/);
+	assert.ok(visibleWidth(compact) <= width - 1);
+	for (let columns = 0; columns < width; columns++) {
+		assert.ok(visibleWidth(formatContextUsage(ansiTheme, usage, columns)) <= columns);
+	}
 });
 
 void test("formats a ten-cell green context bar at the inclusive 30% threshold", () => {
@@ -97,7 +99,7 @@ void test("formats a ten-cell green context bar at the inclusive 30% threshold",
 			percent: 30,
 			contextWindow: 272_000,
 		}),
-		"tok ↑0 ↓0 · $0.0000 · ctx <success>[███░░░░░░░]</success> 30%/272.0k",
+		"tok/s — · $0.0000 · ctx <success>[███░░░░░░░]</success> 30%/272.0k",
 	);
 });
 
@@ -112,7 +114,7 @@ void test("uses warning and error colors for higher rounded usage", () => {
 			percent: 30.5,
 			contextWindow: 200_000,
 		}),
-		"tok ↑1.5k ↓2.5m R12 W34 · $1.2000 · ctx <warning>[███░░░░░░░]</warning> 31%/200.0k",
+		"tok/s — R12 W34 · $1.2000 · ctx <warning>[███░░░░░░░]</warning> 31%/200.0k",
 	);
 	assert.equal(
 		formatContextUsage(theme, {
@@ -124,7 +126,7 @@ void test("uses warning and error colors for higher rounded usage", () => {
 			percent: 80.5,
 			contextWindow: 200_000,
 		}),
-		"tok ↑0 ↓0 · $1.2000 · ctx <error>[████████░░]</error> 81%/200.0k",
+		"tok/s — · $1.2000 · ctx <error>[████████░░]</error> 81%/200.0k",
 	);
 });
 
@@ -139,7 +141,7 @@ void test("clamps usage and safely represents missing context usage", () => {
 			percent: -10,
 			contextWindow: 200_000,
 		}),
-		"tok ↑0 ↓0 · $0.0000 · ctx <success>[░░░░░░░░░░]</success> 0%/200.0k",
+		"tok/s — · $0.0000 · ctx <success>[░░░░░░░░░░]</success> 0%/200.0k",
 	);
 	assert.equal(
 		formatContextUsage(theme, {
@@ -151,7 +153,7 @@ void test("clamps usage and safely represents missing context usage", () => {
 			percent: undefined,
 			contextWindow: 272_000,
 		}),
-		"tok ↑0 ↓0 · $0.0000 · ctx <success>[░░░░░░░░░░]</success> ?%/272.0k",
+		"tok/s — · $0.0000 · ctx <success>[░░░░░░░░░░]</success> ?%/272.0k",
 	);
 	assert.equal(
 		formatContextUsage(theme, {
@@ -163,6 +165,6 @@ void test("clamps usage and safely represents missing context usage", () => {
 			percent: undefined,
 			contextWindow: undefined,
 		}),
-		"tok ↑0 ↓0 · $0.0000 · ctx <success>[░░░░░░░░░░]</success> ?%/?",
+		"tok/s — · $0.0000 · ctx <success>[░░░░░░░░░░]</success> ?%/?",
 	);
 });

package/extensions/osdy-pi/context-usage-ui.ts

@@ -1,4 +1,5 @@
-import { visibleWidth } from "@earendil-works/pi-tui";
+import type { GenerationReading } from "./generation-meter.js";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { shortNumber } from "./format.js";
 
 export type ContextUsageDisplayData = {
@@ -7,6 +8,7 @@ export type ContextUsageDisplayData = {
 	cacheRead: number;
 	cacheWrite: number;
 	cost: number;
+	generation?: GenerationReading | undefined;
 	percent: number | undefined;
 	contextWindow: number | undefined;
 };
@@ -53,8 +55,17 @@ export function formatContextUsage(
 		usageTone(displayPercent),
 		`[${usageBar(displayPercent)}]`,
 	);
-	const full = `tok ↑${shortNumber(usage.input)} ↓${shortNumber(usage.output)}${cacheLabel} · $${usage.cost.toFixed(4)} · ctx ${bar} ${percentageLabel}%/${contextWindowLabel}`;
+	const generation = usage.generation;
+	const rate = generation?.kind === "complete" || generation?.kind === "streaming"
+		? generation.tokensPerSecond : null;
+	const speed = rate !== null && Number.isFinite(rate) && rate > 0
+		? `${generation?.kind === "streaming" ? "≈" : ""}${rate.toFixed(1)} tok/s`
+		: generation?.kind === "streaming" ? "tok/s …" : "tok/s —";
+	const full = `${speed}${cacheLabel} · $${usage.cost.toFixed(4)} · ctx ${bar} ${percentageLabel}%/${contextWindowLabel}`;
 	if (availableWidth === undefined || visibleWidth(full) <= availableWidth)
 		return full;
-	return `$${usage.cost.toFixed(4)} · ctx ${bar} ${percentageLabel}%`;
+	const compact = `${speed}${cacheLabel} · $${usage.cost.toFixed(4)} · ctx ${bar} ${percentageLabel}%`;
+	if (visibleWidth(compact) <= availableWidth) return compact;
+	const minimal = `${speed} · $${usage.cost.toFixed(4)} · ctx ${percentageLabel}%`;
+	return truncateToWidth(minimal, Math.max(0, availableWidth), "");
 }

package/extensions/osdy-pi/generation-meter.test.ts

@@ -0,0 +1,62 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+// @ts-expect-error Native test runner resolves TypeScript source imports.
+import { createGenerationMeter } from "./generation-meter.ts";
+
+void test("estimates characters, then uses finalized output over first-output-to-end time", () => {
+	let now = 0;
+	const meter = createGenerationMeter(() => now);
+	assert.deepEqual(meter.start(), { kind: "streaming", tokensPerSecond: null });
+	now = 5000; // Request latency is not generation time.
+	meter.delta("abcd");
+	now = 6000;
+	assert.deepEqual(meter.delta("abcdefghijkl"), { kind: "streaming", tokensPerSecond: 4 });
+	now = 7000;
+	assert.deepEqual(meter.finish(100, "stop"), { kind: "complete", tokensPerSecond: 50 });
+	now = 9000;
+	assert.deepEqual(meter.delta("ignored"), { kind: "complete", tokensPerSecond: 50 });
+	assert.deepEqual(meter.start(), { kind: "streaming", tokensPerSecond: null });
+	assert.deepEqual(meter.reset(), { kind: "idle" });
+	assert.deepEqual(meter.finish(100, "stop"), { kind: "idle" });
+});
+
+void test("empty output, short/invalid intervals, invalid usage and interrupted responses are unavailable", () => {
+	for (const duration of [0, 99, -1, Number.NaN, Infinity]) {
+		let now = 0;
+		const meter = createGenerationMeter(() => now);
+		meter.start();
+		meter.delta("abcd");
+		now = duration;
+		assert.equal(meter.delta("").kind, "streaming");
+		assert.deepEqual(meter.finish(20, "stop"), { kind: "unavailable" });
+	}
+	for (const output of [undefined, 0, -1, 1.5, Number.NaN, Infinity]) {
+		let now = 0;
+		const meter = createGenerationMeter(() => now);
+		meter.start(); meter.delta("abcd"); now = 1000;
+		assert.deepEqual(meter.finish(output, "stop"), { kind: "unavailable" });
+	}
+	for (const reason of ["aborted", "error", "pending", "deferred", undefined]) {
+		let now = 0;
+		const meter = createGenerationMeter(() => now);
+		meter.start(); meter.delta("abcd"); now = 1000;
+		assert.deepEqual(meter.finish(20, reason), { kind: "unavailable" });
+	}
+	const meter = createGenerationMeter(() => 1000);
+	meter.start(); meter.delta("");
+	assert.deepEqual(meter.finish(20, "toolUse"), { kind: "unavailable" });
+	meter.start();
+	assert.deepEqual(meter.interrupt(), { kind: "unavailable" });
+});
+
+void test("clock regression invalidates the response, and normal length/tool-use endings are valid", () => {
+	for (const reason of ["length", "toolUse"]) {
+		let now = 1000;
+		const meter = createGenerationMeter(() => now);
+		meter.start(); meter.delta("abcd"); now = 2000;
+		assert.deepEqual(meter.finish(20, reason), { kind: "complete", tokensPerSecond: 20 });
+		assert.deepEqual(meter.interrupt(), { kind: "complete", tokensPerSecond: 20 });
+		meter.start(); meter.delta("abcd"); now = 1900; meter.delta("efgh"); now = 3000;
+		assert.deepEqual(meter.finish(20, reason), { kind: "unavailable" });
+	}
+});

package/extensions/osdy-pi/generation-meter.ts

@@ -0,0 +1,69 @@
+export type GenerationReading =
+	| { kind: "idle" | "unavailable" }
+	| { kind: "streaming"; tokensPerSecond: number | null }
+	| { kind: "complete"; tokensPerSecond: number };
+
+export interface GenerationMeter {
+	start(): GenerationReading;
+	delta(text: string): GenerationReading;
+	finish(output: number | undefined, stopReason: string | undefined): GenerationReading;
+	interrupt(): GenerationReading;
+	reset(): GenerationReading;
+}
+
+/** Volatile, per-message measurement. No partial-message references or timers.
+ * Live UTF-16 characters / 4 is a heuristic, never tokenizer/server telemetry.
+ */
+export function createGenerationMeter(now: () => number = () => performance.now()): GenerationMeter {
+	let reading: GenerationReading = { kind: "idle" };
+	let firstOutput: number | undefined;
+	let lastTime: number | undefined;
+	let invalidClock = false;
+	let characters = 0;
+	const sample = (): number => {
+		const time = now();
+		if (!Number.isFinite(time) || (lastTime !== undefined && time < lastTime)) invalidClock = true;
+		lastTime = time;
+		return time;
+	};
+	const rate = (tokens: number, time: number): number | null => {
+		const elapsed = firstOutput === undefined ? 0 : time - firstOutput;
+		// Sub-100ms observations are too short to present a useful rate.
+		if (invalidClock || elapsed < 100 || !Number.isFinite(elapsed)) return null;
+		const value = tokens / (elapsed / 1000);
+		return Number.isFinite(value) && value > 0 ? value : null;
+	};
+	const reset = (): GenerationReading => {
+		firstOutput = undefined;
+		lastTime = undefined;
+		invalidClock = false;
+		characters = 0;
+		return reading = { kind: "idle" };
+	};
+	return {
+		reset,
+		start() {
+			reset();
+			return reading = { kind: "streaming", tokensPerSecond: null };
+		},
+		delta(text) {
+			if (reading.kind !== "streaming" || !text) return reading;
+			const time = sample();
+			firstOutput ??= time;
+			characters += text.length;
+			return reading = { kind: "streaming", tokensPerSecond: rate(characters / 4, time) };
+		},
+		finish(output, stopReason) {
+			if (reading.kind !== "streaming") return reading;
+			const time = sample();
+			const completed = stopReason === "stop" || stopReason === "length" || stopReason === "toolUse";
+			const value = completed && output !== undefined && Number.isSafeInteger(output) && output > 0
+				? rate(output, time) : null;
+			return reading = value === null ? { kind: "unavailable" } : { kind: "complete", tokensPerSecond: value };
+		},
+		interrupt() {
+			if (reading.kind === "streaming") reading = { kind: "unavailable" };
+			return reading;
+		},
+	};
+}

package/extensions/osdy-pi/runtime.test.ts

@@ -50,7 +50,7 @@ registerHooks({
 type ShortcutRegistration = Parameters<ExtensionAPI["registerShortcut"]>[1];
 
 async function resetRuntimeFixture(root = mkdtempSync(join(tmpdir(), "osdy-reset-ui-runtime-")),
-	options: Pick<NonNullable<Parameters<typeof registerOsdyPi>[1]>, "fetchCodexUsage"> = {}) {
+	options: Pick<NonNullable<Parameters<typeof registerOsdyPi>[1]>, "fetchCodexUsage" | "generationClock"> = {}) {
 	const { registerOsdyPi: registerResetRuntime } = await import("./runtime.js");
 	const previousDir = process.env.PI_CODING_AGENT_DIR;
 	const previousFetch = globalThis.fetch;
@@ -69,6 +69,10 @@ async function resetRuntimeFixture(root = mkdtempSync(join(tmpdir(), "osdy-reset
 	let beforeAuth: () => Promise<void> = () => Promise.resolve();
 	let onRender: (view: string) => void = () => {};
 	let panel: Component | undefined;
+	let footer: Component | undefined;
+	let renders = 0;
+	let mounts = 0;
+	const tui = { terminal: { columns: 120, rows: 40 }, requestRender: () => { renders++; }, hasOverlay: () => false } as unknown as TUI;
 	const shortcuts = new Map<string, ShortcutRegistration>();
 	const views: string[] = [];
 	let quotaReads = 0;
@@ -99,15 +103,18 @@ async function resetRuntimeFixture(root = mkdtempSync(join(tmpdir(), "osdy-reset
 		on: (name: string, handler: (event: unknown, ctx: ExtensionContext) => Promise<void> | void) => {
 			const list = events.get(name) ?? []; list.push(handler); events.set(name, list);
 		}, registerFlag: () => {}, registerMessageRenderer: () => {}, registerEntryRenderer: () => {},
-		events: { on: () => () => {} }, exec: () => { throw new Error("external execution forbidden"); },
+		getThinkingLevel: () => "off", events: { on: () => () => {} }, exec: () => { throw new Error("external execution forbidden"); },
 	} as unknown as ExtensionAPI;
 	const ctx = { cwd: root, hasUI: true, mode: "tui", model: { provider: "openai-codex", id: "synthetic" }, isIdle: () => true,
-		sessionManager: { getSessionId: () => session }, modelRegistry: { getProviderAuth: async (provider: string) => {
+		getContextUsage: () => undefined,
+		sessionManager: { getSessionId: () => session, getEntries: () => [] }, modelRegistry: { getProviderAuth: async (provider: string) => {
 			assert.equal(provider, "openai-codex");
 			const token = `header.${Buffer.from(JSON.stringify({ "https://api.openai.com/auth": { chatgpt_account_id: account } })).toString("base64url")}.signature`;
 			await beforeAuth();
 			return { auth: { apiKey: token } };
-		} }, ui: { getEditorComponent: () => undefined, setEditorComponent: () => {}, setHeader: () => {}, setFooter: () => {},
+		} }, ui: { getEditorComponent: () => undefined, setEditorComponent: () => { mounts++; },
+			setHeader: (factory?: (tui: TUI, theme: Theme) => Component & { dispose?(): void }) => { factory?.(tui, ctx.ui.theme).dispose?.(); },
+			setFooter: (factory?: (tui: TUI, theme: Theme, data: unknown) => Component) => { footer = factory?.(tui, ctx.ui.theme, {}); },
 			setWidget: () => {}, setWorkingVisible: () => {}, notify: (text: string) => { notices.push(text); },
 			theme: { name: "dark", appearance: "dark", fg: (_color: string, text: string) => text }, getAllThemes: () => [], setTheme: () => ({ success: false }),
 			select: (title: string, options: string[]) => {
@@ -145,7 +152,11 @@ async function resetRuntimeFixture(root = mkdtempSync(join(tmpdir(), "osdy-reset
 			}) } });
 		await lifecycle("session_start");
 	} catch (error) { globalThis.fetch = previousFetch; if (previousDir === undefined) delete process.env.PI_CODING_AGENT_DIR; else process.env.PI_CODING_AGENT_DIR = previousDir; throw error; }
-	return { root, posts, dialogs, notices, views, expiry, quotaReads: () => quotaReads, overlays: () => overlays,
+	return { root, posts, dialogs, notices, views, expiry,
+		emit: async (name: string, event: unknown) => { for (const handler of events.get(name) ?? []) await handler(event, ctx); },
+		enable: () => commands.get("osdy-pi")!.handler("enable", ctx),
+		footer: () => footer?.render(120).join("\n") ?? "", renders: () => renders, mounts: () => mounts,
+		quotaReads: () => quotaReads, overlays: () => overlays,
 		open: (surface = "usage") => { nextAction = true; return commands.get(surface)!.handler("", ctx); },
 		view: (shortcut = false) => { nextAction = false; return shortcut
 			? shortcuts.get("ctrl+alt+u")!.handler(ctx) : commands.get("usage")!.handler("", ctx); },
@@ -163,6 +174,60 @@ async function resetRuntimeFixture(root = mkdtempSync(join(tmpdir(), "osdy-reset
 	};
 }
 
+void test("generation lifecycle uses delta-only estimates and final event usage without remounting", async () => {
+	let now = 0;
+	const f = await resetRuntimeFixture(undefined, { generationClock: () => now });
+	const message = { role: "assistant", usage: { output: 80, reasoning: 40 }, stopReason: "stop" };
+	const delta = (type: string, text: string) => f.emit("message_update", {
+		message, assistantMessageEvent: { type, delta: text, partial: message },
+	});
+	try {
+		await f.enable();
+		const mounts = f.mounts();
+		await f.emit("message_start", { message });
+		assert.match(f.footer(), /tok\/s …/);
+		now = 5000; await delta("thinking_delta", "abcd");
+		now = 6000; await delta("text_delta", "abcd");
+		await delta("toolcall_delta", "abcd");
+		assert.match(f.footer(), /≈3\.0 tok\/s/);
+		await delta("text_end", "not counted");
+		assert.match(f.footer(), /≈3\.0 tok\/s/);
+		now = 7000; await f.emit("message_end", { message });
+		assert.match(f.footer(), /40\.0 tok\/s/);
+		assert.doesNotMatch(f.footer(), /≈|tok ↑/);
+		await f.emit("message_start", { message: { role: "toolResult" } });
+		assert.match(f.footer(), /40\.0 tok\/s/);
+		await f.emit("agent_end", {});
+		assert.match(f.footer(), /40\.0 tok\/s/);
+		assert.equal(f.mounts(), mounts);
+		assert.ok(f.renders() > 0);
+		await f.emit("message_start", { message });
+		await delta("text_delta", "abcd"); now += 1000;
+		await f.emit("message_end", { message: { ...message, stopReason: "aborted" } });
+		assert.match(f.footer(), /tok\/s —/);
+		await f.emit("message_start", { message });
+		await delta("text_delta", "abcd"); now += 1000;
+		await delta("error", "ignored");
+		assert.match(f.footer(), /tok\/s —/);
+		await f.emit("message_end", { message });
+		assert.match(f.footer(), /tok\/s —/);
+		await f.emit("message_start", { message });
+		await delta("text_delta", "abcd"); now += 1000;
+		await f.emit("agent_end", {});
+		assert.match(f.footer(), /tok\/s —/);
+		await f.emit("message_start", { message });
+		await delta("text_delta", "abcd"); now += 1000;
+		await f.replace(); await f.enable();
+		await f.emit("message_end", { message });
+		assert.match(f.footer(), /tok\/s —/);
+		await f.emit("message_start", { message });
+		await delta("text_delta", "abcd"); now += 1000;
+		await f.shutdown();
+		await f.emit("message_end", { message });
+		assert.match(f.footer(), /tok\/s —/);
+	} finally { await f.close(); }
+});
+
 void test("registered active surfaces select and Cancel-first confirm before exactly one mocked POST", async () => {
 	for (const surface of ["usage", "osdyConfig"]) {
 		const f = await resetRuntimeFixture();

package/extensions/osdy-pi/runtime.ts

@@ -5,6 +5,7 @@ import type {
 	ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
 import { homedir } from "node:os";
+import { createGenerationMeter, type GenerationReading } from "./generation-meter.js";
 import { createCodexUsageRefresh, type CodexUsageRefreshClock } from "./codex-usage-refresh.js";
 import { createControlCenterTodo } from "./control-center-todo.js";
 import { createControlCenterAgents } from "./control-center-agents.js";
@@ -26,7 +27,8 @@ import { createAudioPlaybackAdapter } from "./audio-playback.js";
 import { subscribeQuestionPromptAudioNotification } from "./plugin-events.js";
 import { createAudioSoundSettingsStore } from "./audio-sound-settings.js";
 import { createEditorSettingsStore } from "./editor-settings.js";
-import { registerAccountProfilesCommand } from "./account-profiles.js";
+import { registerAccountProfilesCommand, readStoredProfileCodexCredential, sharedAgentDir } from "./account-profiles.js";
+import { requestProfileCodexUsage } from "./profile-codex-usage.js";
 import {
 	applyOsdyPi,
 	clearGentleShellChangesWidget,
@@ -1121,6 +1123,7 @@ export async function registerOsdyPi(
 		/** Tests inject a synthetic agent-data root; production uses the SDK root. */
 		agentDir?: () => string;
 		codexUsageClock?: CodexUsageRefreshClock;
+		generationClock?: () => number;
 		fetchCodexUsage?: CodexUsageFetcher;
 		accountFactory?: typeof bindControlCenterAccount;
 		editorSettingsStore?: ReturnType<typeof createEditorSettingsStore>;
@@ -1139,6 +1142,12 @@ export async function registerOsdyPi(
 		workingTreeEnabled: true,
 		workingTreePlacement: "aboveEditor",
 	};
+	const generationMeter = createGenerationMeter(dependencies.generationClock);
+	state.generation = generationMeter.reset();
+	const presentGeneration = (reading: GenerationReading): void => {
+		state.generation = reading;
+		state.tui?.requestRender();
+	};
 	const workingState: WorkingWidgetState = {
 		active: false,
 		activity: "thinking",
@@ -1269,6 +1278,9 @@ export async function registerOsdyPi(
 		}
 	}, dependencies.codexUsageClock);
 	registerAccountProfilesCommand(pi, {
+		previewUsage: profile => requestProfileCodexUsage(profile, {
+			readCredentials: async name => readStoredProfileCodexCredential(await sharedAgentDir(process.env), name),
+		}),
 		requestRender: () => {
 			state.tui?.requestRender();
 		},
@@ -1302,11 +1314,29 @@ export async function registerOsdyPi(
 		audioRouter,
 	);
 
+	pi.on("message_start", (event) => {
+		if (sessionContext && event.message.role === "assistant") presentGeneration(generationMeter.start());
+	});
+	pi.on("message_update", (event) => {
+		if (!sessionContext || event.message.role !== "assistant") return;
+		const update = event.assistantMessageEvent;
+		if (update.type === "text_delta" || update.type === "thinking_delta" || update.type === "toolcall_delta") {
+			// Count only deltas, not mutable partial snapshots or authoritative block ends.
+			presentGeneration(generationMeter.delta(update.delta));
+		} else if (update.type === "error") presentGeneration(generationMeter.interrupt());
+	});
+	pi.on("message_end", (event) => {
+		if (sessionContext && event.message.role === "assistant") {
+			// message_end precedes persistence. Output already includes reasoning tokens.
+			presentGeneration(generationMeter.finish(event.message.usage?.output, event.message.stopReason));
+		}
+	});
 	pi.on("agent_start", () => {
 		controller.onAgentStart();
 		audioRouter.onAgentStart();
 	});
 	pi.on("agent_end", (_event, ctx) => {
+		presentGeneration(generationMeter.interrupt());
 		controller.onAgentEnd();
 		audioRouter.onAgentEnd(ctx);
 		if (state.enabled) clearGentleShellChangesWidget(ctx);
@@ -1342,6 +1372,7 @@ export async function registerOsdyPi(
 	});
 	pi.on("session_shutdown", () => {
 		usageSettingsReady = false;
+		presentGeneration(generationMeter.reset());
 		idleUsageRefresh.stop();
 		runtimeGeneration++;
 		for (const abort of resetAborts) abort.abort();
@@ -1359,6 +1390,7 @@ export async function registerOsdyPi(
 		sessionContext = undefined;
 	});
 	pi.on("session_start", async (_event, ctx) => {
+		presentGeneration(generationMeter.reset());
 		controller.onShutdown();
 		idleUsageRefresh.stop();
 		codexUsageAbort?.abort();

package/extensions/osdy-pi/types.ts

@@ -6,6 +6,7 @@ type EditorFactory = Exclude<
 	undefined
 >;
 import type { CodexUsageSnapshot } from "./codex-usage.js";
+import type { GenerationReading } from "./generation-meter.js";
 
 export type AnimationMode = "off" | "intro" | "continuous";
 
@@ -58,6 +59,8 @@ export type CodexUsageState =
 
 export type OsdyState = {
 	codexUsage: CodexUsageState;
+	/** Volatile response reading; never persisted as usage or settings. */
+	generation?: GenerationReading;
 	enabled: boolean;
 	/** Actual mounted editor, including while a desired change is deferred. */
 	editorEffective: boolean;

package/extensions/osdy-pi/ui.test.ts

@@ -1,4 +1,8 @@
 import assert from "node:assert/strict";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { KeybindingsManager } from "../../node_modules/@earendil-works/pi-coding-agent/dist/core/keybindings.js";
+import type { EditorTheme, TUI } from "@earendil-works/pi-tui";
+import type { OsdyState } from "./types.js";
 import { createHash } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
 import { registerHooks } from "node:module";
@@ -394,6 +398,47 @@ void test("places a managed profile beside the model in simple mode and preserve
 	);
 });
 
+void test("one real editor instance and native footer read live/final speed with ANSI-safe resizing", () => {
+	const color = (text: string) => `\u001b[33m${text}\u001b[39m`;
+	const theme = { fg: (_name: string, text: string) => color(text), bold: (text: string) => text };
+	const state: OsdyState = {
+		codexUsage: { kind: "idle" }, enabled: true, editorEffective: true, editorMode: "extended",
+		fallbackEditorFactory: undefined, headerVariant: "osdy-theme", mascot: "current", smallMode: false,
+		tui: undefined, workingTreeEnabled: false, workingTreePlacement: "aboveEditor",
+		generation: { kind: "streaming", tokensPerSecond: 42.3 },
+	};
+	const ctx = { cwd: "/synthetic", ui: { theme }, model: { provider: "test", id: "test", contextWindow: 200000 },
+		getContextUsage: () => ({ percent: 60 }), sessionManager: { getEntries: () => [] },
+	} as unknown as ExtensionContext;
+	const pi = { getThinkingLevel: () => "off" } as ExtensionAPI;
+	const tui = { terminal: { rows: 40, columns: 120 }, requestRender: () => {} } as unknown as TUI;
+	const editorTheme: EditorTheme = { borderColor: color, selectList: {
+		selectedPrefix: color, selectedText: color, description: color, scrollInfo: color, noMatch: color,
+	} };
+	const editor = ui.createEditorComponent(pi, ctx, state)(tui, editorTheme, new KeybindingsManager());
+	for (const reading of [
+		{ kind: "streaming", tokensPerSecond: 42.3 }, { kind: "complete", tokensPerSecond: 50 },
+		{ kind: "streaming", tokensPerSecond: null }, { kind: "unavailable" },
+	] as const) {
+		state.generation = reading;
+		const expected = reading.kind === "complete" ? "50.0 tok/s" : reading.kind === "unavailable" ? "tok/s —"
+			: reading.tokensPerSecond === null ? "tok/s …" : "≈42.3 tok/s";
+		assert.ok(editor.render(120).join("\n").includes(expected));
+		for (const width of [4, 15, 30, 48, 80, 120]) {
+			assert.ok(editor.render(width).every(line => visibleWidth(line) <= width));
+		}
+		state.editorEffective = false;
+		const footer = ui.createFooterComponent(pi, ctx, state, {
+			getGitBranch: () => null, getExtensionStatuses: () => new Map(),
+			getAvailableProviderCount: () => 1, onBranchChange: () => () => {},
+		}, theme);
+		assert.ok(footer.render(120).join("\n").includes(expected));
+		assert.doesNotMatch(footer.render(120).join("\n"), /tok ↑/);
+		assert.ok(footer.render(30).every(line => visibleWidth(line) <= 30));
+		state.editorEffective = true;
+	}
+});
+
 void test("wires themed Codex quota bars below both native footer and extended editor", () => {
 	const source = readFileSync(new URL("./ui.ts", import.meta.url), "utf8");
 	assert.match(source, /renderCompactCodexQuotaBars/);

package/extensions/osdy-pi/ui.ts

@@ -343,7 +343,7 @@ class OsdyFooter implements Component {
 			? renderCompactCodexQuotaBars(this.theme, codexSnapshot, width)
 			: [];
 		const usageLine = truncateToWidth(
-			formatContextUsage(this.theme, contextUsageData(this.ctx), width),
+			formatContextUsage(this.theme, { ...contextUsageData(this.ctx), generation: this.state.generation }, width),
 			width,
 			ellipsis,
 		);
@@ -490,7 +490,7 @@ export function createEditorComponent(
 			const topRight = ctx.ui.theme.fg("muted", layout.topRight);
 			const bottomLeft = formatContextUsage(
 				ctx.ui.theme,
-				contextUsageData(ctx),
+				{ ...contextUsageData(ctx), generation: state.generation },
 				innerWidth,
 			);
 			lines[0] = `${borderColor("╭")}${fitBorder(topLeft, topRight, editorWidth - 2, borderColor)}${borderColor("╮")}`;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "osdy-pi",
-	"version": "1.11.13",
+	"version": "1.11.15",
 	"description": "Osdy Pi package: themes, header, and custom editor for Pi.",
 	"license": "MIT",
 	"type": "module",
@@ -83,7 +83,7 @@
 		"typescript": "^5.9.3",
 		"typescript-eslint": "^8.46.3"
 	},
-	"releaseSource": "89f3886287c5062fa45501a1a1869d25e7d46dac",
+	"releaseSource": "a884185d5c9c03e3695f5cecd4c370259dee1e48",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/OsdyOrtiz/Osdy-Pi.git"