gentle-pi 2.4.0 → 2.6.0

package/tests/shell-todo.test.ts

@@ -0,0 +1,259 @@
+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 ▾ Collapse · 1 of 3 ─+ ctrl\+shift\+t collapse ╮$/);
+	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 ▾ Collapse · 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 keeps the configured collapse shortcut in the header while stale state remains visible", () => {
+	const freshExpanded = renderTodoCard(seeded(), plainTheme, 70, { collapsed: false, staleTurns: 0, collapseKey: "ctrl+shift+t" }).map(stripAnsi);
+	assert.match(freshExpanded[0], /^╭─ ❀ Todos ▾ Collapse · 1 of 3 ─+ ctrl\+shift\+t collapse ╮$/);
+
+	const freshCollapsed = renderTodoCard(seeded(), plainTheme, 70, { collapsed: true, staleTurns: 0, collapseKey: "ctrl+shift+t" }).map(stripAnsi);
+	assert.equal(freshCollapsed.length, 3);
+	assert.match(freshCollapsed[0], /^╭─ ❀ Todos ▸ Expand · 1 of 3 ─+ ctrl\+shift\+t expand ╮$/);
+	assert.match(freshCollapsed[1], /^│ ◐ Fix quiet tools conflict · fixing conflict +│$/);
+
+	const staleExpanded = renderTodoCard(seeded(), plainTheme, 70, { collapsed: false, staleTurns: 2, collapseKey: "ctrl+shift+t" }).map(stripAnsi);
+	assert.match(staleExpanded[0], /^╭─ ❀ Todos ▾ Collapse · 1 of 3 ─+ ctrl\+shift\+t collapse ╮$/);
+	assert.match(staleExpanded[1], /^│ stale · 2 turns +│$/);
+
+	const staleCollapsed = renderTodoCard(seeded(), plainTheme, 70, { collapsed: true, staleTurns: 2, collapseKey: "ctrl+shift+t" }).map(stripAnsi);
+	assert.match(staleCollapsed[0], /^╭─ ❀ Todos ▸ Expand · 1 of 3 ─+ ctrl\+shift\+t expand ╮$/);
+	assert.match(staleCollapsed[1], /^│ stale · 2 turns +│$/);
+	assert.match(staleCollapsed[2], /^│ ◐ Fix quiet tools conflict · fixing conflict +│$/);
+
+	const fallback = applyTodo(emptyTodo(), { action: "write", tasks: [{ title: "Finished first", status: "done" }, { title: "First pending" }, { title: "Later pending" }] }, 1).state;
+	assert.match(renderTodoCard(fallback, plainTheme, 70, { collapsed: true, staleTurns: 0 }).map(stripAnsi)[1], /^│ ○ First pending +│$/);
+
+	const activeAfterPending = applyTodo(emptyTodo(), { action: "write", tasks: [{ title: "Pending first" }, { title: "Active second", status: "in_progress" }, { title: "Pending third" }] }, 1).state;
+	assert.match(renderTodoCard(activeAfterPending, plainTheme, 70, { collapsed: true, staleTurns: 0 }).map(stripAnsi)[1], /^│ ◐ Active second +│$/);
+	assert.deepEqual(renderTodoCard(emptyTodo(), plainTheme, 70, { collapsed: false, staleTurns: 0 }), []);
+});
+
+test("renderTodoCard keeps English controls visible and falls back to their icons at narrow widths", () => {
+	const expanded = renderTodoCard(seeded(), plainTheme, 70, { collapsed: false, staleTurns: 0, collapseKey: "ctrl+shift+t" }).map(stripAnsi);
+	assert.match(expanded[0], /Todos ▾ Collapse/);
+	assert.match(expanded[0], /ctrl\+shift\+t collapse/);
+	const collapsed = renderTodoCard(seeded(), plainTheme, 70, { collapsed: true, staleTurns: 0, collapseKey: "ctrl+shift+t" }).map(stripAnsi);
+	assert.match(collapsed[0], /Todos ▸ Expand/);
+	for (const [collapsedState, icon] of [[false, "▾"], [true, "▸"]] as const) {
+		const line = renderTodoCard(seeded(), plainTheme, 16, { collapsed: collapsedState, staleTurns: 0, collapseKey: "ctrl+shift+t" })[0]!;
+		assert.match(stripAnsi(line), new RegExp(`Todos ${icon}`));
+		assert.equal(visibleWidth(line), 16);
+	}
+});
+
+test("completed titles strike only title cells across wrapped lines, never padding or rails", () => {
+	const theme = {
+		fg: (_color: string, text: string) => `\x1b[32m${text}\x1b[39m`,
+		strikethrough: (text: string) => `\x1b[9m${text}\x1b[29m`,
+	};
+	const state = applyTodo(emptyTodo(), { action: "write", tasks: [
+		{ title: "Alpha beta gamma delta epsilon", status: "done" },
+		{ title: "Pending", status: "pending" },
+	] }, 1).state;
+	for (const width of [12, 20, 60]) {
+		const lines = renderTodoCard(state, theme, width, { collapsed: false, staleTurns: 0 });
+		let struckLetters = "";
+		for (const line of lines) {
+			let strike = false, column = 0;
+			const plain = stripAnsi(line);
+			const titleEnd = plain.slice(0, -1).trimEnd().length;
+			for (const token of line.match(/\x1b\[[\d;]*m|[^\x1b]/gu) ?? []) {
+				if (token.startsWith("\x1b")) {
+					for (const code of token.slice(2, -1).split(";").map(Number)) {
+						if (code === 0 || code === 29) strike = false;
+						if (code === 9) strike = true;
+					}
+				} else {
+					if (column < 2 || column >= titleEnd || /[│╭╮╰╯─✓]/u.test(token)) assert.equal(strike, false, `struck frame/padding: ${JSON.stringify(line)}`);
+					if (strike && /[A-Za-z]/.test(token)) struckLetters += token;
+					column += visibleWidth(token);
+				}
+			}
+			assert.equal(strike, false, "SGR 9 must close before the host appends padding");
+			assert.equal(visibleWidth(line), width);
+		}
+		assert.equal(struckLetters, "Alphabetagammadeltaepsilon");
+	}
+});
+
+test("renderTodoCard keeps stale indicators and collapse hints in scrollable lists", () => {
+	const tasks = Array.from({ length: 40 }, (_, index) => ({ title: `Task ${index + 1}`, status: index < 25 ? "done" : "pending" }));
+	const state = applyTodo(emptyTodo(), { action: "write", tasks }, 1).state;
+	const lines = renderTodoCard(state, plainTheme, 70, { scrollable: true, collapsed: false, staleTurns: 2, collapseKey: "alt+t" }).map(stripAnsi);
+	assert.equal(lines.length, 43, "top rule, stale row, every task, bottom rule");
+	assert.match(lines[0], /^╭─ ❀ Todos ▾ Collapse · 25 of 40 ─+ alt\+t collapse ╮$/);
+	assert.match(lines[1], /^│ stale · 2 turns +│$/);
+	assert.match(lines[2], /^│ ✓ ~Task 1~ +│$/);
+	assert.match(lines[41], /^│ ○ Task 40 +│$/);
+	for (const line of lines) assert.equal(visibleWidth(line), 70);
+});
+
+test("renderTodoCard uses custom shortcuts, omits disabled shortcuts, and remains width-safe when hints cannot fit", () => {
+	const custom = renderTodoCard(seeded(), plainTheme, 70, { collapsed: false, staleTurns: 2, collapseKey: "alt+t" }).map(stripAnsi);
+	assert.match(custom[0], /alt\+t collapse/);
+	assert.match(custom[1], /stale · 2 turns/);
+
+	const disabled = renderTodoCard(seeded(), plainTheme, 70, { collapsed: true, staleTurns: 2 }).map(stripAnsi);
+	assert.doesNotMatch(disabled[0], /(?:collapse|expand|ctrl\+shift\+t)/);
+	assert.match(disabled[1], /stale · 2 turns/);
+
+	for (const width of [0, 1, 2, 3, 4, 5, 8, 16]) {
+		const lines = renderTodoCard(seeded(), plainTheme, width, { collapsed: false, staleTurns: 2, collapseKey: "ctrl+shift+t" });
+		for (const line of lines) assert.equal(visibleWidth(line), width, `"${stripAnsi(line)}" is not ${width} wide`);
+	}
+});

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);
+});

