gentle-pi 2.4.0 → 2.5.0

package/lib/shell-todo.ts

@@ -0,0 +1,280 @@
+import { CARD_TONE, renderCard, type CardTheme } from "./shell-card.ts";
+import { sanitizeTerminalText } from "./terminal-theme.ts";
+
+// Gentle Todo: the task list the model keeps while it works. Everything here
+// is pure. The state lives in the session branch (every tool result carries
+// the full snapshot), and staleness is how many turns passed since the last
+// write while tasks are still open.
+
+export const TODO_STATUS = {
+	PENDING: "pending",
+	IN_PROGRESS: "in_progress",
+	DONE: "done",
+} as const;
+
+export type TodoStatus = (typeof TODO_STATUS)[keyof typeof TODO_STATUS];
+
+export const TODO_ACTION = {
+	WRITE: "write",
+	ADD: "add",
+	UPDATE: "update",
+	CLEAR: "clear",
+	LIST: "list",
+} as const;
+
+export type TodoAction = (typeof TODO_ACTION)[keyof typeof TODO_ACTION];
+
+export interface TodoTask {
+	id: number;
+	title: string;
+	status: TodoStatus;
+	note?: string;
+}
+
+export interface TodoState {
+	tasks: TodoTask[];
+	nextId: number;
+	/** Turn index of the last write, or null before the first one. */
+	updatedTurn: number | null;
+}
+
+export interface TodoTaskInput {
+	id?: number;
+	title?: string;
+	status?: string;
+	note?: string;
+}
+
+export interface TodoParams {
+	action: string;
+	tasks?: TodoTaskInput[];
+	id?: number;
+	title?: string;
+	status?: string;
+	note?: string;
+}
+
+export interface TodoResult {
+	state: TodoState;
+	text: string;
+	error?: string;
+}
+
+export interface TodoSummary {
+	done: number;
+	total: number;
+	open: number;
+}
+
+export interface TodoTheme extends CardTheme {
+	strikethrough(text: string): string;
+}
+
+export interface TodoRenderOptions {
+	collapsed: boolean;
+	staleTurns: number;
+	collapseKey?: string;
+}
+
+/** Tool results carry the snapshot under this key; the old rpiv-todo shape is read too. */
+export const TODO_DETAILS_KEY = "gentleTodo";
+export const TODO_TOOL_NAME = "todo";
+export const TODO_GLYPH = "❀";
+const STATUS_ALIASES: Record<string, TodoStatus> = { completed: TODO_STATUS.DONE, complete: TODO_STATUS.DONE, doing: TODO_STATUS.IN_PROGRESS, todo: TODO_STATUS.PENDING };
+const STATUS_GLYPH: Record<TodoStatus, string> = { [TODO_STATUS.PENDING]: "○", [TODO_STATUS.IN_PROGRESS]: "◐", [TODO_STATUS.DONE]: "✓" };
+const STATUS_ROLE: Record<TodoStatus, string> = { [TODO_STATUS.PENDING]: "text", [TODO_STATUS.IN_PROGRESS]: "accent", [TODO_STATUS.DONE]: "dim" };
+const GLYPH_ROLE: Record<TodoStatus, string> = { [TODO_STATUS.PENDING]: "muted", [TODO_STATUS.IN_PROGRESS]: "accent", [TODO_STATUS.DONE]: "success" };
+const NOTE_ROLE = "muted";
+const STALE_AFTER_TURNS = 2;
+/** Above this many rows the finished tasks fold into one line and the rest is capped. */
+const ROW_CAP = 12;
+
+export function emptyTodo(): TodoState {
+	return { tasks: [], nextId: 1, updatedTurn: null };
+}
+
+function cleanText(value: unknown): string {
+	return typeof value === "string" ? sanitizeTerminalText(value).replace(/\s+/g, " ").trim() : "";
+}
+
+function parseStatus(value: unknown): TodoStatus | undefined {
+	if (value === undefined || value === null || value === "") return TODO_STATUS.PENDING;
+	if (typeof value !== "string") return undefined;
+	const normalized = value.trim().toLowerCase().replace(/[\s-]+/g, "_");
+	if ((Object.values(TODO_STATUS) as string[]).includes(normalized)) return normalized as TodoStatus;
+	return STATUS_ALIASES[normalized];
+}
+
+export function todoSummary(state: TodoState): TodoSummary {
+	const done = state.tasks.filter((task) => task.status === TODO_STATUS.DONE).length;
+	return { done, total: state.tasks.length, open: state.tasks.length - done };
+}
+
+export function staleTurns(state: TodoState, currentTurn: number): number {
+	if (state.updatedTurn === null || todoSummary(state).open === 0) return 0;
+	return Math.max(0, currentTurn - state.updatedTurn);
+}
+
+function summaryText(state: TodoState): string {
+	const { done, total } = todoSummary(state);
+	const inProgress = state.tasks.filter((task) => task.status === TODO_STATUS.IN_PROGRESS).length;
+	return `${total} ${total === 1 ? "task" : "tasks"} · ${done} done · ${inProgress} in progress`;
+}
+
+function taskLine(task: TodoTask): string {
+	return `[${task.status}] #${task.id} ${task.title}${task.note ? ` — ${task.note}` : ""}`;
+}
+
+function buildTask(input: TodoTaskInput, id: number): TodoTask | string {
+	const title = cleanText(input.title);
+	if (title.length === 0) return "title is required";
+	const status = parseStatus(input.status);
+	if (status === undefined) return `unknown status "${input.status}" (use pending, in_progress, or done)`;
+	const note = cleanText(input.note);
+	return { id, title, status, ...(note ? { note } : {}) };
+}
+
+function write(state: TodoState, inputs: TodoTaskInput[], turn: number): TodoResult {
+	const tasks: TodoTask[] = [];
+	let nextId = state.nextId;
+	for (const input of inputs) {
+		const keepId = typeof input.id === "number" && Number.isInteger(input.id) && input.id > 0 && !tasks.some((task) => task.id === input.id);
+		const id = keepId ? (input.id as number) : nextId++;
+		nextId = Math.max(nextId, id + 1);
+		const built = buildTask(input, id);
+		if (typeof built === "string") return { state, text: `Error: ${built}`, error: built };
+		tasks.push(built);
+	}
+	const next = { tasks, nextId, updatedTurn: turn };
+	return { state: next, text: `Todo list written: ${summaryText(next)}` };
+}
+
+function update(state: TodoState, params: TodoParams, turn: number): TodoResult {
+	const task = state.tasks.find((candidate) => candidate.id === params.id);
+	if (!task) {
+		const error = `no task #${params.id}`;
+		return { state, text: `Error: ${error}`, error };
+	}
+	if (params.status === undefined && params.title === undefined && params.note === undefined) {
+		const error = "nothing to update: pass status, title, or note";
+		return { state, text: `Error: ${error}`, error };
+	}
+	const built = buildTask({ id: task.id, title: params.title ?? task.title, status: params.status ?? task.status, note: params.note ?? task.note }, task.id);
+	if (typeof built === "string") return { state, text: `Error: ${built}`, error: built };
+	const next = { ...state, tasks: state.tasks.map((candidate) => (candidate.id === task.id ? built : candidate)), updatedTurn: turn };
+	const change = task.status === built.status ? "updated" : `→ ${built.status}`;
+	return { state: next, text: `#${built.id} ${built.title} ${change}` };
+}
+
+export function applyTodo(state: TodoState, params: TodoParams, turn: number): TodoResult {
+	switch (params.action) {
+		case TODO_ACTION.WRITE:
+			return write(state, Array.isArray(params.tasks) ? params.tasks : [], turn);
+		case TODO_ACTION.ADD: {
+			const built = buildTask({ title: params.title, status: params.status, note: params.note }, state.nextId);
+			if (typeof built === "string") return { state, text: `Error: ${built}`, error: built };
+			const next = { tasks: [...state.tasks, built], nextId: state.nextId + 1, updatedTurn: turn };
+			return { state: next, text: `Added #${built.id} ${built.title} (${built.status})` };
+		}
+		case TODO_ACTION.UPDATE:
+			return update(state, params, turn);
+		case TODO_ACTION.CLEAR:
+			return { state: { ...emptyTodo(), updatedTurn: turn }, text: `Cleared ${state.tasks.length} ${state.tasks.length === 1 ? "task" : "tasks"}` };
+		case TODO_ACTION.LIST:
+			return { state, text: state.tasks.length === 0 ? "No tasks." : state.tasks.map(taskLine).join("\n") };
+		default: {
+			const error = `unknown action "${params.action}" (use write, add, update, clear, or list)`;
+			return { state, text: `Error: ${error}`, error };
+		}
+	}
+}
+
+interface ReplayEntry {
+	type?: string;
+	message?: { role?: string; toolName?: string; isError?: boolean; details?: unknown };
+}
+
+interface RpivTask {
+	id?: number;
+	subject?: string;
+	status?: string;
+	activeForm?: string;
+}
+
+function fromRpiv(details: { tasks?: RpivTask[]; nextId?: number }): TodoState {
+	const tasks: TodoTask[] = [];
+	for (const raw of details.tasks ?? []) {
+		if (raw.status === "deleted" || typeof raw.id !== "number") continue;
+		const built = buildTask({ id: raw.id, title: raw.subject, status: raw.status, note: raw.status === TODO_STATUS.IN_PROGRESS ? raw.activeForm : undefined }, raw.id);
+		if (typeof built !== "string") tasks.push(built);
+	}
+	return { tasks, nextId: typeof details.nextId === "number" ? details.nextId : tasks.reduce((max, task) => Math.max(max, task.id), 0) + 1, updatedTurn: null };
+}
+
+// The last successful `todo` result on the branch is the state: ours carries
+// the snapshot under `gentleTodo`; rpiv-todo carried `tasks` + `nextId` at the top.
+export function replayTodo(entries: readonly unknown[]): TodoState {
+	let state = emptyTodo();
+	for (const entry of entries as ReplayEntry[]) {
+		const message = entry?.message;
+		if (entry?.type !== "message" || message?.role !== "toolResult" || message.toolName !== TODO_TOOL_NAME || message.isError === true) continue;
+		const details = message.details as Record<string, unknown> | undefined;
+		if (!details || typeof details !== "object") continue;
+		const ours = details[TODO_DETAILS_KEY] as TodoState | undefined;
+		if (ours && Array.isArray(ours.tasks)) state = { tasks: ours.tasks, nextId: ours.nextId, updatedTurn: ours.updatedTurn ?? null };
+		else if (Array.isArray(details.tasks)) state = fromRpiv(details as { tasks?: RpivTask[]; nextId?: number });
+	}
+	return state;
+}
+
+export function todoPromptBlock(state: TodoState, stale: number): string | undefined {
+	if (todoSummary(state).open === 0) return undefined;
+	const lines = state.tasks.map((task, index) => `${index + 1}. [${task.status}] ${task.title}${task.note ? ` — ${task.note}` : ""}`);
+	const staleLine = stale >= STALE_AFTER_TURNS ? `\n(stale: ${stale} turns without an update — bring the list up to date now)` : "";
+	return [
+		"## Todo list",
+		"Keep it current with the `todo` tool: mark a task in_progress before starting it, done right after finishing it, and rewrite the whole list with `write` whenever the plan changes. Update it before you end the turn.",
+		...lines,
+	].join("\n") + staleLine;
+}
+
+function taskRow(task: TodoTask, theme: TodoTheme): string {
+	const title = task.status === TODO_STATUS.DONE ? theme.strikethrough(task.title) : task.title;
+	const note = task.status === TODO_STATUS.IN_PROGRESS && task.note ? ` ${theme.fg(NOTE_ROLE, "·")} ${theme.fg(NOTE_ROLE, task.note)}` : "";
+	return `${theme.fg(GLYPH_ROLE[task.status], STATUS_GLYPH[task.status])} ${theme.fg(STATUS_ROLE[task.status], title)}${note}`;
+}
+
+// Long lists keep the card short: done tasks fold into "✓ N done" and the
+// open ones fill the remaining rows, with a trailing count for the rest.
+function bodyRows(state: TodoState, theme: TodoTheme): string[] {
+	if (state.tasks.length <= ROW_CAP) return state.tasks.map((task) => taskRow(task, theme));
+	const { done } = todoSummary(state);
+	const open = state.tasks.filter((task) => task.status !== TODO_STATUS.DONE);
+	const rows: string[] = [];
+	if (done > 0) rows.push(`${theme.fg(GLYPH_ROLE[TODO_STATUS.DONE], STATUS_GLYPH[TODO_STATUS.DONE])} ${theme.fg(NOTE_ROLE, `${done} done`)}`);
+	const room = ROW_CAP - rows.length - (open.length > ROW_CAP - rows.length ? 1 : 0);
+	for (const task of open.slice(0, room)) rows.push(taskRow(task, theme));
+	if (open.length > room) rows.push(theme.fg(NOTE_ROLE, `… ${open.length - room} more`));
+	return rows;
+}
+
+function collapsedRow(state: TodoState, theme: TodoTheme): string {
+	const active = state.tasks.find((task) => task.status === TODO_STATUS.IN_PROGRESS);
+	if (active) return taskRow(active, theme);
+	const { open } = todoSummary(state);
+	return `${theme.fg(GLYPH_ROLE[TODO_STATUS.PENDING], STATUS_GLYPH[TODO_STATUS.PENDING])} ${theme.fg(NOTE_ROLE, `${open} open`)}`;
+}
+
+export function renderTodoCard(state: TodoState, theme: TodoTheme, width: number, options: TodoRenderOptions): string[] {
+	if (state.tasks.length === 0) return [];
+	const { done, total } = todoSummary(state);
+	const stale = options.staleTurns >= STALE_AFTER_TURNS;
+	const hint = stale ? `stale · ${options.staleTurns} turns` : options.collapsed && options.collapseKey ? `${options.collapseKey} expand` : undefined;
+	const body = options.collapsed ? [collapsedRow(state, theme)] : bodyRows(state, theme);
+	return renderCard(
+		{ title: "Todos", subtitle: `${done} of ${total}`, body, tone: stale ? CARD_TONE.WARNING : CARD_TONE.INFO, glyph: TODO_GLYPH },
+		theme,
+		width,
+		{ expanded: true, hint },
+	);
+}

