@underactive/pi-topping-statusline 0.1.3 → 0.1.4

package/README.md

@@ -129,7 +129,10 @@ early in a session, before the cache-write premium is amortized by reads. Above
 
 A feed contributes nothing when its publisher is absent, has published nothing this run, or
 reports a value its format suppresses; the segment disappears entirely once every feed is
-quiet, so it costs nothing to leave switched on. Publishers typically reset per process run,
+quiet, so it costs nothing to leave switched on. Feed values are shown in dim text; a value
+that remains unchanged for five minutes fades into the statusline background over 500ms and
+then hides. It reappears in dim text only when that configured field's value changes.
+Publishers typically reset per process run,
 so entries predating the current session start (`--resume`, `/reload`, `/new`, fork) are
 ignored rather than shown as a stale total. During steady-state rendering, the session is
 re-read at most once every two seconds, because pi copies the whole entry list on each read

package/index.ts

@@ -25,9 +25,15 @@ import {
 	type ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
 import type { Component, TUI } from "@earendil-works/pi-tui";
-import { makeBoxPainters, renderBoxRow } from "./src/box.js";
+import { makeBoxPainters, renderBoxRow, renderBoxRowIfVisible } from "./src/box.js";
 import { SegmentContextBuilder } from "./src/context.js";
-import { isBorderRow, stripAnsi, stripRedundantStats } from "./src/footer.js";
+import {
+	collapseFooterLayoutSlot,
+	filterVisibleRows,
+	isBorderRow,
+	stripAnsi,
+	stripRedundantStats,
+} from "./src/footer.js";
 import { buildStatusLine } from "./src/layout.js";
 import { RAINBOW_DEG_PER_FRAME, RAINBOW_FRAME_MS, RainbowBorder } from "./src/rainbow.js";
 import { registerSettingsCommand } from "./src/settings-menu.js";
@@ -47,6 +53,7 @@ export default function (pi: ExtensionAPI) {
 	let ensureTimer: ReturnType<typeof setInterval> | undefined;
 	let patchedFooter: Component | undefined;
 	let footerRenderOriginal: ((width: number) => string[]) | undefined;
+	let restoreFooterLayout: (() => void) | undefined;
 
 	const requestRender = () => activeTui?.requestRender();
 	builder.setRequestRender(requestRender);
@@ -149,7 +156,7 @@ export default function (pi: ExtensionAPI) {
 			},
 			{ col: 3, row: bottomIdx },
 		);
-		out.push(renderBoxRow(painters, bottomBar, bottomIdx, width, box.bottomLeft, box.bottomRight));
+		out.push(...renderBoxRowIfVisible(painters, bottomBar, bottomIdx, width, box.bottomLeft, box.bottomRight));
 		for (let i = bottomIdx + 1; i < lines.length; i++) {
 			out.push(`  ${lines[i]}`);
 		}
@@ -163,7 +170,21 @@ export default function (pi: ExtensionAPI) {
 				? inner(tui, editorTheme, keybindings)
 				: new CustomEditor(tui, editorTheme, keybindings);
 			const innerRender = editor.render.bind(editor);
-			editor.render = width => renderBoxed(innerRender, width, editor);
+			let boxRenderFailed = false;
+			editor.render = width => {
+				try {
+					return renderBoxed(innerRender, width, editor);
+				} catch (err) {
+					if (!boxRenderFailed) {
+						boxRenderFailed = true;
+						activeCtx?.ui.notify(
+							`Statusline render failed, using plain editor: ${err instanceof Error ? err.message : String(err)}`,
+							"error",
+						);
+					}
+					return innerRender(width);
+				}
+			};
 			return editor;
 		};
 	};
