@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/pi-zentui/test/footer-hidden.test.ts

@@ -0,0 +1,312 @@
+import { stripVTControlCharacters } from "node:util";
+import type { ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { describe, expect, it, vi } from "vitest";
+import { mergeConfig } from "../extensions/zentui/config";
+import { installHiddenFooter } from "../extensions/zentui/footer";
+
+function setup(raw: unknown = {}) {
+	const config = mergeConfig(raw);
+	const statuses = new Map<string, string>();
+	const theme = { fg: (_: string, text: string) => `\x1b[90m${text}\x1b[39m` } as Theme;
+	const requestRender = vi.fn();
+	const onBranchChange = vi.fn();
+	const hooks = {
+		setRequestRender: vi.fn(),
+		setExtensionStatusesGetter: vi.fn(),
+		onDispose: vi.fn(),
+	};
+	let factory: Parameters<ExtensionContext["ui"]["setFooter"]>[0];
+	const setFooter = vi.fn((value: typeof factory) => {
+		factory = value;
+	});
+	installHiddenFooter(
+		{ ui: { setFooter } } as unknown as ExtensionContext,
+		() => config.components.extensionStatuses,
+		hooks,
+	);
+	const component = factory?.({ requestRender } as never, theme, {
+		getExtensionStatuses: () => statuses,
+		onBranchChange,
+	} as never);
+	if (!component) throw new Error("Hidden factory missing");
+	return { config, statuses, theme, requestRender, onBranchChange, hooks, setFooter, component };
+}
+
+describe("Hidden footer status-only presentation", () => {
+	it("has no empty row for absent, empty, control-only or globally/per-key hidden statuses", () => {
+		const h = setup();
+		expect(h.component.render(80)).toEqual([]);
+		h.statuses.set("empty", " \n\t ");
+		h.statuses.set("controls", "\x1b[31m\x1b[0m\x1b]0;title\x07\x00");
+		expect(h.component.render(80)).toEqual([]);
+		h.statuses.set("active", "ACTIVE");
+		h.config.components.extensionStatuses.defaultVisibility = "hide";
+		expect(h.component.render(80)).toEqual([]);
+		h.config.components.extensionStatuses.visibility.active = "show";
+		expect(h.component.render(80)).toEqual(["ACTIVE"]);
+		h.config.components.extensionStatuses.defaultVisibility = "show";
+		h.config.components.extensionStatuses.visibility.active = "hide";
+		expect(h.component.render(80)).toEqual([]);
+		h.component.dispose?.();
+	});
+
+	it.each([
+		{ extensionStatuses: { defaultPlacement: "off", placements: { a: "off" } } },
+		{
+			components: {
+				footer: {
+					styles: {
+						starship: {
+							extensionStatuses: {
+								defaultPlacement: "off",
+								placements: { a: "off" },
+								colorModes: { a: "zentui" },
+							},
+						},
+					},
+				},
+			},
+		},
+	])("ignores legacy/local Starship placement and colors, preserving native key order", (raw) => {
+		const h = setup(raw);
+		h.statuses.set("Z", "LAST");
+		h.statuses.set("a", "\x1b[31mFIRST\x1b[0m");
+		expect(h.component.render(80)).toEqual(["\x1b[31mFIRST\x1b[0m LAST"]);
+		h.component.dispose?.();
+	});
+
+	it("matches native whitespace, ANSI colors, Unicode cropping and dim ellipsis at narrow widths", () => {
+		const h = setup();
+		const text = "\x1b[32m界 e\u0301 👩‍💻\x1b[0m\n\t  ready\r now";
+		h.statuses.set("x", text);
+		const nativeText = text
+			.replace(/[\r\n\t]/g, " ")
+			.replace(/ +/g, " ")
+			.trim();
+		for (const width of [1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 18, 80]) {
+			const rows = h.component.render(width);
+			expect(rows).toHaveLength(1);
+			expect(rows[0].replace(/\x1b\[0m$/, "")).toBe(
+				truncateToWidth(nativeText, width, h.theme.fg("dim", "...")).replace(/\x1b\[0m$/, ""),
+			);
+			expect(visibleWidth(rows[0])).toBeLessThanOrEqual(width);
+			expect(rows[0]).not.toMatch(/[\r\n\t]/);
+		}
+		expect(h.component.render(0)).toEqual([]);
+		expect(h.component.render(-1)).toEqual([]);
+		h.statuses.set("x", "SYNC ready");
+		expect(stripVTControlCharacters(h.component.render(8)[0])).toBe("SYNC ...");
+		h.component.dispose?.();
+	});
+
+	it("removes unsafe terminal controls while preserving safe styles and closed HTTP links", () => {
+		const h = setup();
+		h.statuses.set(
+			"x",
+			"\x1b]0;TITLE\x07\x1b]52;c;CLIPBOARD\x07\x1b[2J\x00\x07\x1b[35mOK\x1b[0m\t\x1b]8;;https://example.com\x07LINK",
+		);
+		expect(h.component.render(80)).toEqual([
+			"\x1b[35mOK\x1b[0m \x1b]8;;https://example.com/\x07LINK\x1b]8;;\x07",
+		]);
+		for (const width of [1, 3, 5, 6, 7]) {
+			const row = h.component.render(width)[0];
+			expect(visibleWidth(row)).toBeLessThanOrEqual(width);
+			expect(row).not.toMatch(/TITLE|CLIPBOARD|\x1b\[2J|\x00/);
+			let active = false;
+			for (const match of row.matchAll(/\x1b\]8;;([^\x07]*)\x07/g)) active = Boolean(match[1]);
+			expect(active).toBe(false);
+		}
+		h.component.dispose?.();
+	});
+
+	it("applies Hidden Zentui color without changing source data, Original neighbors or placement", () => {
+		const h = setup({
+			colors: { extensionStatus: "yellow" },
+			components: {
+				extensionStatuses: {
+					hidden: { placements: { b: "right" }, colorModes: { a: "zentui" } },
+				},
+				footer: { colors: { extensionStatus: "red" }, colorSource: "terminal" },
+			},
+		});
+		const fg = vi.spyOn(h.theme, "fg");
+		const supplied = "\x1b[1;31;44m\x1b]8;;https://example.com\x07BUILD\x1b]8;;\x07\x1b[0m";
+		h.statuses.set("a", supplied);
+		h.statuses.set("b", "\x1b[36mTEST\x1b[0m");
+		expect(h.component.render(12)).toEqual(["\x1b[90mBUILD\x1b[39m\x1b[0m   \x1b[36mTEST\x1b[0m"]);
+		expect(fg).toHaveBeenCalledWith("muted", "BUILD");
+		expect(h.statuses.get("a")).toBe(supplied);
+		h.component.dispose?.();
+	});
+
+	it("keeps recolored Unicode statuses within bounds and resolves the current theme on each render", () => {
+		const h = setup({
+			components: { extensionStatuses: { hidden: { colorModes: { x: "zentui" } } } },
+		});
+		h.statuses.set("x", "\x1b[32m界 e\u0301 👩‍💻\x1b[0m ready");
+		for (let width = 1; width <= 30; width++) {
+			const row = h.component.render(width)[0];
+			expect(visibleWidth(row)).toBeLessThanOrEqual(width);
+			expect(row).not.toContain("\x1b[32m");
+			expect(row).not.toContain("�");
+		}
+		h.theme.fg = (color, text) => (color === "muted" ? `\x1b[95m${text}\x1b[39m` : text);
+		expect(h.component.render(80)[0]).toContain("\x1b[95m");
+		h.theme.fg = (color, text) => {
+			if (color === "muted") throw new Error("unsupported theme role");
+			return text;
+		};
+		expect(h.component.render(80)).toEqual(["界 e\u0301 👩‍💻 ready"]);
+		h.statuses.set("x", "\x1b[32m\x1b[0m");
+		expect(h.component.render(80)).toEqual([]);
+		h.component.dispose?.();
+	});
+
+	it("uses only the authorized factory, exposes live discovery/render callbacks and releases them", () => {
+		const h = setup();
+		expect(h.setFooter).toHaveBeenCalledTimes(1);
+		expect(h.onBranchChange).not.toHaveBeenCalled();
+		const getter = h.hooks.setExtensionStatusesGetter.mock.calls[0][0];
+		h.statuses.set("a", "LATEST");
+		expect(getter()).toBe(h.statuses);
+		h.hooks.setRequestRender.mock.calls[0][0]();
+		expect(h.requestRender).toHaveBeenCalledTimes(1);
+		h.component.invalidate();
+		expect(h.component.render(80)).toEqual(["LATEST"]);
+		h.component.dispose?.();
+		expect(h.hooks.setRequestRender).toHaveBeenLastCalledWith(undefined);
+		expect(h.hooks.setExtensionStatusesGetter).toHaveBeenLastCalledWith(undefined);
+		expect(h.hooks.onDispose).toHaveBeenCalledTimes(1);
+		expect(h.setFooter).toHaveBeenCalledTimes(1);
+	});
+});
+
+describe("Hidden extension status placement", () => {
+	it.each([
+		["left"],
+		["middle"],
+		["right"],
+		["left", "middle"],
+		["left", "right"],
+		["middle", "right"],
+		["left", "middle", "right"],
+	])("anchors short content for zones %j", (...active) => {
+		const h = setup({
+			components: {
+				extensionStatuses: {
+					hidden: {
+						placements: { left: "left", middle: "middle", right: "right" },
+					},
+				},
+			},
+		});
+		const labels = { left: "L", middle: "M", right: "R" };
+		const positions = { left: 0, middle: 10, right: 20 };
+		for (const key of active as (keyof typeof labels)[]) h.statuses.set(key, labels[key]);
+		const row = h.component.render(21)[0];
+		const expected = Array.from({ length: 21 }, () => " ");
+		for (const key of active as (keyof typeof labels)[]) expected[positions[key]] = labels[key];
+		expect(row).toBe(expected.join("").trimEnd());
+		h.component.dispose?.();
+	});
+
+	it("centers then clamps middle beside long edge content and fairly caps collisions", () => {
+		const h = setup({
+			components: {
+				extensionStatuses: {
+					hidden: {
+						placements: { l: "left", m: "middle", r: "right" },
+					},
+				},
+			},
+		});
+		h.statuses.set("l", "LONGLEFT");
+		h.statuses.set("m", "MID");
+		h.statuses.set("r", "R");
+		expect(h.component.render(15)).toEqual(["LONGLEFT MID  R"]);
+		h.statuses.set("l", "L");
+		h.statuses.set("r", "LONGRIGHT");
+		expect(h.component.render(15)).toEqual(["L MID LONGRIGHT"]);
+		h.statuses.set("l", "LONGLEFT");
+		h.statuses.set("r", "RIGHT");
+		expect(stripVTControlCharacters(h.component.render(11)[0])).toBe("... MID ...");
+		h.statuses.delete("m");
+		h.statuses.set("r", "R");
+		expect(h.component.render(12)).toEqual(["LONGLEFT   R"]);
+		h.component.dispose?.();
+	});
+
+	it("uses deterministic L/M/R fallback only when cells and gaps cannot fit", () => {
+		const h = setup({
+			components: {
+				extensionStatuses: {
+					hidden: {
+						placements: { l: "left", m: "middle", r: "right" },
+					},
+				},
+			},
+		});
+		for (const key of ["l", "m", "r"]) h.statuses.set(key, key.toUpperCase());
+		for (const [width, expected] of [
+			[1, "L"],
+			[2, "L"],
+			[3, "L M"],
+			[4, "L M"],
+			[5, "L M R"],
+		] as const) {
+			expect(h.component.render(width)).toEqual([expected]);
+		}
+		for (const width of [0, -1]) expect(h.component.render(width)).toEqual([]);
+		h.component.dispose?.();
+	});
+
+	it("preserves supplied colors and resets backgrounds/links before every padding and status boundary", () => {
+		const h = setup({
+			components: {
+				extensionStatuses: {
+					hidden: {
+						placements: { l: "left", m: "middle", r: "right" },
+					},
+				},
+			},
+		});
+		h.statuses.set("l", "\x1b[42mL");
+		h.statuses.set("m", "\x1b[36mM");
+		h.statuses.set("r", "\x1b[33m\x1b]8;;https://example.com\x07R");
+		expect(h.component.render(9)).toEqual([
+			"\x1b[42mL\x1b[0m   \x1b[36mM\x1b[0m   \x1b[33m\x1b]8;;https://example.com/\x07R\x1b]8;;\x07\x1b[0m",
+		]);
+		h.statuses.set("l2", "PLAIN");
+		expect(h.component.render(30)[0]).toContain("\x1b[42mL\x1b[0m PLAIN");
+		h.component.dispose?.();
+	});
+
+	it("bounds ANSI/Unicode zones at every width and retains key order within each zone", () => {
+		const h = setup({
+			components: {
+				extensionStatuses: {
+					hidden: {
+						defaultPlacement: "middle",
+						placements: { l: "left", r: "right" },
+					},
+				},
+			},
+		});
+		h.statuses.set("z", "LAST");
+		h.statuses.set("a", "FIRST");
+		expect(h.component.render(20)).toEqual(["     FIRST LAST"]);
+		h.statuses.set("l", "\x1b[41m界界界");
+		h.statuses.set("r", "\x1b[33m👩‍💻 e\u0301 󰀵");
+		for (let width = 1; width <= 60; width++) {
+			const rows = h.component.render(width);
+			expect(rows).toHaveLength(1);
+			expect(visibleWidth(rows[0])).toBeLessThanOrEqual(width);
+			expect(rows[0]).not.toMatch(/[\r\n\t]/);
+			expect(rows[0]).not.toContain("�");
+		}
+		h.config.components.extensionStatuses.defaultVisibility = "hide";
+		expect(h.component.render(30)).toEqual([]);
+		h.component.dispose?.();
+	});
+});

package/dist/extensions/pi-zentui/test/footer-hyperlink.test.ts

@@ -169,6 +169,28 @@ for (const host of ["installed", "legacy"] as const) {
 			},
 		);
 
+		it.each(["$extensions$fill RIGHT", "LEFT$fill$extensions$wrap_sep SUFFIX"])(
+			"closes compact zone links before padding and neighboring text: %s",
+			(compactFormat) => {
+				const config = structuredClone(defaultConfig);
+				const style = config.components.footer.styles.starship;
+				style.format = "force compact ".repeat(30);
+				style.responsive = true;
+				style.compactFormat = compactFormat;
+				style.extensionStatuses.colorModes.pr = "original";
+				for (const width of [5, 20, 40, 80]) {
+					const lines = renderFooter(config, new Map([["pr", link(longLabel)]]), width);
+					for (const line of lines) {
+						expect(visibleWidth(line)).toBeLessThanOrEqual(width);
+						const state = linkState(`${line}NEIGHBOR`);
+						expect(state.active).toBe(false);
+						expect(state.linked).toMatch(/^[a-z…]*$/);
+						expect(state.plain).toContain("NEIGHBOR");
+					}
+				}
+			},
+		);
+
 		it("closes links when compact omission truncates a previously joined row", () => {
 			const rows = packCompactChunks(
 				[

package/dist/extensions/pi-zentui/test/footer-layout.test.ts

@@ -5,6 +5,7 @@ import {
 	compactChunkBudget,
 	fullFooterFitsAligned,
 	packCompactChunks,
+	packCompactZones,
 	reflowFullFooter,
 } from "../extensions/zentui/footer-layout";
 
@@ -111,3 +112,82 @@ describe("responsive footer layout", () => {
 		).toBe(true);
 	});
 });
+
+describe("right-aligned footer zones", () => {
+	it("pads only the right-bearing row in both full reflow arrangements", () => {
+		expect(reflowFullFooter({ left: "LLLL", middle: "M", right: "R" }, 5, true)).toEqual([
+			"LLLL",
+			"  M R",
+		]);
+		expect(reflowFullFooter({ left: "L", middle: "MMMM", right: "RRRR" }, 6, true)).toEqual([
+			"L MMMM",
+			"  RRRR",
+		]);
+		expect(reflowFullFooter({ left: "L", middle: "M", right: "" }, 5, true)).toEqual(["L", "M"]);
+		expect(reflowFullFooter({ left: "", middle: "", right: "R" }, 5, true)).toEqual(["    R"]);
+	});
+	it("reserves separate metadata chunks before variable left budgets", () => {
+		const rows = packCompactZones(
+			[chunk("directory"), chunk("branch")],
+			[
+				chunk("gpt-6-astra"),
+				chunk("OpenAI", "separator"),
+				chunk("high", "separator"),
+				chunk("telemetry", "separator"),
+			],
+			18,
+			2,
+			" | ",
+		);
+		expect(rows.map(stripVTControlCharacters)).toEqual([
+			"direc… gpt-6-astra",
+			"br… OpenAI | high…",
+		]);
+		expect(rows.map(visibleWidth)).toEqual([18, 18]);
+	});
+	it("follows right template order rather than content names", () => {
+		const rows = packCompactZones(
+			[chunk("left")],
+			[chunk("usage"), chunk("model"), chunk("thinking")],
+			6,
+			1,
+			" | ",
+		);
+		expect(rows).toEqual(["usage…"]);
+	});
+	it("preserves empty-right behavior and avoids dangling boundary separators", () => {
+		const left = [chunk("one"), chunk("two", "separator")];
+		expect(packCompactZones(left, [], 7, 2, " | ")).toEqual(packCompactChunks(left, 7, 2, " | "));
+		expect(
+			packCompactZones(
+				[],
+				[chunk("one", "separator"), chunk(""), chunk("two", "separator")],
+				5,
+				2,
+				" | ",
+			),
+		).toEqual(["  one", "  two"]);
+	});
+	it.each([1, 2, 3, "unlimited"] as const)(
+		"respects %s rows and cell bounds with ANSI, links and wide glyphs",
+		(limit) => {
+			const link = "\u001b]8;;https://example.test\u0007界界\u001b]8;;\u0007";
+			for (let width = 0; width < 32; width++) {
+				const rows = packCompactZones(
+					[chunk("left…"), chunk(link), chunk("last")],
+					[
+						chunk("\u001b[31m model\u001b[0m"),
+						chunk("provider", "separator"),
+						chunk("high", "separator"),
+					],
+					width,
+					limit,
+					" | ",
+				);
+				if (limit !== "unlimited") expect(rows.length).toBeLessThanOrEqual(limit);
+				expect(rows.every((row) => visibleWidth(row) <= width)).toBe(true);
+				expect(rows.map(stripVTControlCharacters).join("\n")).not.toContain("……");
+			}
+		},
+	);
+});

package/dist/extensions/pi-zentui/test/footer-thinking-level.test.ts

@@ -0,0 +1,123 @@
+import { stripVTControlCharacters } from "node:util";
+import type { ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { afterEach, describe, expect, it } from "vitest";
+import { defaultConfig } from "../extensions/zentui/config";
+import { installFooter } from "../extensions/zentui/footer";
+import { emptyGitStatus } from "../extensions/zentui/git";
+import { createInitialState } from "../extensions/zentui/state";
+
+const disposals: Array<() => void> = [];
+afterEach(() => {
+	for (const dispose of disposals.splice(0)) dispose();
+});
+
+function createFooter(getThinkingLevel?: () => string | undefined) {
+	const config = structuredClone(defaultConfig);
+	const starship = config.components.footer.styles.starship;
+	starship.format = "$model $provider( $thinkingLevel)";
+	starship.segments.modelInfo = false;
+	const state = createInitialState(emptyGitStatus());
+	state.modelId = "test-model";
+	state.providerLabel = "Test";
+	let factory: Parameters<ExtensionContext["ui"]["setFooter"]>[0];
+	installFooter(
+		{
+			cwd: "/repo",
+			getContextUsage: () => undefined,
+			sessionManager: { getSessionName: () => undefined },
+			ui: {
+				setFooter(value: typeof factory) {
+					factory = value;
+				},
+			},
+		} as unknown as ExtensionContext,
+		state,
+		() => config,
+		{
+			setRequestRender() {},
+			scheduleProjectRefresh() {},
+			getThinkingLevel,
+		},
+	);
+	const footer = factory?.(
+		{ requestRender() {} } as never,
+		{ fg: (_color: string, text: string) => text } as Theme,
+		{ onBranchChange: () => () => {}, getExtensionStatuses: () => new Map() } as never,
+	);
+	if (!footer) throw new Error("footer was not installed");
+	disposals.push(() => footer.dispose?.());
+	return {
+		starship,
+		state,
+		render(width = 160) {
+			const rows = footer.render(width);
+			expect(rows.every((row) => visibleWidth(row) <= width)).toBe(true);
+			return stripVTControlCharacters(rows.join("\n")).trim();
+		},
+	};
+}
+
+describe("footer thinking level", () => {
+	it.each(["minimal", "low", "medium", "high", "xhigh", "future-level"])(
+		"renders active level %s without requiring model capability metadata",
+		(level) => {
+			const footer = createFooter(() => level);
+			expect(footer.render()).toBe(`test-model Test ${level}`);
+			footer.state.modelId = "";
+			expect(footer.render()).toBe(`no-model Test ${level}`);
+		},
+	);
+
+	it.each([undefined, "", "off", "OFF", "Off", " \t\n", "\u001b[31mOFF\u001b[0m"])(
+		"omits inactive level %j and conditional labels/separators",
+		(level) => {
+			const footer = createFooter(() => level);
+			footer.starship.format = "$model($sep thinking: $" + "{thinkingLevel})";
+			expect(footer.render()).toBe("test-model");
+		},
+	);
+
+	it("omits the variable when the optional getter is missing", () => {
+		expect(createFooter().render()).toBe("test-model Test");
+	});
+
+	it("reads the live level on each render without synchronization or editor installation", () => {
+		let level = "high";
+		const footer = createFooter(() => level);
+		expect(footer.render()).toBe("test-model Test high");
+		level = "low";
+		expect(footer.render()).toBe("test-model Test low");
+		level = "off";
+		expect(footer.render()).toBe("test-model Test");
+	});
+
+	it("uses the same sanitized value in wide and forced compact templates", () => {
+		const footer = createFooter(() => "\u001b[31mfuture\u001b[0m\n\tlevel\u0007");
+		footer.starship.format = `${"wide-".repeat(20)}$thinkingLevel`;
+		footer.starship.compactFormat = "compact: $" + "{thinkingLevel}";
+		footer.starship.responsive = true;
+		expect(footer.render()).toBe(`${"wide-".repeat(20)}future level`);
+		expect(footer.render(32)).toBe("compact: future level");
+		for (const width of [0, 1, 2, 5, 10, 16, 24]) {
+			expect(footer.render(width)).not.toMatch(/[\u0000-\u0009\u000b-\u001f\u007f]/);
+		}
+	});
+
+	it("keeps both templates authoritative and the built-in model info unchanged", () => {
+		let level = "future-level";
+		const footer = createFooter(() => level);
+		footer.starship.format = "$model $provider";
+		expect(footer.render()).toBe("test-model Test");
+		footer.starship.format = "wide-".repeat(30);
+		footer.starship.responsive = true;
+		expect(footer.render(24)).not.toContain("future-level");
+		footer.starship.format = "";
+		footer.starship.segments.modelInfo = true;
+		const builtIn = footer.render();
+		expect(builtIn).toContain("test-model");
+		expect(builtIn).not.toContain("future-level");
+		level = "off";
+		expect(footer.render()).toBe(builtIn);
+	});
+});

package/dist/extensions/pi-zentui/test/format.test.ts

@@ -20,6 +20,7 @@ import {
 	formatPackageVersionSegment,
 	getUsageTotals,
 	invalidateUsageTotalsCache,
+	resolveContextUsage,
 } from "../extensions/zentui/format";
 import {
 	ASCII_DEFAULT_ICONS,
@@ -417,10 +418,14 @@ describe("formatOsLabel", () => {
 	it("honors a custom icons.os over platform defaults", () => {
 		expect(formatOsLabel("X", "auto", "darwin")).toBe("X");
 		expect(formatOsLabel("X", "ascii", "linux")).toBe("X");
+		expect(formatOsLabel(ASCII_DEFAULT_ICONS.os, "ascii", "linux", true)).toBe(
+			ASCII_DEFAULT_ICONS.os,
+		);
+		expect(formatOsLabel(NERD_DEFAULT_ICONS.os, "nerd", "linux", true)).toBe(NERD_DEFAULT_ICONS.os);
 	});
 
 	it("maps platform icons when using the mode default os glyph", () => {
-		expect(formatOsLabel(NERD_DEFAULT_ICONS.os, "auto", "linux")).toBe(
+		expect(formatOsLabel(NERD_DEFAULT_ICONS.os, "nerd", "linux")).toBe(
 			OS_PLATFORM_ICONS_NERD.linux,
 		);
 		expect(formatOsLabel(ASCII_DEFAULT_ICONS.os, "ascii", "darwin")).toBe(
@@ -925,3 +930,72 @@ describe("formatPackageVersionSegment", () => {
 		expect(out).not.toContain("\u{f487}");
 	});
 });
+
+describe("resolveContextUsage snapshot", () => {
+	it.each([0, 1_100])("uses authoritative live tokens %s without host estimation", (tokens) => {
+		const getContextUsage = vi.fn(() => {
+			throw new Error("unexpected host estimate");
+		});
+		const ctx = { model: { contextWindow: 10_000 }, getContextUsage };
+		expect(resolveContextUsage(ctx as never, { tokens })).toEqual({
+			percent: tokens / 100,
+			contextWindow: 10_000,
+		});
+		expect(getContextUsage).not.toHaveBeenCalled();
+	});
+
+	it("uses one coherent fresh host snapshot without live tokens, including unknown and zero", () => {
+		const getContextUsage = vi
+			.fn()
+			.mockReturnValueOnce({ tokens: null, percent: null, contextWindow: 10_000 })
+			.mockReturnValueOnce({ tokens: 0, percent: 0, contextWindow: 20_000 })
+			.mockReturnValueOnce(undefined);
+		const ctx = { model: undefined, getContextUsage };
+		expect(resolveContextUsage(ctx)).toEqual({ percent: undefined, contextWindow: 10_000 });
+		expect(resolveContextUsage(ctx)).toEqual({ percent: 0, contextWindow: 20_000 });
+		expect(resolveContextUsage(ctx)).toEqual({ percent: undefined, contextWindow: undefined });
+		expect(getContextUsage).toHaveBeenCalledTimes(3);
+	});
+
+	it("falls back once for absent model windows and observes changed model windows immediately", () => {
+		const getContextUsage = vi.fn(() => ({ tokens: null, percent: null, contextWindow: 10_000 }));
+		const ctx = { model: { contextWindow: undefined as number | undefined }, getContextUsage };
+		expect(resolveContextUsage(ctx as never, { tokens: 1_100 })).toEqual({
+			percent: 11,
+			contextWindow: 10_000,
+		});
+		expect(getContextUsage).toHaveBeenCalledTimes(1);
+		ctx.model.contextWindow = 20_000;
+		expect(resolveContextUsage(ctx as never, { tokens: 1_100 })).toEqual({
+			percent: 5.5,
+			contextWindow: 20_000,
+		});
+		expect(getContextUsage).toHaveBeenCalledTimes(1);
+	});
+
+	it.each([0, -1, Number.NaN, Number.POSITIVE_INFINITY])(
+		"falls back for invalid model window %s",
+		(contextWindow) => {
+			const getContextUsage = vi.fn(() => ({ tokens: 1_000, percent: 10, contextWindow: 10_000 }));
+			expect(
+				resolveContextUsage({ model: { contextWindow }, getContextUsage } as never, {
+					tokens: 1_100,
+				}).percent,
+			).toBe(10);
+			expect(getContextUsage).toHaveBeenCalledTimes(1);
+		},
+	);
+
+	it.each([-1, Number.NaN, Number.POSITIVE_INFINITY])(
+		"falls back for invalid live tokens %s",
+		(tokens) => {
+			const getContextUsage = vi.fn(() => ({ tokens: 1_000, percent: 10, contextWindow: 10_000 }));
+			expect(
+				resolveContextUsage({ model: { contextWindow: 10_000 }, getContextUsage } as never, {
+					tokens,
+				}).percent,
+			).toBe(10);
+			expect(getContextUsage).toHaveBeenCalledTimes(1);
+		},
+	);
+});