@underactive/pi-topping-statusline 0.2.0 → 0.2.2

package/src/tests/context-estimate.test.ts

@@ -0,0 +1,207 @@
+/**
+ * The context graph between a compaction and the next response. pi reports
+ * usage as unknown for that stretch; the builder fills it with pi's own
+ * estimate of the compacted context, the figure pi hands compaction callers as
+ * estimatedTokensAfter, so the graph never vanishes and agrees with the result
+ * pi-topping-compact reports.
+ */
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+	buildSessionContext,
+	estimateTokens,
+	type ExtensionAPI,
+	type ExtensionContext,
+	type SessionEntry,
+} from "@earendil-works/pi-coding-agent";
+import { SegmentContextBuilder, estimateCompactedContextTokens } from "../context.ts";
+import { stripAnsi } from "../footer.ts";
+import { SEGMENTS } from "../segments.ts";
+import { resolveEffectiveSettings } from "../settings.ts";
+import type { SegmentContext } from "../types.ts";
+
+const WINDOW = 131_072;
+const OPTIONS = resolveEffectiveSettings({}).segmentOptions;
+const INCLUDE = { git: false, pr: false, piStats: false, tokenRate: false, feeds: [] };
+/** Outside any repo, so the builder's git probes stay inert. */
+const CWD = "/tmp/pi-topping-statusline-tests";
+const fakePi = { exec: async () => undefined, getThinkingLevel: () => "off" } as unknown as ExtensionAPI;
+
+type Usage = { tokens: number | null; contextWindow: number; percent: number | null } | undefined;
+const UNKNOWN: Usage = { tokens: null, contextWindow: WINDOW, percent: null };
+
+const EPOCH = 1_700_000_000_000;
+const at = (i: number) => new Date(EPOCH + i * 1000).toISOString();
+const user = (id: string, parentId: string | null, text: string, i: number): SessionEntry =>
+	({
+		type: "message",
+		id,
+		parentId,
+		timestamp: at(i),
+		message: { role: "user", content: text, timestamp: EPOCH + i * 1000 },
+	}) as unknown as SessionEntry;
+const assistant = (id: string, parentId: string, text: string, i: number): SessionEntry =>
+	({
+		type: "message",
+		id,
+		parentId,
+		timestamp: at(i),
+		message: {
+			role: "assistant",
+			content: [{ type: "text", text }],
+			api: "anthropic-messages",
+			provider: "anthropic",
+			model: "m",
+			usage: { input: 80_000, output: 500, cacheRead: 0, cacheWrite: 0, totalTokens: 80_500 },
+			stopReason: "stop",
+			timestamp: EPOCH + i * 1000,
+		},
+	}) as unknown as SessionEntry;
+
+/** A branch just after compaction: the first exchange summarized, the second kept, the leaf on the compaction. */
+function compactedBranch(): SessionEntry[] {
+	return [
+		user("e1", null, "Please review the repository layout.", 1),
+		assistant("e2", "e1", "x".repeat(60_000), 2),
+		user("e3", "e2", "Now write the tests.", 3),
+		assistant("e4", "e3", "Done, all pass.", 4),
+		{
+			type: "compaction",
+			id: "e5",
+			parentId: "e4",
+			timestamp: at(5),
+			summary: "The layout was reviewed. ".repeat(80),
+			firstKeptEntryId: "e3",
+			tokensBefore: 86_000,
+		} as unknown as SessionEntry,
+	];
+}
+
+function fakeCtx(branch: SessionEntry[], usage: Usage, counters = { branch: 0 }): ExtensionContext {
+	return {
+		cwd: CWD,
+		model: { id: "m", provider: "anthropic", name: "M", contextWindow: WINDOW },
+		getContextUsage: () => usage,
+		sessionManager: {
+			getSessionId: () => "session-1",
+			getSessionName: () => undefined,
+			getLeafId: () => branch.at(-1)?.id ?? null,
+			getBranch: () => {
+				counters.branch++;
+				return [...branch];
+			},
+			getEntries: () => branch,
+		},
+	} as unknown as ExtensionContext;
+}
+
+/** What pi itself computes as estimatedTokensAfter for this branch. */
+function piEstimate(branch: SessionEntry[]): number {
+	let tokens = 0;
+	for (const message of buildSessionContext(branch, branch.at(-1)?.id).messages) tokens += estimateTokens(message);
+	return tokens;
+}
+
+function segmentCtx(overrides: Partial<SegmentContext>): SegmentContext {
+	return {
+		options: OPTIONS,
+		model: undefined,
+		thinkingLevel: "off",
+		cwd: CWD,
+		sessionName: undefined,
+		contextPercent: null,
+		contextTokens: 0,
+		contextWindow: WINDOW,
+		git: { branch: null, status: null, pr: null },
+		worktree: null,
+		scrollHint: undefined,
+		piStats: undefined,
+		tokenRate: undefined,
+		feedData: undefined,
+		...overrides,
+	};
+}
+
+test("after a compaction the builder sizes the context as pi does, leaving out what was summarized", () => {
+	const branch = compactedBranch();
+	const builder = new SegmentContextBuilder(fakePi);
+	builder.attach(fakeCtx(branch, UNKNOWN));
+	const ctx = builder.build(80, OPTIONS, INCLUDE, undefined);
+
+	const expected = piEstimate(branch);
+	assert.equal(ctx.contextTokens, expected);
+	assert.equal(ctx.contextPercent, (expected / WINDOW) * 100);
+	assert.equal(ctx.contextEstimated, true);
+	assert.equal(ctx.contextWindow, WINDOW);
+	assert.ok(expected > 0);
+	const summarized = branch[1] as SessionEntry & { message: Parameters<typeof estimateTokens>[0] };
+	assert.ok(expected < estimateTokens(summarized.message), "the summarized reply no longer counts");
+});
+
+test("the estimate is cached per leaf and rebuilt when the branch grows", () => {
+	const branch = compactedBranch();
+	const counters = { branch: 0 };
+	const builder = new SegmentContextBuilder(fakePi);
+	builder.attach(fakeCtx(branch, UNKNOWN, counters));
+
+	const first = builder.build(80, OPTIONS, INCLUDE, undefined);
+	builder.build(80, OPTIONS, INCLUDE, undefined);
+	assert.equal(counters.branch, 1, "the same leaf reuses the estimate");
+
+	const followUp = user("e6", "e5", "And now the docs, please.", 6);
+	branch.push(followUp);
+	const grown = builder.build(80, OPTIONS, INCLUDE, undefined);
+	assert.equal(counters.branch, 2, "a new leaf rebuilds it");
+	const added = estimateTokens((followUp as SessionEntry & { message: Parameters<typeof estimateTokens>[0] }).message);
+	assert.equal(grown.contextTokens, first.contextTokens + added);
+	assert.equal(grown.contextTokens, piEstimate(branch));
+});
+
+test("pi's measured figure takes over as soon as it has one", () => {
+	const counters = { branch: 0 };
+	const builder = new SegmentContextBuilder(fakePi);
+	builder.attach(fakeCtx(compactedBranch(), { tokens: 12_345, contextWindow: WINDOW, percent: 9.4 }, counters));
+	const ctx = builder.build(80, OPTIONS, INCLUDE, undefined);
+	assert.equal(ctx.contextTokens, 12_345);
+	assert.equal(ctx.contextPercent, 9.4);
+	assert.equal(ctx.contextEstimated, false);
+	assert.equal(counters.branch, 0, "no estimate is computed");
+});
+
+test("a broken session manager costs the estimate, not the frame", () => {
+	const builder = new SegmentContextBuilder(fakePi);
+	const ctx = fakeCtx(compactedBranch(), UNKNOWN);
+	(ctx as { sessionManager: Partial<ExtensionContext["sessionManager"]> }).sessionManager = {
+		getSessionName: () => undefined,
+		getEntries: () => [],
+	};
+	builder.attach(ctx);
+	const built = builder.build(80, OPTIONS, INCLUDE, undefined);
+	assert.equal(built.contextPercent, null);
+	assert.equal(built.contextTokens, 0);
+	assert.equal(built.contextEstimated, false);
+});
+
+test("an empty branch estimates zero", () => {
+	assert.equal(
+		estimateCompactedContextTokens({
+			getBranch: () => [],
+			getLeafId: () => null,
+		} as unknown as ExtensionContext["sessionManager"]),
+		0,
+	);
+});
+
+test("the graph draws an estimate with a ~ on its label", () => {
+	const estimated = SEGMENTS.context_graph.render(
+		segmentCtx({ contextPercent: 9.2, contextTokens: 12_000, contextEstimated: true }),
+	);
+	assert.ok(estimated.visible);
+	assert.equal(stripAnsi(estimated.content), `${"▋".repeat(2)}${"░".repeat(18)} ~9.2%/131K`);
+
+	const measured = SEGMENTS.context_graph.render(segmentCtx({ contextPercent: 9.2, contextTokens: 12_000 }));
+	assert.equal(stripAnsi(measured.content), `${"▋".repeat(2)}${"░".repeat(18)} 9.2%/131K`);
+
+	const unknown = SEGMENTS.context_graph.render(segmentCtx({}));
+	assert.equal(unknown.visible, false, "with nothing to size against, the graph still stays out");
+});