@@ -212,17 +233,23 @@ export default function (pi: ExtensionAPI) {
 	// its cwd and stats lines, which the box now carries itself.
 	const ensureFooterPatched = () => {
 		const tui = activeTui;
-		if (!tui || patchedFooter) return;
-		let footer: Component | undefined;
-		for (const child of tui.children) {
-			footer = findFooter(child);
-			if (footer) break;
+		if (!tui) return;
+		if (!patchedFooter) {
+			let footer: Component | undefined;
+			for (const child of tui.children) {
+				footer = findFooter(child);
+				if (footer) break;
+			}
+			if (!footer) return;
+			const orig = footer.render.bind(footer);
+			footerRenderOriginal = orig;
+			footer.render = width => filterVisibleRows(orig(width).slice(2));
+			patchedFooter = footer;
+		}
+		if (!restoreFooterLayout) {
+			const layoutRoot = (tui as unknown as { layoutRoot?: unknown }).layoutRoot;
+			restoreFooterLayout = collapseFooterLayoutSlot(layoutRoot, patchedFooter);
 		}
-		if (!footer) return;
-		const orig = footer.render.bind(footer);
-		footerRenderOriginal = orig;
-		footer.render = width => orig(width).slice(2);
-		patchedFooter = footer;
 	};
 
 	pi.on("model_select", () => requestRender());
@@ -267,8 +294,10 @@ export default function (pi: ExtensionAPI) {
 		if (patchedFooter && footerRenderOriginal) {
 			patchedFooter.render = footerRenderOriginal;
 		}
+		restoreFooterLayout?.();
 		patchedFooter = undefined;
 		footerRenderOriginal = undefined;
+		restoreFooterLayout = undefined;
 		ourFactory = undefined;
 		wrappedFactory = undefined;
 		activeTui = undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@underactive/pi-topping-statusline",
-	"version": "0.1.3",
+	"version": "0.1.4",
 	"description": "oh-my-pi's powerline statusline as a pi extension with some customizations",
 	"keywords": [
 		"pi-package",
@@ -45,9 +45,9 @@
 		"@earendil-works/pi-tui": "*"
 	},
 	"devDependencies": {
-		"@earendil-works/pi-ai": "0.80.10",
-		"@earendil-works/pi-coding-agent": "0.80.10",
-		"@earendil-works/pi-tui": "0.80.10",
+		"@earendil-works/pi-ai": "0.84.4",
+		"@earendil-works/pi-coding-agent": "0.84.4",
+		"@earendil-works/pi-tui": "0.84.4",
 		"@types/node": "^22.0.0",
 		"typescript": "^5.7.0"
 	}

package/src/box.ts

@@ -9,6 +9,7 @@
  * (host borderColor vs menu theme; shared stepped animator vs phase-from-
  * elapsed instance).
  */
+import { stripVTControlCharacters } from "node:util";
 import { visibleWidth } from "@earendil-works/pi-tui";
 import { perimeterLength, perimeterPosition, type RainbowBorder } from "./rainbow.js";
 import type { BoxGlyphs } from "./theme.js";
@@ -67,3 +68,17 @@ export function renderBoxRow(
 		painters.paint(rowIdx, boxWidth - 1, rightGlyph)
 	);
 }
+
+/** Render a box row only when its bar contains visible, non-whitespace content. */
+export function renderBoxRowIfVisible(
+	painters: BoxPainters,
+	bar: string,
+	rowIdx: number,
+	boxWidth: number,
+	leftGlyph: string,
+	rightGlyph: string,
+): string[] {
+	const plainBar = stripVTControlCharacters(bar);
+	if (plainBar.trim().length === 0) return [];
+	return [renderBoxRow(painters, bar, rowIdx, boxWidth, leftGlyph, rightGlyph)];
+}

package/src/context.ts

@@ -7,8 +7,11 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { isDeepStrictEqual } from "node:util";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { SegmentContext, SegmentIncludes, StatusLineSegmentOptions, TokenRateDisplay } from "./types.js";
+import { FADE_SHADE_COUNT } from "./theme.js";
+import type { FeedDisplayState, SegmentContext, SegmentIncludes, StatusLineSegmentOptions, TokenRateDisplay } from "./types.js";
+import { feedKey } from "./utils.js";
 
 const GIT_STATUS_TTL_MS = 1_000;
 const BRANCH_POLL_TTL_MS = 5_000;
@@ -16,6 +19,10 @@ const EXEC_TIMEOUT_MS = 2_000;
 
 /** getEntries() filters and copies the whole session, so rescans are rate-limited. */
 const FEED_TTL_MS = 2_000;
+/** Unchanged feed values remain fully visible for five minutes. */
+export const FEED_HOLD_MS = 5 * 60 * 1_000;
+/** Match the existing token-rate fade cadence. */
+export const FEED_FADE_MS = 500;
 
 /** Prototype-less map — feed keys are publisher-supplied customTypes. */
 const emptyFeedData = (): Record<string, unknown> => Object.create(null);
@@ -32,6 +39,22 @@ interface RepoInfo {
 	toplevel: string;
 }
 
+interface FeedTracking {
+	value: unknown;
+	changedAt: number;
+}
+
+/** Pure feed lifecycle snapshot, including a clock moving backwards. */
+export function getFeedDisplayState(changedAt: number, now: number): FeedDisplayState {
+	const elapsed = Math.max(0, now - changedAt);
+	if (elapsed < FEED_HOLD_MS) return { phase: "active", fadeShade: 0 };
+	if (elapsed >= FEED_HOLD_MS + FEED_FADE_MS) return { phase: "hidden", fadeShade: FADE_SHADE_COUNT - 1 };
+	return {
+		phase: "fading",
+		fadeShade: Math.min(FADE_SHADE_COUNT - 1, Math.floor((elapsed - FEED_HOLD_MS) / (FEED_FADE_MS / FADE_SHADE_COUNT))),
+	};
+}
+
 function deriveContextUsage(ctx: ExtensionContext | undefined): {
 	contextWindow: number;
 	tokens: number | undefined;
@@ -90,8 +113,11 @@ export class SegmentContextBuilder {
 
 	#feedData: Record<string, unknown> = emptyFeedData();
 	#feedsScannedAt = 0;
-	#feedsScanned = "";
+	#feedsScannedRef: readonly string[] | undefined;
 	#runStartedAt = 0;
+	#feedTracking = new Map<string, FeedTracking>();
+	#feedTimer: ReturnType<typeof setTimeout> | undefined;
+	#feedTimerAt: number | undefined;
 
 	constructor(pi: ExtensionAPI) {
 		this.#pi = pi;
@@ -118,7 +144,8 @@ export class SegmentContextBuilder {
 		this.#runStartedAt = Date.now();
 		this.#feedData = emptyFeedData();
 		this.#feedsScannedAt = 0;
-		this.#feedsScanned = "";
+		this.#feedsScannedRef = undefined;
+		this.#clearFeedLifecycle();
 		if (this.#repoCwd !== ctx.cwd) {
 			this.#resetGitState();
 			this.#repoCwd = ctx.cwd;
@@ -131,6 +158,14 @@ export class SegmentContextBuilder {
 		this.#headWatcher = undefined;
 		this.#watcherOk = false;
 		this.#ctx = undefined;
+		this.#clearFeedLifecycle();
+	}
+
+	#clearFeedLifecycle(): void {
+		this.#feedTracking.clear();
+		if (this.#feedTimer) clearTimeout(this.#feedTimer);
+		this.#feedTimer = undefined;
+		this.#feedTimerAt = undefined;
 	}
 
 	// ── git plumbing ─────────────────────────────────────────────────────────
@@ -288,6 +323,55 @@ export class SegmentContextBuilder {
 		}
 	}
 
+	#syncFeedTracking(feeds: StatusLineSegmentOptions["feeds"], now: number): Record<string, FeedDisplayState> {
+		const configured = new Set<string>();
+		for (const feed of feeds) {
+			const key = feedKey(feed.customType, feed.field);
+			configured.add(key);
+			const payload = this.#feedData[feed.customType];
+			if (payload === null || typeof payload !== "object" || !Object.hasOwn(payload, feed.field)) {
+				this.#feedTracking.delete(key);
+				continue;
+			}
+			const value = (payload as Record<string, unknown>)[feed.field];
+			const prior = this.#feedTracking.get(key);
+			if (!prior || !isDeepStrictEqual(prior.value, value)) this.#feedTracking.set(key, { value, changedAt: now });
+		}
+		for (const key of this.#feedTracking.keys()) {
+			if (!configured.has(key)) this.#feedTracking.delete(key);
+		}
+
+		const states: Record<string, FeedDisplayState> = Object.create(null);
+		for (const [key, tracking] of this.#feedTracking) states[key] = getFeedDisplayState(tracking.changedAt, now);
+		this.#scheduleFeedTransition(now);
+		return states;
+	}
+
+	#scheduleFeedTransition(now: number): void {
+		let nextAt: number | undefined;
+		for (const { changedAt } of this.#feedTracking.values()) {
+			const display = getFeedDisplayState(changedAt, now);
+			if (display.phase === "hidden") continue;
+			const next =
+				display.phase === "active"
+					? changedAt + FEED_HOLD_MS
+					: changedAt + FEED_HOLD_MS + (display.fadeShade + 1) * (FEED_FADE_MS / FADE_SHADE_COUNT);
+			if (nextAt === undefined || next < nextAt) nextAt = next;
+		}
+		if (this.#feedTimer && this.#feedTimerAt === nextAt) return;
+		if (this.#feedTimer) clearTimeout(this.#feedTimer);
+		this.#feedTimer = undefined;
+		this.#feedTimerAt = nextAt;
+		if (nextAt === undefined) return;
+		this.#feedTimer = setTimeout(() => {
+			this.#feedTimer = undefined;
+			this.#feedTimerAt = undefined;
+			this.#requestRender();
+			this.#scheduleFeedTransition(Date.now());
+		}, Math.max(1, nextAt - now));
+		this.#feedTimer.unref?.();
+	}
+
 	async #refreshPr(): Promise<void> {
 		const cwd = this.#repoCwd;
 		const branch = this.#branch;
@@ -350,13 +434,16 @@ export class SegmentContextBuilder {
 			if (include.pr) void this.#refreshPr();
 		}
 
+		let feedDisplayState: Record<string, FeedDisplayState> | undefined;
 		if (include.feeds.length > 0) {
 			// Editing the subscription list mid-session must not wait out the TTL.
-			const key = include.feeds.join("\u0000");
-			if (key !== this.#feedsScanned || now - this.#feedsScannedAt > FEED_TTL_MS) {
-				this.#feedsScanned = key;
+			if (include.feeds !== this.#feedsScannedRef || now - this.#feedsScannedAt > FEED_TTL_MS) {
+				this.#feedsScannedRef = include.feeds;
 				this.#refreshFeeds(include.feeds, now);
 			}
+			feedDisplayState = this.#syncFeedTracking(options.feeds, now);
+		} else {
+			this.#clearFeedLifecycle();
 		}
 
 		const model = ctx?.model
@@ -388,7 +475,8 @@ export class SegmentContextBuilder {
 			scrollHint,
 			piStats: include.piStats ? this.#piStatsProvider?.(width) : undefined,
 			tokenRate: include.tokenRate ? this.#tokenRateProvider?.() : undefined,
-			feedData: include.feeds.length > 0 ? { ...this.#feedData } : undefined,
+			feedData: include.feeds.length > 0 ? this.#feedData : undefined,
+			feedDisplayState,
 		};
 	}
 }

package/src/footer.ts

@@ -8,6 +8,52 @@ export function stripAnsi(str: string): string {
 	return str.replace(ANSI_RE, "");
 }
 
+/** Drop host footer rows that contain only whitespace or SGR control codes. */
+export function filterVisibleRows(rows: readonly string[]): string[] {
+	return rows.filter(row => stripAnsi(row).trim().length > 0);
+}
+
+interface LayoutEntry {
+	component: unknown;
+	minSize?: number;
+}
+
+function containsComponent(node: unknown, target: unknown, seen: Set<unknown>): boolean {
+	if (node === target) return true;
+	if (!node || typeof node !== "object" || seen.has(node)) return false;
+	seen.add(node);
+	const children = (node as { children?: unknown }).children;
+	return Array.isArray(children) && children.some(child => containsComponent(child, target, seen));
+}
+
+/**
+ * Let Pi's fullscreen footer slot collapse when its component renders no rows.
+ * Pi 0.84 gives that VStack entry minSize=1, independently of render output.
+ */
+export function collapseFooterLayoutSlot(layoutRoot: unknown, footer: unknown): (() => void) | undefined {
+	const seen = new Set<unknown>();
+	const find = (node: unknown): LayoutEntry | undefined => {
+		if (!node || typeof node !== "object" || seen.has(node)) return undefined;
+		seen.add(node);
+		const entries = (node as { entries?: unknown }).entries;
+		if (!Array.isArray(entries)) return undefined;
+		for (const entry of entries as LayoutEntry[]) {
+			const nested = find(entry.component);
+			if (nested) return nested;
+		}
+		return (entries as LayoutEntry[]).find(entry => containsComponent(entry.component, footer, new Set()));
+	};
+
+	const entry = find(layoutRoot);
+	if (!entry) return undefined;
+	const previous = entry.minSize;
+	entry.minSize = 0;
+	return () => {
+		if (previous === undefined) delete entry.minSize;
+		else entry.minSize = previous;
+	};
+}
+
 export function isBorderRow(row: string): boolean {
 	const text = stripAnsi(row);
 	return /^─+$/.test(text) || /^─+ [↑↓] \d+ more\s*─*$/.test(text);

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 };
 	},
 };
 

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);
 });