package/lib/shell-usage-view.ts

@@ -0,0 +1,76 @@
+import { Key, matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { renderUsagePanel, type ActiveProvider, type UsageStore, type UsageTheme } from "./shell-usage.ts";
+
+// Gentle Shell subscriptions overlay: a framed panel over the usage store.
+// It reads the store on every render, so a refresh only needs to record.
+
+export interface UsageViewDeps {
+	theme: UsageTheme;
+	now(): number;
+	active(): ActiveProvider | undefined;
+	onRefresh(): Promise<void>;
+	onClose(): void;
+	requestRender(): void;
+}
+
+const TITLE = "✿ Subscriptions";
+const REFRESHING = "✿ Subscriptions · refreshing…";
+const FRAME_ROLE = "border";
+const TITLE_ROLE = "customMessageLabel";
+const KEY_ROLE = "accent";
+const KEY_TEXT_ROLE = "dim";
+const KEYS = [
+	["r", "refresh"],
+	["esc", "close"],
+] as const;
+
+function rule(length: number): string {
+	return "─".repeat(Math.max(0, length));
+}
+
+function fit(text: string, width: number): string {
+	const clipped = truncateToWidth(text, width, "…");
+	return clipped + " ".repeat(Math.max(0, width - visibleWidth(clipped)));
+}
+
+export class UsageView {
+	private readonly store: UsageStore;
+	private readonly deps: UsageViewDeps;
+	private refreshing = false;
+
+	constructor(store: UsageStore, deps: UsageViewDeps) {
+		this.store = store;
+		this.deps = deps;
+	}
+
+	handleInput(data: string): void {
+		if (matchesKey(data, Key.escape) || data === "q") {
+			this.deps.onClose();
+			return;
+		}
+		if (data === "r" && !this.refreshing) {
+			this.refreshing = true;
+			this.deps.requestRender();
+			void this.deps.onRefresh().finally(() => {
+				this.refreshing = false;
+				this.deps.requestRender();
+			});
+		}
+	}
+
+	render(width: number): string[] {
+		const theme = this.deps.theme;
+		const inner = width - 2;
+		const title = this.refreshing ? REFRESHING : TITLE;
+		const top = theme.fg(FRAME_ROLE, "╭─ ") + theme.fg(TITLE_ROLE, title) + theme.fg(FRAME_ROLE, ` ${rule(inner - visibleWidth(title) - 3)}╮`);
+		const body = renderUsagePanel(this.store.all(), theme, inner - 2, this.deps.now(), this.deps.active()).map(
+			(line) => `${theme.fg(FRAME_ROLE, "│")} ${fit(line, inner - 2)} ${theme.fg(FRAME_ROLE, "│")}`,
+		);
+		const keys = KEYS.map(([key, label]) => `${theme.fg(KEY_ROLE, key)} ${theme.fg(KEY_TEXT_ROLE, label)}`).join("   ");
+		const keysLine = `${theme.fg(FRAME_ROLE, "│")} ${fit(keys, inner - 2)} ${theme.fg(FRAME_ROLE, "│")}`;
+		const bottom = theme.fg(FRAME_ROLE, `╰${rule(inner)}╯`);
+		return [top, ...body, keysLine, bottom];
+	}
+
+	invalidate(): void {}
+}

package/lib/shell-usage.ts

@@ -0,0 +1,246 @@
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import { paintGauge } from "./shell-gauge.ts";
+
+// Gentle Shell subscription usage: the rate-limit windows each connected
+// provider reports. Codex sends them as SSE headers and through its usage
+// endpoint; both land in the same model. Parsing is pure and never keeps
+// account details beyond the plan name.
+
+export interface UsageWindow {
+	label: string;
+	usedPercent: number;
+	windowSeconds: number;
+	resetAt: number | null;
+}
+
+export interface UsageLimit {
+	name: string;
+	windows: UsageWindow[];
+	limitReached: boolean;
+}
+
+export interface ProviderUsage {
+	provider: string;
+	plan: string | undefined;
+	limits: UsageLimit[];
+	fetchedAt: number;
+}
+
+export interface UsageTheme {
+	fg(color: string, text: string): string;
+}
+
+interface RawWindow {
+	used_percent?: number;
+	limit_window_seconds?: number;
+	reset_after_seconds?: number;
+	reset_at?: number;
+}
+
+interface RawRateLimit {
+	limit_reached?: boolean;
+	primary_window?: RawWindow | null;
+	secondary_window?: RawWindow | null;
+}
+
+interface RawAdditionalLimit {
+	limit_name?: string;
+	rate_limit?: RawRateLimit | null;
+}
+
+interface RawCodexUsage {
+	plan_type?: string;
+	rate_limit?: RawRateLimit | null;
+	additional_rate_limits?: RawAdditionalLimit[] | null;
+}
+
+export const CODEX_PROVIDER = "openai-codex";
+export const ANTHROPIC_PROVIDER = "anthropic";
+const ANTHROPIC_MAIN_LIMIT = "claude";
+const ANTHROPIC_PREFIX = "anthropic-ratelimit-unified-";
+const ANTHROPIC_WINDOWS: ReadonlyArray<[key: string, seconds: number]> = [
+	["5h", 18_000],
+	["7d", 604_800],
+];
+export const CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
+const CODEX_MAIN_LIMIT = "codex";
+const CODEX_ACCOUNT_CLAIM = "https://api.openai.com/auth";
+const HEADER_PREFIX = "x-codex-";
+const PANEL_METER_CELLS = 16;
+const MINUTE = 60;
+const HOUR = 3600;
+const DAY = 86_400;
+const WEEK = 604_800;
+const ROLE = {
+	PROVIDER: "text",
+	PLAN: "muted",
+	LIMIT: "customMessageLabel",
+	LABEL: "muted",
+	PERCENT: "text",
+	RESET: "dim",
+	SEPARATOR: "muted",
+} as const;
+export const USAGE_EMPTY_MESSAGE = "No subscription usage yet. Usage arrives with the next response, or press r to fetch it.";
+export const SUPPORTED_USAGE_PROVIDERS: readonly string[] = [CODEX_PROVIDER, ANTHROPIC_PROVIDER];
+const PENDING_NOTE: Record<string, string> = {
+	[CODEX_PROVIDER]: "no usage yet · r to fetch",
+	[ANTHROPIC_PROVIDER]: "usage arrives with the first response",
+};
+const UNSUPPORTED_NOTE = "no subscription usage for this provider";
+const ACTIVE_MARK = "✿";
+
+export interface ActiveProvider {
+	provider: string;
+}
+
+export function providerNote(provider: string): string {
+	return PENDING_NOTE[provider] ?? UNSUPPORTED_NOTE;
+}
+
+export function windowLabel(seconds: number): string {
+	if (seconds === WEEK) return "week";
+	if (seconds >= DAY && seconds % DAY === 0) return `${seconds / DAY}d`;
+	if (seconds >= HOUR && seconds % HOUR === 0) return `${seconds / HOUR}h`;
+	return `${Math.round(seconds / MINUTE)}m`;
+}
+
+export function formatReset(resetAt: number | null, now: number): string {
+	if (resetAt === null) return "";
+	const seconds = Math.floor((resetAt - now) / 1000);
+	if (seconds <= 0) return "resets now";
+	if (seconds < HOUR) return `resets in ${Math.max(1, Math.round(seconds / MINUTE))}m`;
+	if (seconds < DAY) return `resets in ${Math.floor(seconds / HOUR)}h ${Math.floor((seconds % HOUR) / MINUTE)}m`;
+	return `resets in ${Math.floor(seconds / DAY)}d ${Math.floor((seconds % DAY) / HOUR)}h`;
+}
+
+function parseWindow(raw: RawWindow | null | undefined, now: number): UsageWindow | undefined {
+	if (!raw || typeof raw.used_percent !== "number" || typeof raw.limit_window_seconds !== "number") return undefined;
+	const resetAt =
+		typeof raw.reset_at === "number" ? raw.reset_at * 1000 : typeof raw.reset_after_seconds === "number" ? now + raw.reset_after_seconds * 1000 : null;
+	return { label: windowLabel(raw.limit_window_seconds), usedPercent: raw.used_percent, windowSeconds: raw.limit_window_seconds, resetAt };
+}
+
+function parseRateLimit(name: string, raw: RawRateLimit | null | undefined, now: number): UsageLimit | undefined {
+	if (!raw) return undefined;
+	const windows = [parseWindow(raw.primary_window, now), parseWindow(raw.secondary_window, now)].filter((window): window is UsageWindow => window !== undefined);
+	if (windows.length === 0) return undefined;
+	return { name, windows, limitReached: raw.limit_reached === true };
+}
+
+export function parseCodexUsage(payload: unknown, now: number): ProviderUsage {
+	const raw = (payload ?? {}) as RawCodexUsage;
+	const limits: UsageLimit[] = [];
+	const main = parseRateLimit(CODEX_MAIN_LIMIT, raw.rate_limit, now);
+	if (main) limits.push(main);
+	for (const extra of raw.additional_rate_limits ?? []) {
+		const limit = parseRateLimit(extra.limit_name ?? "limit", extra.rate_limit, now);
+		if (limit) limits.push(limit);
+	}
+	return { provider: CODEX_PROVIDER, plan: typeof raw.plan_type === "string" ? raw.plan_type : undefined, limits, fetchedAt: now };
+}
+
+function headerWindow(headers: Record<string, string>, kind: "primary" | "secondary", now: number): UsageWindow | undefined {
+	const used = Number.parseFloat(headers[`${HEADER_PREFIX}${kind}-used-percent`] ?? "");
+	if (!Number.isFinite(used)) return undefined;
+	const minutes = Number.parseInt(headers[`${HEADER_PREFIX}${kind}-window-minutes`] ?? "", 10);
+	const resetAt = Number.parseInt(headers[`${HEADER_PREFIX}${kind}-reset-at`] ?? "", 10);
+	const seconds = Number.isFinite(minutes) ? minutes * MINUTE : 0;
+	return { label: windowLabel(seconds), usedPercent: used, windowSeconds: seconds, resetAt: Number.isFinite(resetAt) ? resetAt * 1000 : null };
+}
+
+export function parseCodexHeaders(headers: Record<string, string>, now: number): ProviderUsage | undefined {
+	const windows = [headerWindow(headers, "primary", now), headerWindow(headers, "secondary", now)].filter((window): window is UsageWindow => window !== undefined);
+	if (windows.length === 0) return undefined;
+	const reached = headers[`${HEADER_PREFIX}rate-limit-reached-type`];
+	return { provider: CODEX_PROVIDER, plan: undefined, limits: [{ name: CODEX_MAIN_LIMIT, windows, limitReached: Boolean(reached) }], fetchedAt: now };
+}
+
+// Claude Pro/Max sends utilization as a 0..1 fraction per window and reset
+// times in Unix seconds on every response; there is no usage endpoint.
+export function parseAnthropicHeaders(headers: Record<string, string>, now: number): ProviderUsage | undefined {
+	const windows: UsageWindow[] = [];
+	for (const [key, seconds] of ANTHROPIC_WINDOWS) {
+		const fraction = Number.parseFloat(headers[`${ANTHROPIC_PREFIX}${key}-utilization`] ?? "");
+		if (!Number.isFinite(fraction)) continue;
+		const reset = Number.parseInt(headers[`${ANTHROPIC_PREFIX}${key}-reset`] ?? "", 10);
+		windows.push({ label: windowLabel(seconds), usedPercent: fraction * 100, windowSeconds: seconds, resetAt: Number.isFinite(reset) ? reset * 1000 : null });
+	}
+	if (windows.length === 0) return undefined;
+	const status = headers[`${ANTHROPIC_PREFIX}status`];
+	return { provider: ANTHROPIC_PROVIDER, plan: undefined, limits: [{ name: ANTHROPIC_MAIN_LIMIT, windows, limitReached: status === "rejected" }], fetchedAt: now };
+}
+
+export function parseUsageHeaders(headers: Record<string, string>, now: number): ProviderUsage | undefined {
+	return parseCodexHeaders(headers, now) ?? parseAnthropicHeaders(headers, now);
+}
+
+export function accountIdFromToken(token: string): string | undefined {
+	const parts = token.split(".");
+	if (parts.length !== 3) return undefined;
+	try {
+		const claims = JSON.parse(Buffer.from(parts[1], "base64url").toString("utf8")) as Record<string, unknown>;
+		const auth = claims[CODEX_ACCOUNT_CLAIM] as { chatgpt_account_id?: unknown } | undefined;
+		return typeof auth?.chatgpt_account_id === "string" && auth.chatgpt_account_id.length > 0 ? auth.chatgpt_account_id : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function paintMeter(percent: number, cells: number, theme: UsageTheme): string {
+	return paintGauge(percent, theme, cells);
+}
+
+export function renderUsageBar(usage: ProviderUsage, theme: UsageTheme): string | undefined {
+	const main = usage.limits[0];
+	const [first, ...rest] = main?.windows ?? [];
+	if (!first) return undefined;
+	const head = `${theme.fg(ROLE.LABEL, main.name)} ${theme.fg(ROLE.LABEL, first.label)} ${paintMeter(first.usedPercent, 8, theme)} ${theme.fg(ROLE.PERCENT, `${Math.round(first.usedPercent)}%`)}`;
+	const tail = rest.map((window) => `${theme.fg(ROLE.SEPARATOR, "·")} ${theme.fg(ROLE.LABEL, window.label)} ${theme.fg(ROLE.PERCENT, `${Math.round(window.usedPercent)}%`)}`);
+	return [head, ...tail].join(" ");
+}
+
+function updatedAgo(fetchedAt: number, now: number): string {
+	const minutes = Math.floor((now - fetchedAt) / 60_000);
+	return minutes < 1 ? "updated just now" : `updated ${minutes}m ago`;
+}
+
+// The active provider comes first, marked with the petal, and explains
+// itself when it has no data yet. Other providers seen this session follow.
+export function renderUsagePanel(usages: ProviderUsage[], theme: UsageTheme, width: number, now: number, active?: ActiveProvider): string[] {
+	const activeUsage = active ? usages.find((usage) => usage.provider === active.provider) : undefined;
+	const others = usages.filter((usage) => usage !== activeUsage);
+	if (!active && usages.length === 0) return [truncateToWidth(USAGE_EMPTY_MESSAGE, width, "…")];
+	const lines: string[] = [];
+	if (active && !activeUsage) {
+		lines.push(`${theme.fg(ROLE.LIMIT, ACTIVE_MARK)} ${theme.fg(ROLE.PROVIDER, active.provider)} ${theme.fg(ROLE.SEPARATOR, "·")} ${theme.fg(ROLE.RESET, providerNote(active.provider))}`);
+	}
+	for (const usage of [...(activeUsage ? [activeUsage] : []), ...others]) {
+		const mark = usage === activeUsage ? `${theme.fg(ROLE.LIMIT, ACTIVE_MARK)} ` : "";
+		const plan = usage.plan ? ` ${theme.fg(ROLE.SEPARATOR, "·")} ${theme.fg(ROLE.PLAN, usage.plan)}` : "";
+		lines.push(`${mark}${theme.fg(ROLE.PROVIDER, usage.provider)}${plan} ${theme.fg(ROLE.SEPARATOR, "·")} ${theme.fg(ROLE.RESET, updatedAgo(usage.fetchedAt, now))}`);
+		for (const limit of usage.limits) {
+			lines.push(`  ${theme.fg(ROLE.LIMIT, limit.name)}`);
+			for (const window of limit.windows) {
+				const percent = `${Math.round(window.usedPercent)}%`.padStart(4);
+				lines.push(`    ${theme.fg(ROLE.LABEL, window.label.padEnd(5))} ${paintMeter(window.usedPercent, PANEL_METER_CELLS, theme)} ${theme.fg(ROLE.PERCENT, percent)}  ${theme.fg(ROLE.RESET, formatReset(window.resetAt, now))}`);
+			}
+		}
+	}
+	return lines.map((line) => truncateToWidth(line, width, "…"));
+}
+
+export class UsageStore {
+	private readonly usages = new Map<string, ProviderUsage>();
+
+	record(usage: ProviderUsage): void {
+		this.usages.set(usage.provider, usage);
+	}
+
+	get(provider: string): ProviderUsage | undefined {
+		return this.usages.get(provider);
+	}
+
+	all(): ProviderUsage[] {
+		return [...this.usages.values()];
+	}
+}