package/tests/startup-banner.test.ts

@@ -0,0 +1,126 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { syncBuiltinESMExports } from "node:module";
+import fs from "node:fs/promises";
+import startup, { readGitBranch } from "../extensions/startup-banner.ts";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { stripAnsi } from "../lib/terminal-theme.ts";
+
+test("startup branch lookup uses direct git argv and hides its Windows child", async () => {
+	const calls: Array<{ command: string; args: readonly string[]; options: Record<string, unknown> }> = [];
+	const run = ((command: string, args: readonly string[], options: Record<string, unknown>, callback: (error: Error | null, stdout: string) => void) => {
+		calls.push({ command, args, options });
+		callback(null, "main\n");
+	}) as typeof import("node:child_process").execFile;
+	assert.equal(await readGitBranch("/repo with spaces & metacharacters", run), "On branch main");
+	assert.deepEqual(calls, [{
+		command: "git",
+		args: ["-C", "/repo with spaces & metacharacters", "branch", "--show-current"],
+		options: { encoding: "utf8", shell: false, windowsHide: true },
+    }]);
+});
+
+test("startup banner keeps animating after invalidate and cleans up on dispose", async (t) => {
+	t.mock.timers.enable({ apis: ["setTimeout", "setInterval", "Date"] });
+	t.mock.method(fs, "readFile", async () => JSON.stringify({ showRose: true, showTextLogo: true, color: "pink" }));
+	syncBuiltinESMExports();
+	t.after(() => { t.mock.restoreAll(); syncBuiltinESMExports(); });
+	const argv = process.argv;
+	process.argv = ["node"];
+	t.after(() => { process.argv = argv; });
+	for (const [key, value] of [["rows", 40], ["columns", 160]] as const) {
+		const descriptor = Object.getOwnPropertyDescriptor(process.stdout, key);
+		Object.defineProperty(process.stdout, key, { configurable: true, writable: true, value });
+		t.after(() => descriptor ? Object.defineProperty(process.stdout, key, descriptor) : Reflect.deleteProperty(process.stdout, key));
+	}
+	let start: Function;
+	let shutdown: Function;
+	let header: { render(width: number): string[]; invalidate(): void; dispose(): void };
+	let renders = 0;
+	startup({ on: (name: string, fn: Function) => {
+		if (name === "session_start") start = fn;
+		if (name === "session_shutdown") shutdown = fn;
+	}, registerCommand() {}, getCommands: () => [], getAllTools: () => [] } as unknown as ExtensionAPI);
+	await start!({}, { hasUI: true, cwd: "/fixture", ui: { setHeader: (factory: Function) => {
+		header = factory({ requestRender() { renders++; } }, { fg: (_role: string, text: string) => text });
+	} } });
+	t.mock.timers.tick(50);
+	const afterBoot = renders;
+	t.mock.timers.tick(25);
+	assert.ok(renders > afterBoot, "animation timer requests renders");
+	header!.invalidate();
+	const afterInvalidate = renders;
+	t.mock.timers.tick(25);
+	assert.ok(renders > afterInvalidate, "invalidate() must not stop the animation timer");
+	header!.dispose();
+	const afterDispose = renders;
+	t.mock.timers.tick(25);
+	assert.equal(renders, afterDispose, "dispose() stops the animation timer");
+	shutdown!();
+	t.mock.timers.tick(25);
+	assert.equal(renders, afterDispose, "session_shutdown cleanup stays idle");
+});
+
+// Drive the real header factory; background git/home reads never run.
+for (const showRose of [false, true]) for (const showTextLogo of [false, true]) {
+	test(`startup art respects rose=${showRose}, logo=${showTextLogo} and cyan palette`, async (t) => {
+		t.mock.timers.enable({ apis: ["setTimeout", "setInterval", "Date"] });
+		t.mock.method(fs, "readFile", async () => JSON.stringify({ showRose, showTextLogo, color: "cyan" }));
+		syncBuiltinESMExports();
+		t.after(() => { t.mock.restoreAll(); syncBuiltinESMExports(); });
+		const argv = process.argv;
+		process.argv = ["node"];
+		t.after(() => { process.argv = argv; });
+		for (const [key, value] of [["rows", 40], ["columns", 160]] as const) {
+			const descriptor = Object.getOwnPropertyDescriptor(process.stdout, key);
+			Object.defineProperty(process.stdout, key, { configurable: true, writable: true, value });
+			t.after(() => descriptor ? Object.defineProperty(process.stdout, key, descriptor) : Reflect.deleteProperty(process.stdout, key));
+		}
+		let start: Function;
+		let shutdown: Function;
+		let header: { render(width: number): string[]; dispose(): void };
+		const writes: string[] = [];
+		startup({ on: (name: string, fn: Function) => {
+			if (name === "session_start") start = fn;
+			if (name === "session_shutdown") shutdown = fn;
+		}, registerCommand() {}, getCommands: () => [], getAllTools: () => [] } as unknown as ExtensionAPI);
+		const write = t.mock.method(process.stdout, "write", (text: string) => { writes.push(String(text)); return true; });
+		await start!({}, { hasUI: true, cwd: "/fixture", ui: { setHeader: (factory: Function) => {
+			header = factory({ requestRender() {} }, { fg: (_role: string, text: string) => text });
+		} } });
+		t.mock.timers.tick(50);
+		try {
+			for (const width of [40, 80, 160]) {
+				const lines = header!.render(width);
+				assert.ok(lines.every((line) => visibleWidth(line) <= width));
+				const text = stripAnsi(lines.join("\n"));
+				assert.match(text, /GIT:/);
+				assert.match(text, /PATH:/);
+				if (width === 160) {
+					assert.equal(/[\u2800-\u28ff]/.test(text), showRose);
+					assert.equal(/[▒▄▀█]/.test(text), showTextLogo);
+				}
+				assert.match(lines.join("\n"), /\x1b\[38;2;85;170;205m/, "startup labels use the saved cyan palette");
+			}
+			// Cancel pending context reads before advancing the resize clock.
+			t.mock.timers.reset();
+			t.mock.timers.enable({ apis: ["setTimeout", "Date"], now: Date.now() + 1000 });
+			process.stdout.rows = 10;
+			process.stdout.emit("resize");
+			t.mock.timers.tick(150);
+			assert.deepEqual(header!.render(80), []);
+			process.stdout.rows = 25;
+			process.stdout.columns = 80;
+			process.stdout.emit("resize");
+			t.mock.timers.tick(150);
+			const minimal = stripAnsi(header!.render(80).join("\n"));
+			assert.doesNotMatch(minimal, /[\u2800-\u28ff]/);
+			assert.equal(/[▒▄▀█]/.test(minimal), showTextLogo);
+			assert.deepEqual(writes, [], "Pi owns stdout during startup and resize");
+		} finally {
+			shutdown!();
+			write.mock.restore();
+		}
+	});
+}