osdy-pi 1.11.13 → 1.11.14

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:

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/runtime.ts

@@ -26,7 +26,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,
@@ -1269,6 +1270,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();
 		},

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "osdy-pi",
-	"version": "1.11.13",
+	"version": "1.11.14",
 	"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": "375d9ec96ba08e538070ee492c60b0ce45bb0bc4",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/OsdyOrtiz/Osdy-Pi.git"