@underactive/pi-topping-statusline 0.1.3 → 0.2.0

package/src/layout.ts

@@ -1,15 +1,20 @@
 /**
  * The bar layout engine, ported from oh-my-pi component.ts #buildStatusLine.
  *
- * Overflow strategy (in order): drop right segments right-to-left, shrink the
- * elastic `path` segment down to ~8 cells, drop left segments end-first while
- * protecting `path`. The gap between the two groups is filled with the
+ * Overflow strategy (in order): drop right segments right-to-left, truncate
+ * the embedded `working` status (no ellipsis, as pi's own border does), shrink
+ * the elastic `path` segment down to ~8 cells, drop left segments end-first
+ * while protecting `path`. The gap between the two groups is filled with the
  * box-horizontal glyph colored like the editor border, so it tracks the
  * thinking-level border color; the callback receives the gap's absolute
  * column and row in the box, so a caller can paint it as part of a
  * continuous border gradient (the rainbow effect).
+ *
+ * `options.leftFade` (0..1) blends every left segment after a leading `pi`
+ * symbol toward the bar background, which the working-indicator transition
+ * uses to cross-fade the group without moving the symbol or its chevron.
  */
-import { visibleWidth } from "@earendil-works/pi-tui";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { renderSegment } from "./segments.js";
 import { getSeparator } from "./separators.js";
 import { theme } from "./theme.js";
