gentle-pi 2.3.0 → 2.5.0

package/tests/shell-prompt.test.ts

@@ -0,0 +1,118 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { stripAnsi } from "../lib/terminal-theme.ts";
+import {
+	framePromptLines,
+	panelPainter,
+	PROMPT_STATE,
+	petalGlyph,
+	petalTone,
+	withPromptHint,
+	type PromptFrameOptions,
+} from "../lib/shell-prompt.ts";
+
+// The Gentle Shell prompt wraps pi's editor output (a top rule, padded content
+// lines, a bottom rule) in a rounded frame with a petal that shows the agent
+// state. Framing is pure: it takes the editor's lines and returns new ones.
+
+const CURSOR = "\x1b[7m \x1b[0m";
+
+function options(overrides: Partial<PromptFrameOptions> = {}): PromptFrameOptions {
+	return {
+		state: PROMPT_STATE.IDLE,
+		tick: 0,
+		borderColor: (text) => text,
+		fg: (color, text) => `<${color}>${text}</${color}>`,
+		...overrides,
+	};
+}
+
+test("framePromptLines sets the petal in bold when the theme offers it", () => {
+	const lines = framePromptLines(editorLines(40), 40, options({ bold: (text) => `*${text}*` }));
+	assert.match(lines[0], /<borderAccent>\*✿\*<\/borderAccent>/);
+});
+
+function editorLines(width: number, content: string[] = [` ${CURSOR}`]): string[] {
+	const inner = width - 2;
+	return ["─".repeat(inner), ...content.map((line) => line + " ".repeat(inner - visibleWidth(line))), "─".repeat(inner)];
+}
+
+test("framePromptLines draws rounded corners, side rules, and keeps every line at width", () => {
+	const width = 40;
+	const lines = framePromptLines(editorLines(width), width, options({ fg: (_c, t) => t }));
+	assert.equal(lines.length, 3);
+	for (const line of lines) assert.equal(visibleWidth(line), width, `line "${stripAnsi(line)}" is not ${width} wide`);
+	assert.match(stripAnsi(lines[0]), /^╭─ ✿ ─+╮$/);
+	assert.match(stripAnsi(lines[1]), /^│ .* │$/);
+	assert.match(stripAnsi(lines[2]), /^╰─+╯$/);
+});
+
+test("framePromptLines paints the frame with the editor border color and the petal with the state tone", () => {
+	const lines = framePromptLines(editorLines(40), 40, options({ borderColor: (text) => `[b]${text}[/b]`, bold: (text) => `*${text}*` }));
+	assert.match(lines[0], /^\[b\]╭─ \[\/b\]<borderAccent>\*✿\*<\/borderAccent>\[b\] ─+╮\[\/b\]$/);
+	assert.match(lines[1], /^\[b\]│\[\/b\].*\[b\]│\[\/b\]$/);
+	assert.match(lines[2], /^\[b\]╰─+╯\[\/b\]$/);
+});
+
+test("petalTone rests bright, walks the rose ramp while working, and turns to warning when queued", () => {
+	assert.equal(petalTone(PROMPT_STATE.IDLE, 2), "borderAccent");
+	assert.deepEqual([0, 1, 2, 3, 4].map((tick) => petalTone(PROMPT_STATE.WORKING, tick)), ["borderAccent", "accent", "thinkingHigh", "mdQuoteBorder", "borderAccent"]);
+	assert.equal(petalTone(PROMPT_STATE.QUEUED, 1), "warning");
+});
+
+test("petalGlyph spins through the flowers while working and rests otherwise", () => {
+	assert.equal(petalGlyph(PROMPT_STATE.IDLE, 3), "✿");
+	assert.deepEqual([0, 1, 2, 3, 4].map((tick) => petalGlyph(PROMPT_STATE.WORKING, tick)), ["✿", "❀", "❁", "✾", "✿"]);
+	assert.equal(petalGlyph(PROMPT_STATE.QUEUED, 1), "❀");
+});
+
+test("framePromptLines spins the petal and labels the working and queued states", () => {
+	const plain = (_color: string, text: string) => text;
+	const working = framePromptLines(editorLines(40), 40, options({ state: PROMPT_STATE.WORKING, tick: 1 }));
+	assert.match(working[0], /<accent>❀<\/accent>/);
+	assert.match(working[0], /<muted>working<\/muted>/);
+	const workingPlain = framePromptLines(editorLines(40), 40, options({ state: PROMPT_STATE.WORKING, tick: 1, fg: plain }));
+	assert.match(stripAnsi(workingPlain[0]), /^╭─ ❀ working ─+╮$/);
+	assert.equal(visibleWidth(workingPlain[0]), 40);
+
+	const queued = framePromptLines(editorLines(40), 40, options({ state: PROMPT_STATE.QUEUED }));
+	assert.match(queued[0], /<warning>✿<\/warning>/);
+	assert.match(queued[0], /<muted>queued<\/muted>/);
+	const queuedPlain = framePromptLines(editorLines(40), 40, options({ state: PROMPT_STATE.QUEUED, fg: plain }));
+	assert.match(stripAnsi(queuedPlain[0]), /^╭─ ✿ queued ─+╮$/);
+	assert.equal(visibleWidth(queuedPlain[0]), 40);
+});
+
+test("framePromptLines keeps the editor scroll indicators inside the frame", () => {
+	const width = 40;
+	const inner = width - 2;
+	const top = `─── ↑ 2 more ${"─".repeat(inner - 13)}`;
+	const bottom = `─── ↓ 3 more ${"─".repeat(inner - 13)}`;
+	const lines = framePromptLines([top, ` x${" ".repeat(inner - 2)}`, bottom], width, options({ fg: (_c, t) => t }));
+	assert.match(stripAnsi(lines[0]), /^╭─ ✿ ↑ 2 more ─+╮$/);
+	assert.match(stripAnsi(lines[2]), /^╰─ ↓ 3 more ─+╯$/);
+	for (const line of lines) assert.equal(visibleWidth(line), width);
+});
+
+test("withPromptHint places a dim hint after the cursor on an empty editor line", () => {
+	const inner = 38;
+	const line = ` ${CURSOR}${" ".repeat(inner - 2)}`;
+	const hinted = withPromptHint(line, "type, or / for commands", (color, text) => `<${color}>${text}</${color}>`);
+	assert.match(hinted, /\x1b\[7m \x1b\[0m <dim>type, or \/ for commands<\/dim> +$/);
+	const hintedPlain = withPromptHint(line, "type, or / for commands", (_c, t) => t);
+	assert.equal(visibleWidth(hintedPlain), inner);
+});
+
+test("withPromptHint leaves the line alone when the hint does not fit", () => {
+	const line = ` ${CURSOR}${" ".repeat(6)}`;
+	const hinted = withPromptHint(line, "type, or / for commands", (_c, t) => t);
+	assert.equal(hinted, line);
+});
+
+test("panelPainter keeps the background running after pi's cursor reset", () => {
+	const paint = panelPainter("<bg>");
+	assert.equal(paint("a\x1b[0mb"), "<bg>a\x1b[0m<bg>b\x1b[49m");
+	const lines = framePromptLines(editorLines(40), 40, options({ fg: (_c, t) => t, paint }));
+	assert.ok(lines.every((line) => line.startsWith("<bg>") && line.endsWith("\x1b[49m")));
+});

package/tests/shell-todo.test.ts

@@ -0,0 +1,170 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import {
+	applyTodo,
+	emptyTodo,
+	renderTodoCard,
+	replayTodo,
+	staleTurns,
+	TODO_STATUS,
+	todoPromptBlock,
+	todoSummary,
+	type TodoState,
+} from "../lib/shell-todo.ts";
+import { stripAnsi } from "../lib/terminal-theme.ts";
+
+// Gentle Todo: a task list the model rewrites as it works. The reducer is
+// pure, the state replays from the session branch, and staleness is derived
+// from how many turns passed since the last write while tasks stay open.
+
+const plainTheme = {
+	fg(_color: string, text: string) {
+		return text;
+	},
+	strikethrough(text: string) {
+		return `~${text}~`;
+	},
+};
+
+function seeded(): TodoState {
+	return applyTodo(
+		emptyTodo(),
+		{ action: "write", tasks: [{ title: "Add quiet tool rendering", status: "done" }, { title: "Fix quiet tools conflict", status: "in_progress", note: "fixing conflict" }, { title: "Show git bash tails" }] },
+		3,
+	).state;
+}
+
+test("applyTodo write replaces the list, assigns ids, defaults to pending, and records the turn", () => {
+	const { state, text, error } = applyTodo(emptyTodo(), { action: "write", tasks: [{ title: "First" }, { title: "Second", status: "in_progress", note: "working" }] }, 2);
+	assert.equal(error, undefined);
+	assert.deepEqual(state.tasks, [
+		{ id: 1, title: "First", status: TODO_STATUS.PENDING },
+		{ id: 2, title: "Second", status: TODO_STATUS.IN_PROGRESS, note: "working" },
+	]);
+	assert.equal(state.nextId, 3);
+	assert.equal(state.updatedTurn, 2);
+	assert.match(text, /2 tasks · 0 done · 1 in progress/);
+});
+
+test("applyTodo write keeps ids the model passes back and drops the rest", () => {
+	const first = applyTodo(emptyTodo(), { action: "write", tasks: [{ title: "A" }, { title: "B" }] }, 1).state;
+	const second = applyTodo(first, { action: "write", tasks: [{ id: 2, title: "B", status: "done" }, { title: "C" }] }, 2).state;
+	assert.deepEqual(second.tasks.map((task) => `${task.id}:${task.title}:${task.status}`), ["2:B:done", "3:C:pending"]);
+});
+
+test("applyTodo add, update, and clear mutate one task at a time and validate ids", () => {
+	let state = applyTodo(emptyTodo(), { action: "add", title: "Write tests" }, 1).state;
+	assert.equal(state.tasks[0].id, 1);
+	const updated = applyTodo(state, { action: "update", id: 1, status: "in_progress", note: "writing tests" }, 2);
+	assert.equal(updated.error, undefined);
+	assert.equal(updated.state.tasks[0].status, TODO_STATUS.IN_PROGRESS);
+	assert.equal(updated.state.tasks[0].note, "writing tests");
+	assert.match(updated.text, /#1 Write tests → in_progress/);
+	const missing = applyTodo(updated.state, { action: "update", id: 9, status: "done" }, 2);
+	assert.match(missing.error ?? "", /no task #9/);
+	assert.strictEqual(missing.state, updated.state);
+	const noField = applyTodo(updated.state, { action: "update", id: 1 }, 2);
+	assert.match(noField.error ?? "", /nothing to update/);
+	state = applyTodo(updated.state, { action: "clear" }, 3).state;
+	assert.deepEqual(state.tasks, []);
+	assert.equal(state.nextId, 1);
+});
+
+test("applyTodo accepts completed as an alias of done, rejects unknown statuses, and sanitizes text", () => {
+	const alias = applyTodo(emptyTodo(), { action: "write", tasks: [{ title: "X", status: "completed" }] }, 1);
+	assert.equal(alias.state.tasks[0].status, TODO_STATUS.DONE);
+	const bad = applyTodo(emptyTodo(), { action: "write", tasks: [{ title: "X", status: "later" }] }, 1);
+	assert.match(bad.error ?? "", /unknown status "later"/);
+	const dirty = applyTodo(emptyTodo(), { action: "add", title: "Evil\x1b[31m title\n" }, 1).state;
+	assert.equal(dirty.tasks[0].title, "Evil title");
+	const empty = applyTodo(emptyTodo(), { action: "add", title: "   " }, 1);
+	assert.match(empty.error ?? "", /title is required/);
+});
+
+test("applyTodo list reports the state without changing it", () => {
+	const state = seeded();
+	const listed = applyTodo(state, { action: "list" }, 5);
+	assert.strictEqual(listed.state, state);
+	assert.match(listed.text, /\[done\] #1 Add quiet tool rendering/);
+	assert.match(listed.text, /\[in_progress\] #2 Fix quiet tools conflict — fixing conflict/);
+	assert.match(listed.text, /\[pending\] #3 Show git bash tails/);
+});
+
+test("todoSummary and staleTurns describe progress and how long the list went untouched", () => {
+	const state = seeded();
+	assert.deepEqual(todoSummary(state), { done: 1, total: 3, open: 2 });
+	assert.equal(staleTurns(state, 3), 0);
+	assert.equal(staleTurns(state, 5), 2);
+	const allDone = applyTodo(state, { action: "write", tasks: state.tasks.map((task) => ({ ...task, status: "done" })) }, 4).state;
+	assert.equal(staleTurns(allDone, 9), 0, "a finished list never goes stale");
+	assert.equal(staleTurns(emptyTodo(), 9), 0);
+});
+
+test("replayTodo rebuilds the latest state from Gentle and rpiv tool results alike", () => {
+	const gentle = { type: "message", message: { role: "toolResult", toolName: "todo", isError: false, details: { gentleTodo: { tasks: [{ id: 4, title: "Ours", status: "pending" }], nextId: 5, updatedTurn: 7 } } } };
+	const rpiv = { type: "message", message: { role: "toolResult", toolName: "todo", isError: false, details: { action: "update", params: {}, tasks: [{ id: 1, subject: "Theirs", status: "completed", activeForm: "done" }, { id: 2, subject: "Gone", status: "deleted" }, { id: 3, subject: "Now", status: "in_progress", activeForm: "doing it" }], nextId: 4 } } };
+	const other = { type: "message", message: { role: "toolResult", toolName: "bash", details: { tasks: [] } } };
+	assert.deepEqual(replayTodo([other, rpiv]).tasks, [
+		{ id: 1, title: "Theirs", status: TODO_STATUS.DONE },
+		{ id: 3, title: "Now", status: TODO_STATUS.IN_PROGRESS, note: "doing it" },
+	]);
+	assert.equal(replayTodo([other, rpiv]).nextId, 4);
+	assert.equal(replayTodo([rpiv, gentle]).tasks[0].title, "Ours", "the last write wins");
+	assert.equal(replayTodo([rpiv, gentle]).updatedTurn, 7);
+	assert.deepEqual(replayTodo([]), emptyTodo());
+});
+
+test("todoPromptBlock lists open work with the rules, and stays silent when there is nothing open", () => {
+	const block = todoPromptBlock(seeded(), 0);
+	assert.ok(block);
+	assert.match(block, /^## Todo list/m);
+	assert.match(block, /mark a task in_progress before starting/);
+	assert.match(block, /1\. \[done\] Add quiet tool rendering/);
+	assert.match(block, /2\. \[in_progress\] Fix quiet tools conflict — fixing conflict/);
+	assert.match(block, /3\. \[pending\] Show git bash tails/);
+	assert.doesNotMatch(block, /stale/);
+	assert.match(todoPromptBlock(seeded(), 2) ?? "", /stale: 2 turns without an update/);
+	assert.equal(todoPromptBlock(emptyTodo(), 0), undefined);
+	const allDone = applyTodo(seeded(), { action: "write", tasks: [{ title: "A", status: "done" }] }, 1).state;
+	assert.equal(todoPromptBlock(allDone, 0), undefined);
+});
+
+test("renderTodoCard draws the framed list with status glyphs and keeps every line at width", () => {
+	const lines = renderTodoCard(seeded(), plainTheme, 60, { collapsed: false, staleTurns: 0, collapseKey: "ctrl+shift+t" });
+	for (const line of lines) assert.equal(visibleWidth(line), 60, `"${stripAnsi(line)}" is not 60 wide`);
+	const plain = lines.map(stripAnsi);
+	assert.match(plain[0], /^╭─ ❀ Todos · 1 of 3 ─+╮$/);
+	assert.match(plain[1], /^│ ✓ ~Add quiet tool rendering~ +│$/);
+	assert.match(plain[2], /^│ ◐ Fix quiet tools conflict · fixing conflict +│$/);
+	assert.match(plain[3], /^│ ○ Show git bash tails +│$/);
+	assert.match(plain[4], /^╰─+╯$/);
+});
+
+test("renderTodoCard folds a long list: done tasks become one row and the open ones are capped", () => {
+	const tasks = Array.from({ length: 40 }, (_, index) => ({ title: `Task ${index + 1}`, status: index < 25 ? "done" : index === 25 ? "in_progress" : "pending" }));
+	const state = applyTodo(emptyTodo(), { action: "write", tasks }, 1).state;
+	const plain = renderTodoCard(state, plainTheme, 60, { collapsed: false, staleTurns: 0 }).map(stripAnsi);
+	assert.equal(plain.length, 14, "top rule, twelve rows, bottom rule");
+	assert.match(plain[0], /Todos · 25 of 40/);
+	assert.match(plain[1], /^│ ✓ 25 done +│$/);
+	assert.match(plain[2], /^│ ◐ Task 26 +│$/);
+	assert.match(plain[11], /^│ ○ Task 35 +│$/);
+	assert.match(plain[12], /^│ … 5 more +│$/);
+	const allDone = applyTodo(emptyTodo(), { action: "write", tasks: tasks.map((task) => ({ ...task, status: "done" })) }, 1).state;
+	const folded = renderTodoCard(allDone, plainTheme, 60, { collapsed: false, staleTurns: 0 }).map(stripAnsi);
+	assert.equal(folded.length, 3);
+	assert.match(folded[1], /^│ ✓ 40 done +│$/);
+});
+
+test("renderTodoCard marks a stale list in the top rule and collapses to the task in progress", () => {
+	const stale = renderTodoCard(seeded(), plainTheme, 70, { collapsed: false, staleTurns: 2, collapseKey: "ctrl+shift+t" }).map(stripAnsi);
+	assert.match(stale[0], /^╭─ ❀ Todos · 1 of 3 ─+ stale · 2 turns ╮$/);
+	const collapsed = renderTodoCard(seeded(), plainTheme, 70, { collapsed: true, staleTurns: 0, collapseKey: "ctrl+shift+t" }).map(stripAnsi);
+	assert.equal(collapsed.length, 3);
+	assert.match(collapsed[0], /^╭─ ❀ Todos · 1 of 3 ─+ ctrl\+shift\+t expand ╮$/);
+	assert.match(collapsed[1], /^│ ◐ Fix quiet tools conflict · fixing conflict +│$/);
+	const idle = applyTodo(emptyTodo(), { action: "write", tasks: [{ title: "Only pending" }] }, 1).state;
+	assert.match(renderTodoCard(idle, plainTheme, 70, { collapsed: true, staleTurns: 0 }).map(stripAnsi)[1], /^│ ○ 1 open +│$/);
+	assert.deepEqual(renderTodoCard(emptyTodo(), plainTheme, 70, { collapsed: false, staleTurns: 0 }), []);
+});

package/tests/shell-usage-view.test.ts

@@ -0,0 +1,62 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { stripAnsi } from "../lib/terminal-theme.ts";
+import { parseCodexUsage, UsageStore } from "../lib/shell-usage.ts";
+import { UsageView } from "../lib/shell-usage-view.ts";
+
+// The subscriptions overlay: one framed panel listing every provider the
+// store knows, with r to refetch and esc to close.
+
+const NOW = 1_788_600_000_000;
+const plainTheme = {
+	fg(_color: string, text: string) {
+		return text;
+	},
+};
+
+function payload(percent: number) {
+	return { plan_type: "pro", rate_limit: { primary_window: { used_percent: percent, limit_window_seconds: 604_800, reset_at: NOW / 1000 + 7200 } } };
+}
+
+test("UsageView frames the panel, keeps every line at width, and shows the empty state", () => {
+	const store = new UsageStore();
+	const events: string[] = [];
+	const view = new UsageView(store, { theme: plainTheme, now: () => NOW, active: () => undefined, onRefresh: async () => events.push("refresh"), onClose: () => events.push("close"), requestRender: () => events.push("render") });
+	const empty = view.render(90).map(stripAnsi);
+	assert.match(empty[0], /^╭─ ✿ Subscriptions ─+╮$/);
+	assert.match(empty[1], /No subscription usage yet/);
+	assert.match(empty[empty.length - 2], /r refresh .* esc close/);
+	assert.match(empty[empty.length - 1], /^╰─+╯$/);
+
+	store.record(parseCodexUsage(payload(40), NOW));
+	const lines = view.render(90);
+	for (const line of lines) assert.equal(visibleWidth(line), 90, `"${stripAnsi(line)}" is not 90 wide`);
+	const plain = lines.map(stripAnsi);
+	assert.match(plain[1], /^│ openai-codex · pro · updated just now +│$/);
+	assert.match(plain[3], /^│ {5}week +▰+▱+ +40% +resets in 2h 0m +│$/);
+});
+
+test("UsageView refetches on r and closes on escape or q", async () => {
+	const store = new UsageStore();
+	const events: string[] = [];
+	const view = new UsageView(store, {
+		theme: plainTheme,
+		now: () => NOW,
+		active: () => ({ provider: "openai-codex" }),
+		onRefresh: async () => {
+			store.record(parseCodexUsage(payload(55), NOW));
+			events.push("refresh");
+		},
+		onClose: () => events.push("close"),
+		requestRender: () => events.push("render"),
+	});
+	view.handleInput("r");
+	await new Promise((resolve) => setTimeout(resolve, 0));
+	assert.deepEqual(events, ["render", "refresh", "render"]);
+	assert.match(stripAnsi(view.render(90)[3]), /55%/);
+	assert.match(stripAnsi(view.render(90)[1]), /^│ ✿ openai-codex · pro · updated just now/);
+	view.handleInput("\x1b");
+	view.handleInput("q");
+	assert.equal(events.filter((event) => event === "close").length, 2);
+});

package/tests/shell-usage.test.ts

@@ -0,0 +1,197 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import {
+	accountIdFromToken,
+	formatReset,
+	parseAnthropicHeaders,
+	parseCodexHeaders,
+	parseUsageHeaders,
+	parseCodexUsage,
+	renderUsageBar,
+	renderUsagePanel,
+	UsageStore,
+	windowLabel,
+	type ProviderUsage,
+} from "../lib/shell-usage.ts";
+
+// Subscription usage: what each connected provider says about its windows.
+// Parsers are pure; the store only remembers the latest snapshot.
+
+const NOW = 1_788_600_000_000;
+
+const plainTheme = {
+	fg(_color: string, text: string) {
+		return text;
+	},
+};
+
+const taggedTheme = {
+	fg(color: string, text: string) {
+		return `<${color}>${text}</${color}>`;
+	},
+};
+
+const CODEX_PAYLOAD = {
+	plan_type: "pro",
+	rate_limit: {
+		allowed: true,
+		limit_reached: false,
+		primary_window: { used_percent: 40, limit_window_seconds: 604_800, reset_after_seconds: 175_331, reset_at: 1_788_777_491 },
+		secondary_window: null,
+	},
+	additional_rate_limits: [
+		{
+			limit_name: "codex_spark",
+			metered_feature: "spark",
+			rate_limit: {
+				allowed: true,
+				limit_reached: false,
+				primary_window: { used_percent: 12, limit_window_seconds: 18_000, reset_after_seconds: 18_000, reset_at: 1_788_620_161 },
+				secondary_window: { used_percent: 3, limit_window_seconds: 604_800, reset_after_seconds: 604_800, reset_at: 1_789_206_961 },
+			},
+		},
+	],
+	credits: { has_credits: false, unlimited: false, balance: "0" },
+	email: "someone@example.com",
+};
+
+test("windowLabel names the common windows and falls back to hours or days", () => {
+	assert.equal(windowLabel(18_000), "5h");
+	assert.equal(windowLabel(604_800), "week");
+	assert.equal(windowLabel(10_800), "3h");
+	assert.equal(windowLabel(172_800), "2d");
+	assert.equal(windowLabel(1_800), "30m");
+});
+
+test("formatReset speaks in minutes, hours, or days", () => {
+	assert.equal(formatReset(NOW + 25 * 60_000, NOW), "resets in 25m");
+	assert.equal(formatReset(NOW + (1 * 3600 + 48 * 60) * 1000, NOW), "resets in 1h 48m");
+	assert.equal(formatReset(NOW + (2 * 86_400 + 5 * 3600) * 1000, NOW), "resets in 2d 5h");
+	assert.equal(formatReset(NOW - 1000, NOW), "resets now");
+	assert.equal(formatReset(null, NOW), "");
+});
+
+test("parseCodexUsage keeps plan, windows, and named limits, and never keeps the email", () => {
+	const usage = parseCodexUsage(CODEX_PAYLOAD, NOW);
+	assert.equal(usage.provider, "openai-codex");
+	assert.equal(usage.plan, "pro");
+	assert.equal(usage.fetchedAt, NOW);
+	assert.deepEqual(
+		usage.limits.map((limit) => ({ name: limit.name, windows: limit.windows.map((w) => `${w.label}:${w.usedPercent}`) })),
+		[
+			{ name: "codex", windows: ["week:40"] },
+			{ name: "codex_spark", windows: ["5h:12", "week:3"] },
+		],
+	);
+	assert.equal(usage.limits[0].windows[0].resetAt, 1_788_777_491_000);
+	assert.equal(JSON.stringify(usage).includes("example.com"), false);
+});
+
+test("parseCodexUsage tolerates a payload without rate limits", () => {
+	const usage = parseCodexUsage({ plan_type: "free" }, NOW);
+	assert.equal(usage.plan, "free");
+	assert.deepEqual(usage.limits, []);
+});
+
+test("parseCodexHeaders reads the SSE rate-limit headers when a provider sends them", () => {
+	const usage = parseCodexHeaders(
+		{
+			"x-codex-primary-used-percent": "62",
+			"x-codex-primary-window-minutes": "300",
+			"x-codex-primary-reset-at": "1788620161",
+			"x-codex-secondary-used-percent": "31",
+			"x-codex-secondary-window-minutes": "10080",
+			"x-codex-secondary-reset-at": "1789206961",
+			"content-type": "text/event-stream",
+		},
+		NOW,
+	);
+	assert.ok(usage);
+	assert.deepEqual(usage.limits[0].windows.map((w) => `${w.label}:${w.usedPercent}:${w.resetAt}`), ["5h:62:1788620161000", "week:31:1789206961000"]);
+	assert.equal(parseCodexHeaders({ "content-type": "text/event-stream" }, NOW), undefined);
+});
+
+test("accountIdFromToken decodes the chatgpt account claim from an OAuth JWT", () => {
+	const claims = Buffer.from(JSON.stringify({ "https://api.openai.com/auth": { chatgpt_account_id: "acct-123" } })).toString("base64url");
+	assert.equal(accountIdFromToken(`header.${claims}.sig`), "acct-123");
+	assert.equal(accountIdFromToken("sk-not-a-jwt"), undefined);
+	assert.equal(accountIdFromToken("a.!!!.c"), undefined);
+});
+
+test("renderUsageBar summarizes the main limit with a gauge and the rest as percentages", () => {
+	const usage = parseCodexUsage(CODEX_PAYLOAD, NOW);
+	assert.equal(renderUsageBar(usage, plainTheme), "codex week ▰▰▰▱▱▱▱▱ 40%");
+	const twoWindows = parseCodexUsage({ ...CODEX_PAYLOAD, rate_limit: CODEX_PAYLOAD.additional_rate_limits[0].rate_limit }, NOW);
+	assert.equal(renderUsageBar(twoWindows, plainTheme), "codex 5h ▰▱▱▱▱▱▱▱ 12% · week 3%");
+	const hot = renderUsageBar(parseCodexUsage({ rate_limit: { primary_window: { used_percent: 91, limit_window_seconds: 18_000, reset_at: 1 } } }, NOW), taggedTheme);
+	assert.match(hot, /<warning>▰▰▰▰▰▰▰<\/warning>/);
+	assert.equal(renderUsageBar(parseCodexUsage({}, NOW), plainTheme), undefined);
+});
+
+test("renderUsagePanel lists each provider with meters, resets, and a stale marker", () => {
+	const usage = parseCodexUsage(CODEX_PAYLOAD, NOW);
+	const lines = renderUsagePanel([usage], plainTheme, 70, NOW + 3 * 60_000);
+	for (const line of lines) assert.ok(visibleWidth(line) <= 70, `too wide: ${line}`);
+	assert.match(lines[0], /^openai-codex · pro · updated 3m ago$/);
+	assert.match(lines[1], /^ {2}codex$/);
+	assert.match(lines[2], /^ {4}week +▰+▱+ +40% +resets in 2d 1h$/);
+	assert.match(lines[3], /^ {2}codex_spark$/);
+	assert.match(lines[4], /^ {4}5h /);
+	assert.match(lines[5], /^ {4}week /);
+	assert.deepEqual(renderUsagePanel([], plainTheme, 120, NOW), ["No subscription usage yet. Usage arrives with the next response, or press r to fetch it."]);
+});
+
+test("renderUsagePanel puts the active provider first and explains missing data", () => {
+	const codex = parseCodexUsage(CODEX_PAYLOAD, NOW);
+	const claude = parseAnthropicHeaders({ "anthropic-ratelimit-unified-5h-utilization": "0.2" }, NOW);
+	assert.ok(claude);
+	const both = renderUsagePanel([codex, claude], plainTheme, 100, NOW, { provider: "anthropic" });
+	assert.match(both[0], /^✿ anthropic · updated just now$/);
+	assert.match(both[1], /^ {2}claude$/);
+	assert.match(both.find((line) => line.startsWith("openai-codex")) ?? "", /^openai-codex · pro/);
+
+	const apiKey = renderUsagePanel([codex], plainTheme, 100, NOW, { provider: "openai" });
+	assert.match(apiKey[0], /^✿ openai · no subscription usage for this provider$/);
+	assert.match(apiKey[1], /^openai-codex · pro/);
+
+	const pending = renderUsagePanel([], plainTheme, 100, NOW, { provider: "anthropic" });
+	assert.deepEqual(pending, ["✿ anthropic · usage arrives with the first response"]);
+	assert.deepEqual(renderUsagePanel([], plainTheme, 100, NOW, { provider: "openai-codex" }), ["✿ openai-codex · no usage yet · r to fetch"]);
+});
+
+test("UsageStore keeps the latest snapshot per provider and lists them in order", () => {
+	const store = new UsageStore();
+	const first: ProviderUsage = { provider: "openai-codex", plan: "pro", limits: [], fetchedAt: 1 };
+	const second: ProviderUsage = { provider: "openai-codex", plan: "pro", limits: [], fetchedAt: 2 };
+	store.record(first);
+	store.record({ provider: "anthropic", plan: undefined, limits: [], fetchedAt: 1 });
+	store.record(second);
+	assert.equal(store.get("openai-codex"), second);
+	assert.deepEqual(store.all().map((usage) => usage.provider), ["openai-codex", "anthropic"]);
+});
+
+test("parseAnthropicHeaders turns the unified utilization fractions into 5h and weekly windows", () => {
+	const headers = {
+		"anthropic-ratelimit-unified-status": "allowed_warning",
+		"anthropic-ratelimit-unified-5h-utilization": "0.42",
+		"anthropic-ratelimit-unified-5h-reset": "1788620161",
+		"anthropic-ratelimit-unified-7d-utilization": "0.875",
+		"anthropic-ratelimit-unified-7d-reset": "1789206961",
+		"anthropic-ratelimit-unified-representative-claim": "seven_day",
+	};
+	const usage = parseAnthropicHeaders(headers, NOW);
+	assert.ok(usage);
+	assert.equal(usage.provider, "anthropic");
+	assert.deepEqual(usage.limits.map((limit) => limit.name), ["claude"]);
+	assert.deepEqual(usage.limits[0].windows.map((w) => `${w.label}:${w.usedPercent}:${w.resetAt}`), ["5h:42:1788620161000", "week:87.5:1789206961000"]);
+	assert.equal(usage.limits[0].limitReached, false);
+	assert.equal(parseAnthropicHeaders({ ...headers, "anthropic-ratelimit-unified-status": "rejected" }, NOW)?.limits[0].limitReached, true);
+	assert.equal(parseAnthropicHeaders({ "anthropic-ratelimit-requests-remaining": "99" }, NOW), undefined);
+});
+
+test("parseUsageHeaders picks whichever provider the headers belong to", () => {
+	assert.equal(parseUsageHeaders({ "x-codex-primary-used-percent": "10", "x-codex-primary-window-minutes": "300" }, NOW)?.provider, "openai-codex");
+	assert.equal(parseUsageHeaders({ "anthropic-ratelimit-unified-5h-utilization": "0.1" }, NOW)?.provider, "anthropic");
+	assert.equal(parseUsageHeaders({ "content-type": "application/json" }, NOW), undefined);
+});