package/src/tests/context-thresholds.test.ts

@@ -48,3 +48,9 @@ test("a null or undefined percent against a known window renders '?'", () => {
 test("a known percent renders with one decimal", () => {
 	assert.equal(formatContextUsage(42.567, 200_000), "42.6%/200K");
 });
+
+test("an estimate wears ~ wherever it shows a figure", () => {
+	assert.equal(formatContextUsage(9.2, 131_072, 12_000, true), "~9.2%/131K");
+	assert.equal(formatContextUsage(9.2, 0, 12_000, true), "~12K/?");
+	assert.equal(formatContextUsage(null, 131_072, 0, true), "?/131K", "nothing to mark");
+});

package/src/tests/feeds.test.ts

@@ -14,9 +14,10 @@ import test from "node:test";
 import type { ExtensionAPI, ExtensionContext, SessionEntry } from "@earendil-works/pi-coding-agent";
 import { renderBoxRowIfVisible } from "../box.ts";
 import { FEED_FADE_MS, FEED_HOLD_MS, SegmentContextBuilder, getFeedDisplayState } from "../context.ts";
+import { stripAnsi } from "../footer.ts";
 import { buildStatusLine } from "../layout.ts";
 import { SEGMENTS } from "../segments.ts";
-import { DEFAULT_FEEDS, DEFAULT_SEGMENTS, resolveEffectiveSettings, sanitizeFeeds } from "../settings.ts";
+import { DEFAULT_SEGMENTS, resolveEffectiveSettings, sanitizeFeeds } from "../settings.ts";
 import { theme } from "../theme.ts";
 import type { FeedDisplayState, SegmentContext, StatusLineFeed } from "../types.ts";
 import { feedKey } from "../utils.ts";
@@ -31,7 +32,6 @@ const feedMap = (entries: Record<string, unknown> = {}): Record<string, unknown>
 	Object.assign(Object.create(null) as Record<string, unknown>, entries);
 
 const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
-const stripAnsi = (text: string) => text.replace(/\x1b\[[0-9;]*m/g, "");
 
 // Partial stand-ins: the builder only reaches the members defined here.
 const fakePi = { exec: async () => undefined, getThinkingLevel: () => "off" } as unknown as ExtensionAPI;
@@ -507,9 +507,3 @@ test("sanitizeFeeds drops unusable rows and normalizes the rest", () => {
 test("an explicitly empty feed list is honoured rather than reseeded", () => {
 	assert.deepEqual(resolveEffectiveSettings({ feeds: [] }).segmentOptions.feeds, []);
 });
-
-test("the default subscription matches what pi-prompt-cache publishes", () => {
-	assert.equal(DEFAULT_FEEDS[0]?.customType, SAVINGS);
-	assert.equal(DEFAULT_FEEDS[0]?.field, "savedUsd");
-	assert.equal(DEFAULT_FEEDS[0]?.format, "currency");
-});

package/src/tests/footer.test.ts

@@ -48,6 +48,7 @@ test("filterVisibleRows drops empty notifications but keeps visible rows", () =>
 test("fullscreen footer slot can collapse and restores its minimum", () => {
 	const footer = { render: () => [] };
 	const footerContainer = { children: [footer] };
+	// minSize: 1 mirrors the footer dock shape used by hosts before pi 0.86.
 	const footerEntry = { component: footerContainer, minSize: 1 };
 	const dock = { entries: [{ component: {} }, footerEntry] };
 	const root = { entries: [{ component: {} }, { component: dock, minSize: 1 }] };

package/src/tests/menu.test.ts

@@ -1,11 +1,17 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import type { Theme } from "@earendil-works/pi-coding-agent";
+import { stripAnsi } from "../footer.ts";
 import { MenuComponent } from "../menu.ts";
 import type { MenuSection } from "../menu.ts";
 
-const theme = { fg: (_c: string, s: string) => s, bold: (s: string) => s } as unknown as Theme;
-const plain = (lines: string[]) => lines.map(l => l.replace(/\x1b\[[0-9;]*m/g, ""));
+const theme = {
+	fg: (_c: string, s: string) => s,
+	bg: (color: string, s: string) => color === "selectedBg" ? `\x1b[48;5;1m${s}\x1b[49m` : s,
+	bold: (s: string) => s,
+	getBgAnsi: (color: string) => color === "selectedBg" ? "\x1b[48;5;1m" : "",
+} as unknown as Theme;
+const plain = (lines: string[]) => lines.map(stripAnsi);
 
 function makeSections(feeds: { customType: string; prefix: string }[]): MenuSection[] {
 	const items: any[] = [];
@@ -47,6 +53,29 @@ function drive() {
 
 const type = (menu: any, s: string) => { for (const ch of s) menu.handleInput(ch); };
 
+test("selected rows use the pi-topping marker and background", () => {
+	const { menu } = drive();
+	const lines = menu.render(60);
+	const plainText = plain(lines).join("\n");
+	assert.match(plainText, /> 1\. type/);
+	assert.ok(!plainText.includes("▸"));
+	assert.ok(lines.some(line => line.includes("\x1b[48;5;1m")), "selected row background is missing");
+});
+
+test("selected row background survives an embedded reset from truncated content", () => {
+	const { menu } = drive();
+	// Width narrow enough that the "1. type" label truncates, which embeds a raw \x1b[0m reset.
+	const lines = menu.render(15);
+	const selectedLine = lines.find(line => line.includes("\x1b[48;5;1m"))!;
+	assert.ok(selectedLine, "selected row not found");
+	assert.ok(selectedLine.includes("\x1b[0m"), "expected a reset from truncateToWidth in the selected row");
+	assert.doesNotMatch(
+		selectedLine,
+		/\x1b\[0m(?!\x1b\[48;5;1m)/,
+		"selected background must be reopened after every reset",
+	);
+});
+
 test("typing into a text row edits only on commit", () => {
 	const { menu } = drive();
 	menu.handleInput("\r");                    // Enter on row 0 -> begin editing

package/src/tests/nvidia-green.test.ts

@@ -0,0 +1,51 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+	NVIDIA_GREEN_DARK_HEX,
+	NVIDIA_GREEN_HEX,
+	NvidiaGreenBorder,
+	isSwitchyardProvider,
+} from "../nvidia-green.ts";
+import { resolveEffectiveSettings } from "../settings.ts";
+import { detectColorMode, hexToFgAnsi } from "../theme.ts";
+
+test("recognizes the Switchyard provider case-insensitively after trimming", () => {
+	assert.equal(isSwitchyardProvider("switchyard"), true);
+	assert.equal(isSwitchyardProvider(" Switchyard "), true);
+	assert.equal(isSwitchyardProvider(undefined), false);
+	assert.equal(isSwitchyardProvider(""), false);
+	assert.equal(isSwitchyardProvider("other"), false);
+});
+
+test("switchyard green settings default to true and resolve explicit false", () => {
+	const defaults = resolveEffectiveSettings({});
+	assert.equal(defaults.nvidiaGreenBorder, true);
+	assert.equal(defaults.nvidiaGreenAnimation, true);
+	const off = resolveEffectiveSettings({ nvidiaGreenBorder: false, nvidiaGreenAnimation: false });
+	assert.equal(off.nvidiaGreenBorder, false);
+	assert.equal(off.nvidiaGreenAnimation, false);
+});
+
+test("colorChar wraps a glyph in a color escape and foreground reset", () => {
+	const border = new NvidiaGreenBorder();
+	assert.match(border.colorChar("─", 0, 28), /^\x1b\[38;(2;\d+;\d+;\d+|5;\d+)m─\x1b\[39m$/);
+});
+
+test("phase zero has bright and dark opposite endpoints", () => {
+	const mode = detectColorMode();
+	const border = new NvidiaGreenBorder(0);
+	assert.equal(border.colorChar("─", 0, 28), `${hexToFgAnsi(NVIDIA_GREEN_HEX, mode)}─\x1b[39m`);
+	assert.equal(border.colorChar("─", 14, 28), `${hexToFgAnsi(NVIDIA_GREEN_DARK_HEX, mode)}─\x1b[39m`);
+});
+
+test("step by one full turn preserves the color", () => {
+	const stepped = new NvidiaGreenBorder(37);
+	const unchanged = new NvidiaGreenBorder(37);
+	stepped.step(360);
+	assert.equal(stepped.colorChar("─", 7, 28), unchanged.colorChar("─", 7, 28));
+});
+
+test("opposite positions receive different shades", () => {
+	const border = new NvidiaGreenBorder();
+	assert.notEqual(border.colorChar("─", 0, 28), border.colorChar("─", 14, 28));
+});

package/src/tests/token-rate.test.ts

@@ -8,6 +8,7 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { SegmentContextBuilder } from "../context.ts";
+import { stripAnsi } from "../footer.ts";
 import { SEGMENTS } from "../segments.ts";
 import { resolveEffectiveSettings } from "../settings.ts";
 import { FADE_SHADE_COUNT, theme } from "../theme.ts";
@@ -31,7 +32,7 @@ const BASE = builder.build(
 );
 
 const render = (tokenRate: TokenRateDisplay) => SEGMENTS.token_rate.render({ ...BASE, tokenRate });
-const plain = (tokenRate: TokenRateDisplay) => render(tokenRate).content.replace(/\x1b\[[0-9;]*m/g, "");
+const plain = (tokenRate: TokenRateDisplay) => stripAnsi(render(tokenRate).content);
 const active = (rate: number | null): TokenRateDisplay => ({ rate, phase: "active", fadeShade: 0 });
 
 test("the rate is right-aligned to the placeholder's width", () => {

package/src/tests/working-status-embed.test.ts

@@ -0,0 +1,12 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { hostsWorkingStatus } from "../working-status-embed.ts";
+
+test("only an opted-in editor that receives the host's status hosts the working status", () => {
+	const setWorkingStatusIndicator = (): void => {};
+	assert.equal(hostsWorkingStatus({ embedWorkingStatus: true, setWorkingStatusIndicator }), true);
+	assert.equal(hostsWorkingStatus({ embedWorkingStatus: false, setWorkingStatusIndicator }), false);
+	assert.equal(hostsWorkingStatus({ embedWorkingStatus: true }), false, "pre-0.85 hosts never send the status");
+	assert.equal(hostsWorkingStatus({}), false);
+	assert.equal(hostsWorkingStatus(undefined), false, "a wrapped third-party editor keeps pi's standalone status row");
+});

package/src/tests/working-status.test.ts

@@ -0,0 +1,209 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+	STATUS_HOLD_MS,
+	STATUS_SLIDE_MS,
+	type StatusIndicatorKind,
+	StatusTransition,
+	WORKING_FADE_MS,
+} from "../working-status.ts";
+
+/** Show a status early enough that its slide-out has finished by `at`. */
+function settle(transition: StatusTransition, status: string, kind: StatusIndicatorKind | undefined, at: number): void {
+	transition.resolve(status, kind, at - STATUS_SLIDE_MS);
+	transition.resolve(status, kind, at);
+}
+
+test("a status appearing over the user's segments slides out, then settles verbatim", () => {
+	const transition = new StatusTransition();
+
+	assert.deepEqual(transition.resolve("⠙ Working", "working", 1_000), {
+		status: "⠙ Working",
+		kind: "working",
+		reveal: 0,
+		pending: true,
+	});
+	// Spinner frames change the text mid-slide without restarting it.
+	const early = transition.resolve("⠹ Working", "working", 1_000 + STATUS_SLIDE_MS / 4).reveal ?? -1;
+	const late = transition.resolve("⠸ Working", "working", 1_000 + (STATUS_SLIDE_MS * 3) / 4).reveal ?? -1;
+	assert.ok(0 < early && early < late && late < 1, "reveal grows monotonically");
+	assert.equal(transition.pending(1_000 + STATUS_SLIDE_MS - 1), true);
+
+	assert.deepEqual(transition.resolve("⠼ Working", "working", 1_000 + STATUS_SLIDE_MS), {
+		status: "⠼ Working",
+		kind: "working",
+		pending: false,
+	});
+	assert.equal(transition.pending(1_000 + STATUS_SLIDE_MS), false);
+});
+
+test("a status cleared mid-slide keeps sliding through its hold", () => {
+	const transition = new StatusTransition();
+	transition.resolve("⠙ Working", "working", 0);
+
+	const clearedAt = STATUS_SLIDE_MS / 4;
+	const cleared = transition.resolve(undefined, undefined, clearedAt);
+	const held = transition.resolve(undefined, undefined, clearedAt + STATUS_HOLD_MS / 2);
+	assert.equal(held.status, "⠙ Working");
+	assert.ok(0 < (cleared.reveal ?? 1) && (cleared.reveal ?? 1) < (held.reveal ?? 1), "the slide continues");
+});
+
+test("clearing a working status holds it, cross-fades both halves, then settles", () => {
+	const transition = new StatusTransition();
+	settle(transition, "⠙ Working", "working", 1_000);
+
+	const clearedAt = 2_000;
+	const holdEndsAt = clearedAt + STATUS_HOLD_MS;
+	assert.deepEqual(transition.resolve(undefined, undefined, clearedAt), {
+		status: "⠙ Working",
+		kind: "working",
+		pending: true,
+	});
+	assert.deepEqual(transition.resolve(undefined, undefined, holdEndsAt - 1), {
+		status: "⠙ Working",
+		kind: "working",
+		pending: true,
+	});
+
+	const outgoingStart = transition.resolve(undefined, undefined, holdEndsAt);
+	const outgoingMiddle = transition.resolve(undefined, undefined, holdEndsAt + 150);
+	const outgoingEnd = transition.resolve(undefined, undefined, holdEndsAt + WORKING_FADE_MS / 2 - 1);
+	assert.equal(outgoingStart.status, "⠙ Working");
+	assert.equal(outgoingMiddle.status, "⠙ Working");
+	assert.equal(outgoingEnd.status, "⠙ Working");
+	assert.ok(
+		(outgoingStart.leftFade ?? -1) > (outgoingMiddle.leftFade ?? -1) &&
+			(outgoingMiddle.leftFade ?? -1) > (outgoingEnd.leftFade ?? -1),
+		"outgoing opacity decreases monotonically",
+	);
+
+	const incomingStart = transition.resolve(undefined, undefined, holdEndsAt + WORKING_FADE_MS / 2);
+	const incomingMiddle = transition.resolve(undefined, undefined, holdEndsAt + 550);
+	const incomingEnd = transition.resolve(undefined, undefined, holdEndsAt + WORKING_FADE_MS - 1);
+	assert.equal(incomingStart.status, undefined);
+	assert.equal(incomingMiddle.status, undefined);
+	assert.equal(incomingEnd.status, undefined);
+	assert.ok(
+		(incomingStart.leftFade ?? 2) < (incomingMiddle.leftFade ?? 2) &&
+			(incomingMiddle.leftFade ?? 2) < (incomingEnd.leftFade ?? 2),
+		"incoming opacity increases monotonically",
+	);
+	assert.equal(transition.pending(holdEndsAt + WORKING_FADE_MS - 1), true);
+
+	assert.deepEqual(transition.resolve(undefined, undefined, holdEndsAt + WORKING_FADE_MS), {
+		status: undefined,
+		kind: undefined,
+		pending: false,
+	});
+	assert.equal(transition.pending(holdEndsAt + WORKING_FADE_MS), false);
+});
+
+test("clearing message-style statuses holds them and then cuts without a fade", () => {
+	for (const kind of ["compaction", "retry"] as const) {
+		const transition = new StatusTransition();
+		settle(transition, `⠙ ${kind}`, kind, 100);
+		assert.deepEqual(transition.resolve(undefined, undefined, 200), {
+			status: `⠙ ${kind}`,
+			kind,
+			pending: true,
+		});
+		assert.deepEqual(transition.resolve(undefined, undefined, 200 + STATUS_HOLD_MS - 1), {
+			status: `⠙ ${kind}`,
+			kind,
+			pending: true,
+		});
+		assert.deepEqual(transition.resolve(undefined, undefined, 200 + STATUS_HOLD_MS), {
+			status: undefined,
+			kind: undefined,
+			pending: false,
+		});
+	}
+});
+
+test("a new status during the hold cuts in immediately and cancels the exit", () => {
+	const transition = new StatusTransition();
+	settle(transition, "⠙ Working", "working", 1_000);
+	transition.resolve(undefined, undefined, 1_100);
+
+	assert.deepEqual(transition.resolve("⠹ Retrying", "retry", 1_200), {
+		status: "⠹ Retrying",
+		kind: "retry",
+		pending: false,
+	});
+	assert.equal(transition.pending(2_000), false);
+});
+
+test("a new status during the fade cuts in immediately and cancels the exit", () => {
+	const transition = new StatusTransition();
+	settle(transition, "⠙ Working", "working", 0);
+	transition.resolve(undefined, undefined, 100);
+	const fading = transition.resolve(undefined, undefined, 300);
+	assert.equal(fading.status, "⠙ Working");
+	assert.equal(fading.pending, true);
+
+	assert.deepEqual(transition.resolve("⠸ Compacting", "compaction", 301), {
+		status: "⠸ Compacting",
+		kind: "compaction",
+		pending: false,
+	});
+	assert.equal(transition.pending(1_000), false);
+});
+
+test("a status arriving after the fade's outgoing half slides out again", () => {
+	const transition = new StatusTransition();
+	settle(transition, "⠙ Working", "working", 0);
+	transition.resolve(undefined, undefined, 100);
+
+	const incomingAt = 100 + STATUS_HOLD_MS + WORKING_FADE_MS / 2;
+	assert.equal(transition.resolve(undefined, undefined, incomingAt).status, undefined);
+	assert.deepEqual(transition.resolve("⠹ Retrying", "retry", incomingAt + 1), {
+		status: "⠹ Retrying",
+		kind: "retry",
+		reveal: 0,
+		pending: true,
+	});
+});
+
+test("a working-to-compaction handoff across the hold never yields an empty status", () => {
+	const transition = new StatusTransition();
+	const frames = [
+		transition.resolve("⠙ Working", "working", 0),
+		transition.resolve(undefined, undefined, 100),
+		transition.resolve(undefined, undefined, 100 + STATUS_HOLD_MS - 1),
+		transition.resolve("⠸ Compacting", "compaction", 100 + STATUS_HOLD_MS),
+	];
+
+	assert.ok(frames.every(frame => frame.status !== undefined));
+	assert.equal(frames.at(-1)?.kind, "compaction");
+});
+
+test("an undefined kind preserves the pre-0.86 working fade", () => {
+	const transition = new StatusTransition();
+	transition.resolve("⠙ Working", undefined, 0);
+	transition.resolve(undefined, undefined, 10);
+
+	const fadeStarts = transition.resolve(undefined, undefined, 10 + STATUS_HOLD_MS);
+	assert.equal(fadeStarts.status, "⠙ Working");
+	assert.equal(fadeStarts.leftFade, 1);
+	assert.equal(fadeStarts.pending, true);
+	assert.deepEqual(transition.resolve(undefined, undefined, 10 + STATUS_HOLD_MS + WORKING_FADE_MS), {
+		status: undefined,
+		kind: undefined,
+		pending: false,
+	});
+});
+
+test("reset clears live, exiting, and sliding state", () => {
+	const transition = new StatusTransition();
+	transition.resolve("⠙ Working", "working", 10);
+	transition.resolve(undefined, undefined, 20);
+	transition.reset();
+
+	assert.deepEqual(transition.resolve(undefined, undefined, 21), {
+		status: undefined,
+		kind: undefined,
+		pending: false,
+	});
+	assert.equal(transition.pending(21), false);
+	assert.equal(transition.resolve("⠹ Working", "working", 22).reveal, 0, "the next status slides from the start");
+});