@@ -58,6 +63,7 @@ export function buildStatusLine(
 	gapBorderColor: (str: string, startCol: number, row: number) => string,
 	segmentGroups: { left: StatusLineSegmentId[]; right: StatusLineSegmentId[] },
 	barOrigin: { col: number; row: number } = { col: 0, row: 0 },
+	options: { leftFade?: number } = {},
 ): string {
 	const separatorDef = getSeparator(settings.separator);
 
@@ -112,6 +118,19 @@ export function buildStatusLine(
 			right.pop();
 			rightWidth = rightGroupWidth(right);
 		}
+		// The working status absorbs overflow first so the Pi symbol beside it
+		// survives on narrow terminals.
+		const workingIdx = leftSegIds.indexOf("working");
+		if (workingIdx >= 0 && totalWidth() > width) {
+			const available = visibleWidth(left[workingIdx]) - (totalWidth() - width);
+			if (available >= 1) {
+				left[workingIdx] = truncateToWidth(left[workingIdx], available, "");
+			} else {
+				left.splice(workingIdx, 1);
+				leftSegIds.splice(workingIdx, 1);
+			}
+			leftWidth = leftGroupWidth(left);
+		}
 		// Shrink path before dropping left segments — path is the only elastic segment
 		const pathIdx = leftSegIds.indexOf("path");
 		if (pathIdx >= 0 && totalWidth() > width) {
@@ -137,13 +156,25 @@ export function buildStatusLine(
 		}
 	}
 
-	const renderGroup = (parts: string[], direction: "left" | "right"): string => {
+	const renderGroup = (parts: string[], direction: "left" | "right", fadeFrom = parts.length): string => {
 		if (parts.length === 0) return "";
 		const sep = direction === "left" ? separatorDef.left : separatorDef.right;
 		const capPrefix = bgAnsi.replace("\x1b[48;", "\x1b[38;");
-
+		const sepText = ` ${sepAnsi}${sep}${fgAnsi} `;
+
+		let body: string;
+		const fade = options.leftFade;
+		if (fade !== undefined && fade < 1 && fadeFrom < parts.length) {
+			// The faded tail opens with an explicit default-fg reset so plain text
+			// inside it is recolored too, not just segments that set their own color.
+			const head = parts.slice(0, fadeFrom).join(sepText);
+			const tail = `\x1b[39m${parts.slice(fadeFrom).join(sepText)}`;
+			body = head + theme.fadeAnsi((head ? sepText : "") + tail, fade);
+		} else {
+			body = parts.join(sepText);
+		}
 		let content = bgAnsi + fgAnsi;
-		content += ` ${parts.join(` ${sepAnsi}${sep}${fgAnsi} `)} `;
+		content += ` ${body} `;
 		content += "\x1b[0m";
 
 		if (capLeft) content = `${capPrefix}${capLeft}\x1b[0m${content}`;
@@ -151,7 +182,7 @@ export function buildStatusLine(
 		return content;
 	};
 
-	const leftGroup = renderGroup(left, "left");
+	const leftGroup = renderGroup(left, "left", leftSegIds[0] === "pi" ? 1 : 0);
 	const rightGroup = renderGroup(right, "right");
 	if (!leftGroup && !rightGroup) return "";
 

package/src/segments.ts

@@ -13,6 +13,7 @@ import { formatContextUsage } from "./context-thresholds.js";
 import { MAJOR_COLOR_HEXES, hexToFgAnsi, theme } from "./theme.js";
 import {
 	clampPathLength,
+	feedKey,
 	getSessionAccentHex,
 	sanitizeLabel,
 	sanitizeStatusText,
@@ -256,8 +257,8 @@ function formatFeedValue(value: unknown, format: FeedFormat): string | undefined
 /**
  * Values published by other extensions as custom session entries, each shown
  * as its configured prefix followed by the value. A feed contributes nothing
- * when its publisher is absent, has published nothing this run, or reports a
- * value the configured format suppresses.
+ * when its publisher is absent, has published nothing this run, reports a
+ * value the configured format suppresses, or has faded out after five minutes unchanged.
  */
 const feedsSegment: StatusLineSegment = {
 	id: "feeds",
@@ -269,11 +270,19 @@ const feedsSegment: StatusLineSegment = {
 			const payload = data[feed.customType];
 			if (payload == null || typeof payload !== "object") continue;
 			if (!Object.hasOwn(payload, feed.field)) continue;
+			const display = ctx.feedDisplayState?.[feedKey(feed.customType, feed.field)];
+			if (display?.phase === "hidden") continue;
 			const text = formatFeedValue((payload as Record<string, unknown>)[feed.field], feed.format);
-			if (text !== undefined) parts.push(`${sanitizeLabel(feed.prefix)}${text}`);
+			if (text === undefined) continue;
+			const content = `${sanitizeLabel(feed.prefix)}${text}`;
+			parts.push(
+				display?.phase === "fading"
+					? theme.fadeFg("dim", "statusLineBg", display.fadeShade, content)
+					: theme.fg("dim", content),
+			);
 		}
 		if (parts.length === 0) return INVISIBLE;
-		return { content: theme.fg("success", parts.join(" ")), visible: true };
+		return { content: parts.join(" "), visible: true };
 	},
 };
 
@@ -286,6 +295,20 @@ const scrollHintSegment: StatusLineSegment = {
 	},
 };
 
+/**
+ * Pi's embedded working indicator (spinner + message), already colored by the
+ * host, so it is passed through verbatim. The layout truncates it, without an
+ * ellipsis, when it overflows, mirroring pi's own border rendering.
+ */
+const workingSegment: StatusLineSegment = {
+	id: "working",
+	render(ctx) {
+		const status = ctx.workingStatus;
+		if (!status) return INVISIBLE;
+		return { content: status, visible: true };
+	},
+};
+
 /** Context bar + stats — related parts joined by a space, not the group separator. */
 const contextGraphSegment: StatusLineSegment = {
 	id: "context_graph",
@@ -342,6 +365,7 @@ export const SEGMENTS: Record<StatusLineSegmentId, StatusLineSegment> = {
 	feeds: feedsSegment,
 	context_graph: contextGraphSegment,
 	scroll_hint: scrollHintSegment,
+	working: workingSegment,
 };
 
 export function renderSegment(id: StatusLineSegmentId, ctx: SegmentContext): RenderedSegment {

package/src/settings-menu.ts

@@ -19,6 +19,7 @@ import {
 	saveSettings,
 	sanitizeFeeds,
 	SEPARATORS,
+	topLeftSegments,
 	type SettingsState,
 } from "./settings.js";
 import { theme, type BorderStyle, type SymbolPreset } from "./theme.js";
@@ -140,6 +141,11 @@ function buildSections(settings: StatusLineSettings): MenuSection[] {
 				label: "Animate rainbow border",
 				value: settings.rainbowAnimation ?? true,
 			},
+			{
+				id: "embedWorkingStatus",
+				label: "Embed 'Working' indicator",
+				value: settings.embedWorkingStatus ?? false,
+			},
 		],
 	};
 	return [
@@ -170,6 +176,7 @@ function valuesToSettings(values: Record<string, MenuValue>): StatusLineSettings
 		feeds: sanitizeFeeds(feedsFromValues(values)),
 		rainbowBorder: values.rainbowBorder === true,
 		rainbowAnimation: values.rainbowAnimation === true,
+		embedWorkingStatus: values.embedWorkingStatus === true,
 	};
 }
 
@@ -184,6 +191,8 @@ const CANNED_STATS = "↑ 12.4K ↓ 3.1K R 148K W 12K 92.3% $0.42";
 const CANNED_GIT = { branch: "main", status: { staged: 1, unstaged: 2, untracked: 3 } };
 const CANNED_PERCENT = 42;
 const CANNED_WINDOW = 200_000;
+/** What pi's border indicator looks like mid-stream with pi-topping's loader installed. */
+const CANNED_WORKING = "⠙ Mulling ⢾⣿⣿⣿⣿⣿⢾⢾  28 tps · 11s · ↓ 316 tokens";
 
 /** Fill any feed the live session has no entry for, so the preview stays legible. */
 function cannedFeedData(
@@ -266,13 +275,14 @@ class StatusLinePreview {
 				bottomIdx,
 				flat: s => this.#uiTheme.fg("border", s),
 			});
+			const embedOn = effective.embedWorkingStatus;
 			const top = buildStatusLine(
 				barWidth,
-				ctx,
+				embedOn ? { ...ctx, workingStatus: this.#uiTheme.fg("border", CANNED_WORKING) } : ctx,
 				effective,
 				painters.gapColor,
 				{
-					left: effective.leftSegments,
+					left: topLeftSegments(effective, embedOn),
 					right: effective.rightSegments,
 				},
 				{ col: 3, row: 0 },
@@ -312,7 +322,7 @@ export function registerSettingsCommand(
 	onChange: () => void,
 ): void {
 	pi.registerCommand("topping-statusline-settings", {
-		description: "Configure transparent segments, statusline segments, separator, symbols, border style, feeds, and rainbow border animation",
+		description: "Configure transparent segments, statusline segments, separator, symbols, border style, feeds, rainbow border animation, and the embedded working indicator",
 		handler: async (_args, ctx: ExtensionCommandContext) => {
 			if (ctx.mode !== "tui") {
 				ctx.ui.notify("/topping-statusline-settings requires TUI mode", "error");

package/src/settings.ts

@@ -93,6 +93,7 @@ function loadSettings(): StatusLineSettings {
 		if (raw.feeds !== undefined) settings.feeds = sanitizeFeeds(raw.feeds);
 		if (typeof raw.rainbowBorder === "boolean") settings.rainbowBorder = raw.rainbowBorder;
 		if (typeof raw.rainbowAnimation === "boolean") settings.rainbowAnimation = raw.rainbowAnimation;
+		if (typeof raw.embedWorkingStatus === "boolean") settings.embedWorkingStatus = raw.embedWorkingStatus;
 		return settings;
 	} catch {
 		// Missing or corrupt settings.json falls back to defaults.
@@ -155,6 +156,7 @@ export function resolveEffectiveSettings(settings: StatusLineSettings): Effectiv
 		bottomRightSegments,
 		rainbowBorder: settings.rainbowBorder ?? true,
 		rainbowAnimation: settings.rainbowAnimation ?? true,
+		embedWorkingStatus: settings.embedWorkingStatus ?? false,
 		includes,
 		segmentOptions: {
 			model: { showModel: seg.model, showProvider: seg.provider, showThinking: seg.thinking },
@@ -165,6 +167,16 @@ export function resolveEffectiveSettings(settings: StatusLineSettings): Effectiv
 	};
 }
 
+/**
+ * The top-left group for one frame. While pi's working status is embedded,
+ * it stands in for every left segment except the leading Pi symbol, so the
+ * symbol and its chevron never move when a stream starts or ends.
+ */
+export function topLeftSegments(effective: EffectiveStatusLineSettings, working: boolean): StatusLineSegmentId[] {
+	if (!working) return effective.leftSegments;
+	return effective.leftSegments[0] === "pi" ? ["pi", "working"] : ["working"];
+}
+
 export interface SettingsState {
 	settings: StatusLineSettings;
 	effective: EffectiveStatusLineSettings;

package/src/tests/box.test.ts

@@ -9,7 +9,7 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import { stripVTControlCharacters } from "node:util";
 import { visibleWidth } from "@earendil-works/pi-tui";
-import { makeBoxPainters, renderBoxRow } from "../box.ts";
+import { makeBoxPainters, renderBoxRow, renderBoxRowIfVisible } from "../box.ts";
 import { RainbowBorder } from "../rainbow.ts";
 import type { BoxGlyphs } from "../theme.ts";
 
@@ -44,6 +44,19 @@ test("an empty bar renders chrome only, still totalling boxWidth", () => {
 	assert.equal(visibleWidth(out), 20);
 });
 
+test("an empty footer bar reserves no row", () => {
+	assert.deepEqual(
+		renderBoxRowIfVisible(identityPainters(20), "\x1b[32m \x1b[0m", 2, 20, ROUNDED.bottomLeft, ROUNDED.bottomRight),
+		[],
+	);
+});
+
+test("a visible footer bar retains one row", () => {
+	const rows = renderBoxRowIfVisible(identityPainters(20), "X", 2, 20, ROUNDED.bottomLeft, ROUNDED.bottomRight);
+	assert.equal(rows.length, 1);
+	assert.equal(rows[0], "╰──X" + "─".repeat(15) + "╯");
+});
+
 test("wide characters in the bar consume pad cells, keeping the total fixed", () => {
 	const out = renderBoxRow(identityPainters(20), "日本", 0, 20, ROUNDED.topLeft, ROUNDED.topRight);
 	assert.equal(out, "╭──日本" + "─".repeat(12) + "╮");

package/src/tests/feeds.test.ts

@@ -12,16 +12,23 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import type { ExtensionAPI, ExtensionContext, SessionEntry } from "@earendil-works/pi-coding-agent";
-import { SegmentContextBuilder } from "../context.ts";
+import { renderBoxRowIfVisible } from "../box.ts";
+import { FEED_FADE_MS, FEED_HOLD_MS, SegmentContextBuilder, getFeedDisplayState } from "../context.ts";
+import { buildStatusLine } from "../layout.ts";
 import { SEGMENTS } from "../segments.ts";
 import { DEFAULT_FEEDS, DEFAULT_SEGMENTS, resolveEffectiveSettings, sanitizeFeeds } from "../settings.ts";
-import type { SegmentContext, StatusLineFeed } from "../types.ts";
+import { theme } from "../theme.ts";
+import type { FeedDisplayState, SegmentContext, StatusLineFeed } from "../types.ts";
+import { feedKey } from "../utils.ts";
 
 const SAVINGS = "pi-prompt-cache/savings";
 const OPTIONS = resolveEffectiveSettings({}).segmentOptions;
 const INCLUDE = { git: false, pr: false, piStats: false, tokenRate: false, feeds: [SAVINGS] };
 /** Outside any repo, so the builder's git probes stay inert. */
 const CWD = "/tmp/pi-topping-statusline-tests";
+/** Match the builder's intentional prototype-less feed map in deep equality assertions. */
+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, "");
@@ -60,8 +67,11 @@ async function contextAfterEmitting(
 
 const BASE = await contextAfterEmitting(() => []);
 /** Render the segment against explicit feed config and payloads. */
-const renderFeeds = (feeds: StatusLineFeed[], feedData: Record<string, unknown> | undefined) =>
-	SEGMENTS.feeds.render({ ...BASE, options: { ...BASE.options, feeds }, feedData });
+const renderFeeds = (
+	feeds: StatusLineFeed[],
+	feedData: Record<string, unknown> | undefined,
+	feedDisplayState?: Record<string, FeedDisplayState>,
+) => SEGMENTS.feeds.render({ ...BASE, options: { ...BASE.options, feeds }, feedData, feedDisplayState });
 const savingsFeed = (format: StatusLineFeed["format"] = "currency", prefix = "CS"): StatusLineFeed => ({
 	customType: SAVINGS,
 	field: "savedUsd",
@@ -71,14 +81,39 @@ const savingsFeed = (format: StatusLineFeed["format"] = "currency", prefix = "CS
 const renderSaved = (value: unknown, format: StatusLineFeed["format"] = "currency") =>
 	renderFeeds([savingsFeed(format)], { [SAVINGS]: { savedUsd: value } });
 
+const FOOTER_PAINTERS = {
+	paint: (_row: number, _col: number, ch: string) => ch,
+	horizRun: (_row: number, _startCol: number, count: number) => "─".repeat(count),
+	gapColor: (str: string, _startCol: number, _row: number) => str,
+};
+
+/** Build the same one-row bottom-bar path used by index.ts for feed-only cases. */
+const renderFeedRows = (feedData: Record<string, unknown> | undefined, format: StatusLineFeed["format"] = "currency") => {
+	const feed = savingsFeed(format);
+	const settings = resolveEffectiveSettings({ feeds: [feed] });
+	const ctx: SegmentContext = { ...BASE, options: settings.segmentOptions, feedData };
+	const bar = buildStatusLine(74, ctx, settings, (str, _startCol, _row) => str, { left: [], right: ["feeds"] });
+	return renderBoxRowIfVisible(FOOTER_PAINTERS, bar, 2, 80, "╰", "╯");
+};
+
 // ── reading the feed ───────────────────────────────────────────────────────
 
 test("hidden when no publisher has emitted", async () => {
 	const ctx = await contextAfterEmitting(() => []);
-	assert.deepEqual(ctx.feedData, {});
+	assert.deepEqual(ctx.feedData, feedMap());
 	assert.equal(SEGMENTS.feeds.render(ctx).visible, false);
 });
 
+test("configured but unavailable or empty feeds reserve no footer row", () => {
+	assert.equal(renderFeedRows(undefined).length, 0);
+	assert.equal(renderFeedRows({}).length, 0);
+	assert.equal(renderFeedRows({ [SAVINGS]: {} }).length, 0);
+});
+
+test("a visible feed keeps the footer row", () => {
+	assert.equal(renderFeedRows({ [SAVINGS]: { savedUsd: 1.25 } }).length, 1);
+});
+
 test("a later custom_message sharing the customType cannot shadow a real entry", async () => {
 	// CustomMessageEntry carries customType too, but keeps its payload under
 	// details. Matching on customType alone would hit this newer entry first,
@@ -94,17 +129,17 @@ test("a later custom_message sharing the customType cannot shadow a real entry",
 		details: { savedUsd: 99 },
 	} as SessionEntry;
 	const ctx = await contextAfterEmitting(() => [feedEntry({ savedUsd: 4.2 }), decoy]);
-	assert.deepEqual(ctx.feedData, { [SAVINGS]: { savedUsd: 4.2 } });
+	assert.deepEqual(ctx.feedData, feedMap({ [SAVINGS]: { savedUsd: 4.2 } }));
 });
 
 test("unsubscribed customTypes are ignored", async () => {
 	const ctx = await contextAfterEmitting(() => [feedEntry({ savedUsd: 9 }, "other-ext/thing")]);
-	assert.deepEqual(ctx.feedData, {});
+	assert.deepEqual(ctx.feedData, feedMap());
 });
 
 test("the newest matching entry wins", async () => {
 	const ctx = await contextAfterEmitting(() => [feedEntry({ savedUsd: 0.5 }), feedEntry({ savedUsd: 1.2345 })]);
-	assert.deepEqual(ctx.feedData, { [SAVINGS]: { savedUsd: 1.2345 } });
+	assert.deepEqual(ctx.feedData, feedMap({ [SAVINGS]: { savedUsd: 1.2345 } }));
 });
 
 test("several feeds are collected in one pass and render together", async () => {
@@ -138,12 +173,121 @@ test("missing fields and malformed payloads do not surface", () => {
 	assert.equal(renderFeeds([savingsFeed()], { [SAVINGS]: 5 }).visible, false, "payload must be an object");
 });
 
+// ── stale-feed lifecycle ───────────────────────────────────────────────────
+
+test("feed display state changes at exact hold and fade boundaries", () => {
+	const changedAt = 1_000;
+	assert.deepEqual(getFeedDisplayState(changedAt, changedAt + FEED_HOLD_MS - 1), { phase: "active", fadeShade: 0 });
+	for (let shade = 0; shade < 5; shade++) {
+		assert.deepEqual(getFeedDisplayState(changedAt, changedAt + FEED_HOLD_MS + shade * (FEED_FADE_MS / 5)), {
+			phase: "fading",
+			fadeShade: shade,
+		});
+	}
+	assert.deepEqual(getFeedDisplayState(changedAt, changedAt + FEED_HOLD_MS + FEED_FADE_MS), {
+		phase: "hidden",
+		fadeShade: 4,
+	});
+});
+
+test("missing display state remains active, while fading and hidden feeds render independently", () => {
+	const count: StatusLineFeed = { customType: "my-ext/metrics", field: "count", prefix: "N", format: "number" };
+	const feeds = [savingsFeed(), count];
+	const data = { [SAVINGS]: { savedUsd: 1.5 }, "my-ext/metrics": { count: 42 } };
+	assert.equal(stripAnsi(renderFeeds(feeds, data).content), "CS$1.50 N42");
+
+	const states = {
+		[feedKey(SAVINGS, "savedUsd")]: { phase: "hidden", fadeShade: 4 },
+		[feedKey("my-ext/metrics", "count")]: { phase: "fading", fadeShade: 2 },
+	} satisfies Record<string, FeedDisplayState>;
+	const rendered = renderFeeds(feeds, data, states);
+	assert.equal(stripAnsi(rendered.content), "N42");
+	assert.equal(rendered.visible, true);
+	assert.equal(rendered.content, theme.fadeFg("dim", "statusLineBg", 2, "N42"));
+});
+
+test("tracking preserves equal values and resets changed values per field", () => {
+	const originalNow = Date.now;
+	let now = 1_000_000;
+	Date.now = () => now;
+	try {
+		const entries: SessionEntry[] = [];
+		const builder = new SegmentContextBuilder(fakePi);
+		builder.attach(fakeCtx(entries));
+		entries.push(feedEntry({ savedUsd: { total: 1 }, count: 2 }, SAVINGS, new Date(now).toISOString()));
+		const feeds: StatusLineFeed[] = [
+			{ customType: SAVINGS, field: "savedUsd", prefix: "A", format: "text" },
+			{ customType: SAVINGS, field: "count", prefix: "B", format: "number" },
+		];
+		const options = { ...OPTIONS, feeds };
+		let ctx = builder.build(80, options, INCLUDE, undefined);
+		assert.equal(ctx.feedDisplayState?.[feedKey(SAVINGS, "savedUsd")]?.phase, "active");
+
+		now += FEED_HOLD_MS + 1;
+		entries.push(feedEntry({ savedUsd: { total: 1 }, count: 2 }, SAVINGS, new Date(now).toISOString()));
+		ctx = builder.build(80, options, INCLUDE, undefined);
+		assert.equal(ctx.feedDisplayState?.[feedKey(SAVINGS, "savedUsd")]?.phase, "fading", "cloned equal object must not reset");
+		assert.equal(ctx.feedDisplayState?.[feedKey(SAVINGS, "count")]?.phase, "fading", "equal primitive must not reset");
+
+		now += 2_001;
+		entries.push(feedEntry({ savedUsd: { total: 2 }, count: 2 }, SAVINGS, new Date(now).toISOString()));
+		ctx = builder.build(80, options, INCLUDE, undefined);
+		assert.equal(ctx.feedDisplayState?.[feedKey(SAVINGS, "savedUsd")]?.phase, "active", "changed hidden/fading field reappears");
+		assert.equal(ctx.feedDisplayState?.[feedKey(SAVINGS, "count")]?.phase, "hidden", "fields sharing a publisher age independently");
+
+		now += 2_001;
+		entries.push(feedEntry({ savedUsd: { total: 2 } }, SAVINGS, new Date(now).toISOString()));
+		ctx = builder.build(80, options, INCLUDE, undefined);
+		assert.equal(ctx.feedDisplayState?.[feedKey(SAVINGS, "count")], undefined, "missing fields clear tracking");
+		ctx = builder.build(80, { ...options, feeds: [feeds[0]!] }, INCLUDE, undefined);
+		assert.equal(ctx.feedDisplayState?.[feedKey(SAVINGS, "count")], undefined, "removed subscriptions stay pruned");
+		builder.dispose();
+	} finally {
+		Date.now = originalNow;
+	}
+});
+
+test("feed transition timers request a render and are cleared by attach and dispose", () => {
+	const originalNow = Date.now;
+	const originalSetTimeout = globalThis.setTimeout;
+	const originalClearTimeout = globalThis.clearTimeout;
+	let scheduled: (() => void) | undefined;
+	let cleared = 0;
+	Date.now = () => 1_000_000;
+	globalThis.setTimeout = ((callback: () => void) => {
+		scheduled = callback;
+		return { unref() {} } as unknown as ReturnType<typeof setTimeout>;
+	}) as typeof setTimeout;
+	globalThis.clearTimeout = (() => {
+		cleared++;
+	}) as typeof clearTimeout;
+	try {
+		const entries = [feedEntry({ savedUsd: 1 }, SAVINGS, new Date(Date.now()).toISOString())];
+		const builder = new SegmentContextBuilder(fakePi);
+		let renders = 0;
+		builder.setRequestRender(() => renders++);
+		builder.attach(fakeCtx(entries));
+		builder.build(80, OPTIONS, INCLUDE, undefined);
+		assert.ok(scheduled, "an active feed schedules its stale transition");
+		scheduled?.();
+		assert.equal(renders, 1, "the transition wakes the renderer");
+		builder.attach(fakeCtx(entries));
+		builder.build(80, OPTIONS, INCLUDE, undefined);
+		builder.dispose();
+		assert.ok(cleared >= 2, "attach and dispose clear pending feed timers");
+	} finally {
+		Date.now = originalNow;
+		globalThis.setTimeout = originalSetTimeout;
+		globalThis.clearTimeout = originalClearTimeout;
+	}
+});
+
 // ── the per-run reset ──────────────────────────────────────────────────────
 
 test("entries predating this run are stale and render nothing", async () => {
 	const priorRun = new Date(Date.now() - 60_000).toISOString();
 	const ctx = await contextAfterEmitting(() => [feedEntry({ savedUsd: 7.77 }, SAVINGS, priorRun)]);
-	assert.deepEqual(ctx.feedData, {}, "a prior run's figure must not surface");
+	assert.deepEqual(ctx.feedData, feedMap(), "a prior run's figure must not surface");
 });
 
 test("the first emission of the new run supersedes a stale one", async () => {
@@ -152,7 +296,7 @@ test("the first emission of the new run supersedes a stale one", async () => {
 		feedEntry({ savedUsd: 7.77 }, SAVINGS, priorRun),
 		feedEntry({ savedUsd: 0.42 }),
 	]);
-	assert.deepEqual(ctx.feedData, { [SAVINGS]: { savedUsd: 0.42 } });
+	assert.deepEqual(ctx.feedData, feedMap({ [SAVINGS]: { savedUsd: 0.42 } }));
 });
 
 test("session replacement inside the TTL window drops the cached payload", async () => {
@@ -162,7 +306,7 @@ test("session replacement inside the TTL window drops the cached payload", async
 	builder.attach(fakeCtx(entries));
 	await sleep(3);
 	entries.push(feedEntry({ savedUsd: 4.2 }));
-	assert.deepEqual(builder.build(80, OPTIONS, INCLUDE, undefined).feedData, { [SAVINGS]: { savedUsd: 4.2 } });
+	assert.deepEqual(builder.build(80, OPTIONS, INCLUDE, undefined).feedData, feedMap({ [SAVINGS]: { savedUsd: 4.2 } }));
 
 	// /new, /resume and /fork replace the session in-process; publishers reset,
 	// so the entries above now belong to a previous run.
@@ -170,7 +314,7 @@ test("session replacement inside the TTL window drops the cached payload", async
 	builder.attach(fakeCtx(entries));
 	assert.deepEqual(
 		builder.build(80, OPTIONS, INCLUDE, undefined).feedData,
-		{},
+		feedMap(),
 		"must rescan on attach rather than serve the prior session's payload",
 	);
 });
@@ -186,7 +330,7 @@ test("no stale frame is observable across the whole TTL window", async () => {
 	await sleep(3);
 	builder.attach(fakeCtx(entries));
 	for (let frame = 0; frame < 10; frame++) {
-		assert.deepEqual(builder.build(80, OPTIONS, INCLUDE, undefined).feedData, {}, `frame ${frame} leaked`);
+		assert.deepEqual(builder.build(80, OPTIONS, INCLUDE, undefined).feedData, feedMap(), `frame ${frame} leaked`);
 		await sleep(30);
 	}
 });
@@ -231,7 +375,7 @@ test("changing the subscription list rescans without waiting out the TTL", async
 	// Adding a feed in the settings menu must take effect on the next frame.
 	const ctx = builder.build(80, OPTIONS, { ...INCLUDE, feeds: [SAVINGS, "my-ext/tokens"] }, undefined);
 	assert.equal(scans, 2);
-	assert.deepEqual(ctx.feedData, { [SAVINGS]: { savedUsd: 1 }, "my-ext/tokens": { count: 7 } });
+	assert.deepEqual(ctx.feedData, feedMap({ [SAVINGS]: { savedUsd: 1 }, "my-ext/tokens": { count: 7 } }));
 });
 
 test("a fresh emission appears once the TTL lapses", async () => {
@@ -242,9 +386,9 @@ test("a fresh emission appears once the TTL lapses", async () => {
 
 	await sleep(3);
 	entries.push(feedEntry({ savedUsd: 0.01 }));
-	assert.deepEqual(builder.build(80, OPTIONS, INCLUDE, undefined).feedData, {}, "still inside the TTL");
+	assert.deepEqual(builder.build(80, OPTIONS, INCLUDE, undefined).feedData, feedMap(), "still inside the TTL");
 	await sleep(2_100);
-	assert.deepEqual(builder.build(80, OPTIONS, INCLUDE, undefined).feedData, { [SAVINGS]: { savedUsd: 0.01 } });
+	assert.deepEqual(builder.build(80, OPTIONS, INCLUDE, undefined).feedData, feedMap({ [SAVINGS]: { savedUsd: 0.01 } }));
 });
 
 // ── formats ────────────────────────────────────────────────────────────────
@@ -260,6 +404,11 @@ test("currency hides sub-cent and negative values, matching the publisher's own
 	}
 });
 
+test("format-suppressed feed values reserve no footer row", () => {
+	assert.equal(renderFeedRows({ [SAVINGS]: { savedUsd: 0.0049 } }).length, 0);
+	assert.equal(renderFeedRows({ [SAVINGS]: { savedUsd: "" } }, "text").length, 0);
+});
+
 test("no $0.00 artifact is reachable near the crossing", () => {
 	for (let value = -0.05; value <= 0.05; value += 0.0001) {
 		assert.ok(!stripAnsi(renderSaved(value).content).includes("$0.00"), `rendered $0.00 at ${value}`);

package/src/tests/footer.test.ts

@@ -7,7 +7,13 @@
  */
 import assert from "node:assert/strict";
 import test from "node:test";
-import { isBorderRow, stripAnsi, stripRedundantStats } from "../footer.ts";
+import {
+	collapseFooterLayoutSlot,
+	filterVisibleRows,
+	isBorderRow,
+	stripAnsi,
+	stripRedundantStats,
+} from "../footer.ts";
 
 test("isBorderRow accepts a plain border run", () => {
 	assert.equal(isBorderRow("─────"), true);
@@ -35,6 +41,29 @@ test("stripAnsi removes SGR sequences only", () => {
 	assert.equal(stripAnsi("\x1b[32mgreen\x1b[0m plain"), "green plain");
 });
 
+test("filterVisibleRows drops empty notifications but keeps visible rows", () => {
+	assert.deepEqual(filterVisibleRows(["", "  ", "\x1b[32m\x1b[0m", "saved $1.23"]), ["saved $1.23"]);
+});
+
+test("fullscreen footer slot can collapse and restores its minimum", () => {
+	const footer = { render: () => [] };
+	const footerContainer = { children: [footer] };
+	const footerEntry = { component: footerContainer, minSize: 1 };
+	const dock = { entries: [{ component: {} }, footerEntry] };
+	const root = { entries: [{ component: {} }, { component: dock, minSize: 1 }] };
+
+	const restore = collapseFooterLayoutSlot(root, footer);
+	assert.equal(footerEntry.minSize, 0);
+	assert.equal(root.entries[1]?.minSize, 1, "must not collapse the whole dock");
+	restore?.();
+	assert.equal(footerEntry.minSize, 1);
+});
+
+test("inline layouts without a footer slot are left untouched", () => {
+	assert.equal(collapseFooterLayoutSlot(undefined, {}), undefined);
+	assert.equal(collapseFooterLayoutSlot({ children: [] }, {}), undefined);
+});
+
 test("stripRedundantStats passes undefined through", () => {
 	assert.equal(stripRedundantStats(undefined), undefined);
 });