@hank-warren/pi-statusline 0.7.3 → 0.9.0

package/index.ts

@@ -14,16 +14,20 @@ import {
 } from "./cache-celebration.ts";
 import { CelebrationPreview, trackSelectedLabel } from "./celebration-preview.ts";
 import { DEFAULT_CELEBRATION_STYLE, renderCacheBadge } from "./celebration-styles.ts";
+import { CustomItemsTracker } from "./custom.ts";
+import { buildCustomItemSetupPrompt } from "./custom-setup.ts";
 import { FullRedrawScheduler } from "./redraw.ts";
 import {
 	applySettingChange,
 	buildSettingItems,
 	CACHE_CELEBRATION_LABEL,
 	createAliasSubmenu,
+	createCustomItemsSubmenu,
 	createWorktreeRootSubmenu,
 } from "./settings-menu.ts";
 import {
 	changedSettingKeys,
+	collapseHome,
 	defaultSettings,
 	repoAlias,
 	SettingsStore,
@@ -40,6 +44,8 @@ import {
 
 export interface StatuslineData {
 	model: string;
+	/** Thinking level of the active model; absent when the model cannot reason. */
+	thinkingLevel?: string;
 	/** Provider id of the active model; absent when there is no model. */
 	provider?: string;
 	cwd: string;
@@ -50,6 +56,8 @@ export interface StatuslineData {
 	sessionId: string;
 	cacheCelebration?: CacheCelebrationSnapshot;
 	usage?: UsageSnapshot;
+	/** Rendered output of each enabled custom item, in configuration order. */
+	customValues?: string[];
 }
 
 const RESET = "\x1b[0m";
@@ -177,8 +185,18 @@ export function renderStatusline(
 					formatTokenCount(data.contextTokens),
 				);
 	const usageSegment = settings.showUsage && data.usage ? renderUsageSegment(data.usage, palette) : undefined;
+	// Custom items own their own colours, so they are passed through unstyled;
+	// they sit after the usage meters, which is where the built-in segments stop
+	// and anything the user added begins.
+	const customSegments = settings.showCustomItems ? (data.customValues ?? []).filter((value) => value.length > 0) : [];
 	const segments = [
 		settings.showModel ? styled(palette.model, data.model) : undefined,
+		// A non-reasoning model has no level to show, so the segment goes with it.
+		// "off" on a reasoning model is a real state and reads as pi's own footer
+		// spells it, because a bare "off" between two ids means nothing.
+		settings.showThinking && data.thinkingLevel
+			? styled(palette.thinking, data.thinkingLevel === "off" ? "thinking off" : data.thinkingLevel)
+			: undefined,
 		// No provider is a missing segment, not a placeholder: the model id already
 		// says "no-model" in that state, and a second one would only add noise.
 		settings.showProvider && data.provider ? styled(palette.provider, data.provider) : undefined,
@@ -191,6 +209,7 @@ export function renderStatusline(
 			? `${used}${styled(palette.dim, "/")}${styled(palette.text, formatTokenCount(data.contextWindow))}`
 			: undefined,
 		usageSegment,
+		...customSegments,
 	].filter((segment): segment is string => segment !== undefined);
 
 	const showWorktreeLine = settings.showWorktrees && data.worktrees.length > 0;
@@ -227,6 +246,7 @@ export default function statuslineExtension(pi: ExtensionAPI): void {
 	const cacheCelebration = new CacheCelebrationController(() => requestRender?.());
 	let tracker: SessionWorktreeTracker | undefined;
 	const usageTracker = new UsageTracker({ onChange: () => requestRender?.() });
+	const customItems = new CustomItemsTracker({ onChange: () => requestRender?.() });
 	let cwdGit: GitRepositoryStatus | null = null;
 	let cwdStatusAbort: AbortController | undefined;
 	let cwdStatusInFlight: Promise<void> | undefined;
@@ -267,6 +287,48 @@ export default function statuslineExtension(pi: ExtensionAPI): void {
 		return refresh;
 	};
 
+	/**
+	 * The JSON handed to every custom command on stdin.
+	 *
+	 * Field names follow Claude Code's statusline payload where the two agents
+	 * describe the same thing, so a script written for it needs no rewrite. The
+	 * exception is deliberate: pi's meters are *remaining* headroom, the inverse
+	 * of Claude Code's `rate_limits.*.used_percentage`, so those fields live
+	 * under `usage_remaining` where a ported script cannot read them by accident.
+	 */
+	const customPayload = (ctx: ExtensionContext): Record<string, unknown> => {
+		const context = ctx.getContextUsage();
+		const window = context?.contextWindow ?? ctx.model?.contextWindow ?? 0;
+		const tokens = context?.tokens ?? null;
+		const usage = usageTracker.snapshot();
+		return {
+			version: 1,
+			session_id: ctx.sessionManager.getSessionId(),
+			cwd: ctx.cwd,
+			model: { id: ctx.model?.id ?? null, provider: ctx.model?.provider ?? null },
+			git: cwdGit
+				? { branch: cwdGit.branch, dirty: cwdGit.dirty, behind: cwdGit.behind }
+				: null,
+			context_window: {
+				used_tokens: tokens,
+				context_window_size: window,
+				used_percentage: tokens !== null && window > 0 ? Math.round((tokens * 100) / window) : null,
+			},
+			usage_remaining: {
+				claude: usage.claude
+					? {
+							five_hour: usage.claude.fiveHour,
+							seven_day: usage.claude.sevenDay,
+							scoped_weekly: usage.claude.scopedWeekly ?? null,
+						}
+					: null,
+				codex: usage.codex
+					? { five_hour: usage.codex.fiveHour ?? null, weekly: usage.codex.weekly ?? null }
+					: null,
+			},
+		};
+	};
+
 	const resetTracker = (ctx: ExtensionContext): void => {
 		tracker?.dispose();
 		tracker = undefined;
@@ -279,6 +341,9 @@ export default function statuslineExtension(pi: ExtensionAPI): void {
 			usageTracker.setActiveProvider(ctx.model?.provider);
 			runInBackground(usageTracker.refresh());
 		}
+		customItems.setContext({ cwd: ctx.cwd });
+		customItems.setPayloadFactory(() => customPayload(ctx));
+		if (settings.showCustomItems) customItems.refresh();
 		// A hidden worktree line must not pay for git/gh polling.
 		if (!settings.showWorktrees) return;
 		const next = new SessionWorktreeTracker({
@@ -298,6 +363,18 @@ export default function statuslineExtension(pi: ExtensionAPI): void {
 		settings = next;
 		settingsStore.set(next);
 
+		// Items are adopted before the visibility check so a disabled segment
+		// still shows current config in the submenu; nothing runs while it is off.
+		customItems.setItems(next.customItems);
+		if (next.showCustomItems) {
+			customItems.restartTimer();
+			customItems.start();
+			customItems.refresh();
+		} else if (previous.showCustomItems) {
+			// A hidden segment must not keep spawning commands, matching usage above.
+			customItems.stop();
+		}
+
 		if (!next.showWorktrees) {
 			tracker?.dispose();
 			tracker = undefined;
@@ -347,6 +424,16 @@ export default function statuslineExtension(pi: ExtensionAPI): void {
 				const settingsTheme = tracked.theme;
 				const submenuHost = {
 					getSettings: () => settings,
+					customItemStates: () => customItems.states(),
+					// The contract reaches the agent as a user message, sent when the
+					// menu asks for it. This is the whole reason there is no skill: the
+					// text costs nothing until someone wants an item, and a message from
+					// the menu is discoverable exactly where the feature is.
+					requestCustomItem: (request: string) => {
+						const prompt = buildCustomItemSetupPrompt(collapseHome(settingsStore.getPath(), home), request);
+						if (ctx.isIdle()) pi.sendUserMessage(prompt);
+						else pi.sendUserMessage(prompt, { deliverAs: "followUp" });
+					},
 					commit: (next: StatuslineSettings) => applySettings(ctx, next),
 					notify: (message: string) => ctx.ui.notify(message, "warning"),
 					requestRender: () => tui.requestRender(),
@@ -360,6 +447,7 @@ export default function statuslineExtension(pi: ExtensionAPI): void {
 						{
 							worktreeRoot: createWorktreeRootSubmenu(submenuHost),
 							repoAliases: createAliasSubmenu(submenuHost),
+							customItems: createCustomItemsSubmenu(submenuHost),
 						},
 						home,
 					),
@@ -416,6 +504,7 @@ export default function statuslineExtension(pi: ExtensionAPI): void {
 			// still needs them to move, and a sibling process's poll is worth adopting
 			// before the next turn ends.
 			if (settings.showUsage) usageTracker.start();
+			if (settings.showCustomItems) customItems.start();
 			const stopBranchUpdates = footerData.onBranchChange(() => {
 				runInBackground(refreshCwdStatus(ctx));
 				tui.requestRender();
@@ -428,6 +517,7 @@ export default function statuslineExtension(pi: ExtensionAPI): void {
 					celebrationPreview.dispose();
 					fullRedraw.detach();
 					usageTracker.stop();
+					customItems.dispose();
 					requestRender = undefined;
 				},
 				invalidate(): void {},
@@ -435,11 +525,18 @@ export default function statuslineExtension(pi: ExtensionAPI): void {
 					const usage = ctx.getContextUsage();
 					const cwd = basename(ctx.cwd) || ctx.cwd;
 					const model = ctx.model?.id.split("/").pop() || "no-model";
+					// ctx.thinkingLevel is a live getter on the session; the pi accessor is
+					// the same value for hosts whose context does not expose it.
+					const thinkingLevel = ctx.model?.reasoning ? (ctx.thinkingLevel ?? pi.getThinkingLevel()) : undefined;
+					// Commands size themselves with COLUMNS, so the tracker needs the
+					// width the footer is actually being drawn at.
+					customItems.setContext({ columns: width });
 
 					return fullRedraw.decorate(
 						renderStatusline(
 							{
 								model,
+								thinkingLevel,
 								provider: ctx.model?.provider,
 								cwd,
 								cwdGit,
@@ -449,6 +546,7 @@ export default function statuslineExtension(pi: ExtensionAPI): void {
 								sessionId: ctx.sessionManager.getSessionId(),
 								cacheCelebration: celebrationPreview.snapshot() ?? cacheCelebration.snapshot(),
 								usage: usageTracker.snapshot(),
+								customValues: customItems.values(),
 							},
 							width,
 							settings,
@@ -476,6 +574,9 @@ export default function statuslineExtension(pi: ExtensionAPI): void {
 			usageTracker.setActiveProvider(ctx.model?.provider);
 			runInBackground(usageTracker.refresh());
 		}
+		// Turn end is the event-driven trigger, mirroring how Claude Code re-runs a
+		// statusline command when a new assistant message arrives.
+		if (settings.showCustomItems) customItems.refresh();
 	});
 	// The meters follow the main model's account, so a switch between two logins
 	// of the same provider family has to re-point the tracker before it repaints.
@@ -486,11 +587,15 @@ export default function statuslineExtension(pi: ExtensionAPI): void {
 		}
 		requestRender?.();
 	});
+	// The cycle keybinding (Shift+Tab by default) changes the level without a
+	// turn or a model change, so nothing else would repaint the segment.
+	pi.on("thinking_level_select", () => requestRender?.());
 	pi.on("session_tree", (_event, ctx) => resetTracker(ctx));
 	pi.on("session_shutdown", () => {
 		cacheCelebration.dispose();
 		fullRedraw.detach();
 		usageTracker.stop();
+		customItems.dispose();
 		tracker?.dispose();
 		tracker = undefined;
 		cwdStatusAbort?.abort();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hank-warren/pi-statusline",
-  "version": "0.7.3",
+  "version": "0.9.0",
   "description": "Compact Pi footer statusline with Git/worktree context, token usage, and neon celebrations for exceptional prompt-cache hits.",
   "type": "module",
   "keywords": [
@@ -35,6 +35,8 @@
     "cache-celebration.ts",
     "celebration-preview.ts",
     "celebration-styles.ts",
+    "custom.ts",
+    "custom-setup.ts",
     "redraw.ts",
     "settings.ts",
     "settings-menu.ts",

package/settings-menu.ts

@@ -10,6 +10,7 @@ import {
 	truncateToWidth,
 } from "@earendil-works/pi-tui";
 import { type BooleanSettingKey, collapseHome, resolveWorktreeRoot, type StatuslineSettings } from "./settings.ts";
+import type { CustomItemState } from "./custom.ts";
 import { CELEBRATION_STYLE_NAMES, isCelebrationStyleName } from "./celebration-styles.ts";
 import { isThemeName, THEME_NAMES } from "./themes.ts";
 
@@ -17,7 +18,9 @@ export const THEME_ID = "theme";
 export const CACHE_CELEBRATION_ID = "showCacheCelebration";
 export const WORKTREE_ROOT_ID = "worktreeRoot";
 export const REPO_ALIASES_ID = "repoAliases";
+export const CUSTOM_ITEMS_ID = "customItems";
 export const ADD_ALIAS_VALUE = "\u0000add";
+export const ADD_CUSTOM_ITEM_VALUE = "\u0000add-item";
 
 export const ON = "on";
 export const OFF = "off";
@@ -32,10 +35,12 @@ interface BooleanRow {
 /** Toggle rows, in statusline render order. */
 export const BOOLEAN_ROWS: readonly BooleanRow[] = [
 	{ id: "showModel", label: "Model", description: "Show the active model id." },
+	{ id: "showThinking", label: "Thinking level", description: "Show the thinking level of the active model." },
 	{ id: "showProvider", label: "Provider", description: "Show the provider of the active model." },
 	{ id: "showDirectory", label: "Directory & git", description: "Show the working directory and its git branch." },
 	{ id: "showContext", label: "Context", description: "Show context tokens used against the window." },
 	{ id: "showUsage", label: "Subscription usage", description: "Show Claude/Codex remaining-headroom meters." },
+	{ id: "showCustomItems", label: "Custom items", description: "Run your configured commands and show their output." },
 	{ id: "showWorktrees", label: "Worktree line", description: "Show touched worktrees and their pull requests." },
 	{ id: "showSessionId", label: "Session ID line", description: "Show the full Pi session id on its own line." },
 ];
@@ -57,9 +62,67 @@ export function aliasSummary(settings: StatuslineSettings): string {
 	return `${count} alias${count === 1 ? "" : "es"}`;
 }
 
+/** Row value for the custom-items submenu: how many items are switched on. */
+export function customItemsSummary(settings: StatuslineSettings): string {
+	const total = settings.customItems.length;
+	if (total === 0) return "none configured";
+	return `${settings.customItems.filter((item) => item.enabled).length}/${total} on`;
+}
+
+/**
+ * Rows in the custom-items submenu: each item, what it shows and why, then the
+ * one action that creates an item. Adding hands the job to the agent rather
+ * than opening a form: a statusline command is a script plus a JSON entry plus
+ * a test run, which is a conversation, not a field.
+ */
+export function customItemRows(
+	settings: StatuslineSettings,
+	states: readonly CustomItemState[] = [],
+): SelectItem[] {
+	return [
+		...customItemStateRows(settings, states),
+		{
+			value: ADD_CUSTOM_ITEM_VALUE,
+			label: "Add custom item…",
+			description: "Ask the agent to write one; it gets the contract and the settings path.",
+		},
+	];
+}
+
+function customItemStateRows(settings: StatuslineSettings, states: readonly CustomItemState[]): SelectItem[] {
+	const byId = new Map(states.map((state) => [state.id, state]));
+	return settings.customItems.map((item) => {
+		const state = byId.get(item.id);
+		// Configuration errors outrank run errors: an item that cannot be parsed
+		// never ran, so a stale run error from a previous config would mislead.
+		const error = item.error ?? state?.error;
+		// A broken entry reads as "disabled" unless its reason wins here: it is off
+		// *because* it cannot run, and "disabled" would suggest the user chose that.
+		const detail = item.error !== undefined
+			? item.error
+			: !item.enabled
+				? "disabled"
+				: error !== undefined
+				? error
+				: state?.running === true && state.value === undefined
+					? "running…"
+					: state?.value !== undefined && state.value.length > 0
+						? state.value
+						: state?.value !== undefined
+							? "empty output"
+							: "no value yet";
+		return {
+			value: item.id,
+			label: `${item.enabled ? toggleValue(true) : toggleValue(false)}  ${item.id}`,
+			description: detail,
+		};
+	});
+}
+
 export interface SettingSubmenus {
 	worktreeRoot?: SettingItem["submenu"];
 	repoAliases?: SettingItem["submenu"];
+	customItems?: SettingItem["submenu"];
 }
 
 /** Build the `/statusline` rows for a settings snapshot. */
@@ -81,6 +144,10 @@ export function buildSettingItems(
 	// Rows follow the order their elements render in, so the celebration sits
 	// after the usage meters it is appended to on line 1.
 	for (const row of BOOLEAN_ROWS) {
+		// A toggle for a segment with nothing in it is a row that does nothing;
+		// the list row below is where an item gets created, and the toggle
+		// appears once there is something to switch off.
+		if (row.id === "showCustomItems" && settings.customItems.length === 0) continue;
 		items.push({
 			id: row.id,
 			label: row.label,
@@ -113,6 +180,13 @@ export function buildSettingItems(
 		currentValue: aliasSummary(settings),
 		...(submenus.repoAliases ? { submenu: submenus.repoAliases } : {}),
 	});
+	items.push({
+		id: CUSTOM_ITEMS_ID,
+		label: "Custom item list",
+		description: "Enable or disable configured items; edit commands in statusline-settings.json.",
+		currentValue: customItemsSummary(settings),
+		...(submenus.customItems ? { submenu: submenus.customItems } : {}),
+	});
 
 	return items;
 }
@@ -183,6 +257,13 @@ export function aliasItems(settings: StatuslineSettings): SelectItem[] {
 export interface SubmenuHost {
 	/** Read the live settings; the menu edits a single shared snapshot. */
 	getSettings(): StatuslineSettings;
+	/** Live per-item run state, for the custom-items submenu. */
+	customItemStates?(): CustomItemState[];
+	/**
+	 * Hand "add an item" to the agent with the user's one-line description of
+	 * what it should show. Closes the menu; absent when no agent can be reached.
+	 */
+	requestCustomItem?(request: string): void;
 	/** Commit an edit: persists, applies live, and repaints. */
 	commit(settings: StatuslineSettings): void;
 	notify(message: string): void;
@@ -348,3 +429,99 @@ class AliasSubmenu implements Component {
 export function createAliasSubmenu(host: SubmenuHost): NonNullable<SettingItem["submenu"]> {
 	return (_currentValue, done) => new AliasSubmenu(host, done);
 }
+
+/**
+ * Custom item list: enable/disable each item and read why it is not showing.
+ *
+ * Commands are edited in the settings file, not here. A statusline command is a
+ * shell line with quoting and pipes in it, which a single-line TUI prompt edits
+ * badly, and keeping the field out of the menu means a toggle writes only the
+ * `enabled` flag over whatever the file currently holds.
+ */
+class CustomItemsSubmenu implements Component {
+	private list: SelectList;
+	private prompt: PromptComponent | undefined;
+
+	constructor(
+		private readonly host: SubmenuHost,
+		private readonly done: (value?: string) => void,
+	) {
+		this.list = this.buildList();
+	}
+
+	private buildList(selectedIndex = 0): SelectList {
+		const rows = customItemRows(this.host.getSettings(), this.host.customItemStates?.() ?? []);
+		const list = new SelectList(rows, 10, this.host.selectTheme);
+		list.setSelectedIndex(selectedIndex);
+		list.onCancel = () => this.done(customItemsSummary(this.host.getSettings()));
+		list.onSelect = (item) => (item.value === ADD_CUSTOM_ITEM_VALUE ? this.add() : this.toggle(item.value));
+		return list;
+	}
+
+	private add(): void {
+		if (!this.host.requestCustomItem) {
+			this.host.notify("Add items to statusline-settings.json; see the pi-statusline README");
+			return;
+		}
+		this.prompt = new PromptComponent(
+			"What should the item show? (Enter for the agent to ask)",
+			"",
+			this.host.settingsTheme.hint,
+			(value) => {
+				this.prompt = undefined;
+				// Close the whole menu before the message lands: the agent's reply
+				// renders in the transcript, which the menu is drawn over.
+				this.done(customItemsSummary(this.host.getSettings()));
+				this.host.requestCustomItem?.(value);
+			},
+			() => {
+				this.prompt = undefined;
+				this.host.requestRender();
+			},
+		);
+		this.host.requestRender();
+	}
+
+	private toggle(id: string): void {
+		if (id.startsWith("\u0000")) return;
+		const settings = this.host.getSettings();
+		const index = settings.customItems.findIndex((item) => item.id === id);
+		const target = settings.customItems[index];
+		if (!target) return;
+		if (target.error !== undefined && !target.enabled) {
+			// Enabling an unparseable entry would only fail again on the next tick.
+			this.host.notify(`${id} cannot run: ${target.error}`);
+			return;
+		}
+		const customItems = [...settings.customItems];
+		customItems[index] = { ...target, enabled: !target.enabled };
+		this.host.commit({ ...settings, customItems });
+		this.list = this.buildList(index);
+		this.host.requestRender();
+	}
+
+	invalidate(): void {
+		this.prompt?.invalidate();
+		this.list.invalidate();
+	}
+
+	render(width: number): string[] {
+		if (this.prompt) return this.prompt.render(width);
+		return [
+			truncateToWidth(this.host.settingsTheme.hint("  Custom items"), width),
+			"",
+			...this.list.render(width),
+			"",
+			truncateToWidth(this.host.settingsTheme.hint("  Enter to enable/disable or add · Esc to go back"), width),
+		];
+	}
+
+	handleInput(data: string): void {
+		if (this.prompt) this.prompt.handleInput(data);
+		else this.list.handleInput(data);
+	}
+}
+
+export function createCustomItemsSubmenu(host: SubmenuHost): NonNullable<SettingItem["submenu"]> {
+	return (_currentValue, done) => new CustomItemsSubmenu(host, done);
+}

package/settings.ts

@@ -8,15 +8,23 @@ import {
 	DEFAULT_CELEBRATION_STYLE,
 	isCelebrationStyleName,
 } from "./celebration-styles.ts";
+import {
+	type CustomItem,
+	normalizeCustomItems,
+	sameCustomItems,
+	serializeCustomItems,
+} from "./custom.ts";
 import { DEFAULT_THEME, isThemeName, type StatuslineThemeName } from "./themes.ts";
 
 /** Toggle keys, in the order the `/statusline` menu lists them. */
 export const BOOLEAN_SETTING_KEYS = [
 	"showModel",
+	"showThinking",
 	"showProvider",
 	"showDirectory",
 	"showContext",
 	"showUsage",
+	"showCustomItems",
 	"showWorktrees",
 	"showSessionId",
 	"showCacheCelebration",
@@ -33,6 +41,8 @@ export interface StatuslineSettings extends Record<BooleanSettingKey, boolean> {
 	worktreeRoot: string;
 	/** `repository name -> display alias` overrides for the worktree line. */
 	repoAliases: Record<string, string>;
+	/** User-defined command segments rendered after the usage meters. */
+	customItems: CustomItem[];
 }
 
 function defaultWorktreeRoot(home: string = homedir()): string {
@@ -42,11 +52,17 @@ function defaultWorktreeRoot(home: string = homedir()): string {
 export function defaultSettings(home: string = homedir()): StatuslineSettings {
 	return {
 		showModel: true,
+		// Opt-in: an extra segment on every existing footer would be a surprise,
+		// and most sessions keep one thinking level for their whole life.
+		showThinking: false,
 		// Opt-in: the provider is redundant for anyone with a single login per family.
 		showProvider: false,
 		showDirectory: true,
 		showContext: true,
 		showUsage: true,
+		// On by default and free until the user configures an item: with an empty
+		// list nothing renders, nothing is spawned, and no timer runs.
+		showCustomItems: true,
 		showWorktrees: true,
 		showSessionId: true,
 		showCacheCelebration: true,
@@ -54,6 +70,7 @@ export function defaultSettings(home: string = homedir()): StatuslineSettings {
 		cacheCelebrationStyle: DEFAULT_CELEBRATION_STYLE,
 		worktreeRoot: defaultWorktreeRoot(home),
 		repoAliases: {},
+		customItems: [],
 	};
 }
 
@@ -140,6 +157,7 @@ export function normalizeSettings(value: unknown, home: string = homedir()): Nor
 		"cacheCelebrationStyle",
 		"worktreeRoot",
 		"repoAliases",
+		"customItems",
 	]);
 	for (const [key, raw] of Object.entries(value)) {
 		if (!known.has(key)) {
@@ -158,6 +176,12 @@ export function normalizeSettings(value: unknown, home: string = homedir()): Nor
 			if (aliases) settings.repoAliases = aliases;
 			continue;
 		}
+		if (key === "customItems") {
+			// Unusable entries come back as items carrying their parse error rather
+			// than being dropped, so a write cannot delete what it failed to read.
+			settings.customItems = normalizeCustomItems(raw);
+			continue;
+		}
 		if (key === "theme") {
 			if (isThemeName(raw)) settings.theme = raw;
 			continue;
@@ -185,6 +209,7 @@ export const SETTING_KEYS = [
 	"cacheCelebrationStyle",
 	"worktreeRoot",
 	"repoAliases",
+	"customItems",
 ] as const satisfies readonly (keyof StatuslineSettings)[];
 
 export type SettingKey = (typeof SETTING_KEYS)[number];
@@ -205,11 +230,11 @@ export function changedSettingKeys(
 	previous: StatuslineSettings,
 	next: StatuslineSettings,
 ): SettingKey[] {
-	return SETTING_KEYS.filter((key) =>
-		key === "repoAliases"
-			? !sameAliases(previous.repoAliases, next.repoAliases)
-			: previous[key] !== next[key],
-	);
+	return SETTING_KEYS.filter((key) => {
+		if (key === "repoAliases") return !sameAliases(previous.repoAliases, next.repoAliases);
+		if (key === "customItems") return !sameCustomItems(previous.customItems, next.customItems);
+		return previous[key] !== next[key];
+	});
 }
 
 /**
@@ -232,6 +257,9 @@ export function serializeSettings(
 	}
 	if (settings.worktreeRoot !== defaults.worktreeRoot) out.worktreeRoot = settings.worktreeRoot;
 	if (!sameAliases(settings.repoAliases, defaults.repoAliases)) out.repoAliases = { ...settings.repoAliases };
+	// An empty list is the default and stays out of the file; a configured one is
+	// written back from each entry's original source object.
+	if (settings.customItems.length > 0) out.customItems = serializeCustomItems(settings.customItems);
 	return out;
 }
 

package/themes.ts

@@ -5,6 +5,8 @@
 export interface StatuslinePalette {
 	/** Active model id. */
 	model: string;
+	/** Thinking level of the active model. */
+	thinking: string;
 	/** Provider id of the active model. */
 	provider: string;
 	/** Repository and directory names. */
@@ -37,6 +39,7 @@ const rgb = (hex: string): string => {
 /** The palette this package shipped before themes existed. */
 const DEFAULT: StatuslinePalette = {
 	model: rgb("#0099ff"),
+	thinking: rgb("#5fb0ff"),
 	provider: rgb("#7aa2c8"),
 	path: rgb("#dcdcdc"),
 	branch: rgb("#56b6c2"),
@@ -53,6 +56,7 @@ const DEFAULT: StatuslinePalette = {
 /** Dracula, with the pink branch colour from Hank's Herdr sidebar config. */
 const DRACULA: StatuslinePalette = {
 	model: rgb("#bd93f9"),
+	thinking: rgb("#a98ae0"),
 	provider: rgb("#9580c9"),
 	path: rgb("#f8f8f2"),
 	branch: rgb("#ff79c6"),
@@ -68,6 +72,7 @@ const DRACULA: StatuslinePalette = {
 
 const GITHUB_DARK: StatuslinePalette = {
 	model: rgb("#58a6ff"),
+	thinking: rgb("#6399db"),
 	provider: rgb("#6e8bb5"),
 	path: rgb("#c9d1d9"),
 	branch: rgb("#39c5cf"),
@@ -83,6 +88,7 @@ const GITHUB_DARK: StatuslinePalette = {
 
 const CATPPUCCIN_MOCHA: StatuslinePalette = {
 	model: rgb("#cba6f7"),
+	thinking: rgb("#b89adf"),
 	provider: rgb("#a58fc4"),
 	path: rgb("#cdd6f4"),
 	branch: rgb("#89dceb"),
@@ -99,6 +105,7 @@ const CATPPUCCIN_MOCHA: StatuslinePalette = {
 /** No colour at all: white text, dimmed punctuation, a grey badge flash. */
 const WHITE: StatuslinePalette = {
 	model: rgb("#ffffff"),
+	thinking: rgb("#ffffff"),
 	provider: rgb("#ffffff"),
 	path: rgb("#ffffff"),
 	branch: rgb("#ffffff"),