package/src/theme.ts

@@ -178,7 +178,6 @@ type ColorValue = string | number;
 
 export type StatusColor =
 	| "accent"
-	| "success"
 	| "error"
 	| "warning"
 	| "muted"
@@ -193,11 +192,13 @@ export type StatusColor =
 	| "statusLineContextElevated"
 	| "statusLineStaged"
 	| "statusLineDirty"
-	| "statusLineUntracked";
+	| "statusLineUntracked"
+	| "statusLineBg";
+
+const STATUS_LINE_BG: ColorValue = "#121212";
 
 const FG_COLORS: Record<StatusColor, ColorValue> = {
 	accent: "#febc38",
-	success: "#89d281",
 	error: "#fc3a4b",
 	warning: "#e4c00f",
 	muted: "#777d88",
@@ -213,10 +214,9 @@ const FG_COLORS: Record<StatusColor, ColorValue> = {
 	statusLineStaged: 70,
 	statusLineDirty: 178,
 	statusLineUntracked: 39,
+	statusLineBg: STATUS_LINE_BG,
 };
 
-const STATUS_LINE_BG: ColorValue = "#121212";
-
 /** Dominant palette hexes the session accent must not collide with. */
 export const MAJOR_COLOR_HEXES = [
 	"#febc38",
@@ -246,7 +246,7 @@ export function parseHex(hex: string): [number, number, number] | undefined {
 	return [(n >> 16) & 0xff, (n >> 8) & 0xff, n & 0xff];
 }
 
-/** Number of discrete, eased shades used for the token-rate fade (pi-topping). */
+/** Number of discrete, eased shades used for the token-rate and feed fades (pi-topping). */
 export const FADE_SHADE_COUNT = 5;
 
 /** Resolve an xterm-256 palette index to RGB (16–231 cube, 232–255 grayscale). */
@@ -275,11 +275,14 @@ function rgbTo256(r: number, g: number, b: number): number {
 	return 16 + 36 * scale(r) + 6 * scale(g) + scale(b);
 }
 
+function rgbToFgAnsi(r: number, g: number, b: number, mode: ColorMode): string {
+	return mode === "truecolor" ? `\x1b[38;2;${r};${g};${b}m` : `\x1b[38;5;${rgbTo256(r, g, b)}m`;
+}
+
 export function hexToFgAnsi(hex: string, mode: ColorMode = detectColorMode()): string {
 	const rgb = parseHex(hex);
 	if (!rgb) return "";
-	const [r, g, b] = rgb;
-	return mode === "truecolor" ? `\x1b[38;2;${r};${g};${b}m` : `\x1b[38;5;${rgbTo256(r, g, b)}m`;
+	return rgbToFgAnsi(...rgb, mode);
 }
 
 function fgAnsi(color: ColorValue, mode: ColorMode): string {
@@ -361,8 +364,7 @@ class StatusTheme {
 		const r = Math.round(a[0] * (1 - eased) + b[0] * eased);
 		const g = Math.round(a[1] * (1 - eased) + b[1] * eased);
 		const bl = Math.round(a[2] * (1 - eased) + b[2] * eased);
-		const ansi =
-			this.#mode === "truecolor" ? `\x1b[38;2;${r};${g};${bl}m` : `\x1b[38;5;${rgbTo256(r, g, bl)}m`;
+		const ansi = rgbToFgAnsi(r, g, bl, this.#mode);
 		return `${ansi}${text}\x1b[39m`;
 	}
 }

package/src/types.ts

@@ -142,6 +142,19 @@ export interface SegmentContext {
 	 * entries, and those must not be shown as current.
 	 */
 	feedData: Record<string, unknown> | undefined;
+	/**
+	 * Lifecycle state per configured feed field. Missing state is treated as
+	 * active so previews and manually constructed contexts retain full color.
+	 */
+	feedDisplayState?: Record<string, FeedDisplayState>;
+}
+
+export type FeedPhase = "active" | "fading" | "hidden";
+
+export interface FeedDisplayState {
+	phase: FeedPhase;
+	/** Discrete fade step (0..FADE_SHADE_COUNT-1); meaningful while fading. */
+	fadeShade: number;
 }
 
 export type TokenRatePhase = "active" | "fading" | "idle";

package/src/utils.ts

@@ -65,10 +65,7 @@ export function clampPathLength(pwd: string, maxLen: number): string {
 
 /** Strip ANSI/VT escapes, map control chars to spaces, collapse whitespace. */
 export function sanitizeStatusText(text: string): string {
-	return stripVTControlCharacters(text)
-		.replace(/[\u0000-\u001f\u007f-\u009f]/g, " ")
-		.replace(/ +/g, " ")
-		.trim();
+	return sanitizeLabel(text).trim();
 }
 
 /**
@@ -77,7 +74,7 @@ export function sanitizeStatusText(text: string): string {
  */
 export function sanitizeLabel(text: string): string {
 	return stripVTControlCharacters(text)
-		.replace(/[\u0000-\u001f\u007f-\u009f]/g, " ")
+		.replace(/[\u0000-\u001f\u007f-\u009f\u200b-\u200f\u2028\u2029\u202a-\u202e\u2066-\u2069\ufeff]/g, " ")
 		.replace(/ +/g, " ");
 }
 
@@ -85,6 +82,11 @@ export function withIcon(icon: string, text: string): string {
 	return icon ? `${icon} ${text}` : text;
 }
 
+/** Unambiguous identity for one configured field of a feed publisher. */
+export function feedKey(customType: string, field: string): string {
+	return `${customType}\u0000${field}`;
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Session accent (djb2 hue hash, dark warm band, collision avoidance)
 // ═══════════════════════════════════════════════════════════════════════════