@underactive/pi-topping-statusline 0.1.3 → 0.2.0

package/README.md

@@ -42,6 +42,7 @@ and apply live.
 ║    Border style                                   ‹ rounded ›  ║
 ║    [■] Rainbow border on max thinking                      ON  ║
 ║    [■] Animate rainbow border                              ON  ║
+║    [ ] Embed 'Working' indicator                           OFF ║
 ║                                                                ║
 ╟─ Top Left Segment Group ───────────────────────────────────────╢
 ║    [■] Pi symbol                                           ON  ║
@@ -66,18 +67,18 @@ and apply live.
 ║    + add feed                                                  ║
 ║                                                                ║
 ║  ↑↓ move  ←→ cycle  ␣ toggle  ⏎ apply/edit  esc cancel         ║
-╚════════════════════════════════════════════════════════[ 1/29 ]╝
+╚════════════════════════════════════════════════════════[ 1/30 ]╝
 ```
 
 | Section | Settings |
 | --- | --- |
-| Global | Transparent Segments · Separator (`powerline` `powerline-thin` `slash` `pipe` `ascii`) · Symbols (`nerdfont` `unicode` `ascii` — stored in settings.json as `nerd`/`unicode`/`ascii`) · Border style (`rounded` `heavy` `double` `single`) · Rainbow border on max thinking · Animate rainbow border |
+| Global | Transparent Segments · Separator (`powerline` `powerline-thin` `slash` `pipe` `ascii`) · Symbols (`nerdfont` `unicode` `ascii` — stored in settings.json as `nerd`/`unicode`/`ascii`) · Border style (`rounded` `heavy` `double` `single`) · Rainbow border on max thinking · Animate rainbow border · Embed 'Working' indicator |
 | Top Left Segment Group | Pi symbol · Model · Provider · Thinking level · Path · Git · PR |
 | Top Right Segment Group | Token rate · Session name |
 | Bottom Right Segment Group | Feeds · Token rate · Pi stats · Context bar · Context stats |
 | Bottom Left Segment Group | Scroll hint · Feeds · Token rate |
 | Feeds | One subscription per row: type · field · prefix · format, plus add/remove |
-| Defaults | Transparent on · Separator `powerline-thin` · Symbols `nerdfont` · Border style `rounded` · Rainbow border on · Animate rainbow border on |
+| Defaults | Transparent on · Separator `powerline-thin` · Symbols `nerdfont` · Border style `rounded` · Rainbow border on · Animate rainbow border on · Embed 'Working' indicator off |
 
 With **Rainbow border on max thinking** on (the default), cycling the thinking level to `max`
 replaces the border's fixed theme color with a rainbow: a full hue cycle distributed around the
@@ -87,6 +88,17 @@ the rainbow at a fixed color phase without its repaint timer; the settings previ
 phase too. Any other thinking level keeps the normal theme border color. Disable animation over
 slow SSH links or in terminals with expensive redraws while retaining the rainbow border.
 
+**Embed 'Working' indicator** (off by default) moves pi's streaming status — spinner, message,
+and any loader text a topping such as pi-topping supplies — out of its own row and into the
+top-left group, right after the Pi symbol and its chevron. The remaining left segments (model,
+path, git, PR) step aside while a response streams and return when it ends; the Pi symbol never
+moves. The status appears instantly when a stream starts; when it ends, the swap back
+cross-fades over 750ms (the status sinks into the bar background, then the user's segments
+rise out of it) rather than cutting. A status too long for the bar is truncated without an ellipsis, as pi's own border does.
+Requires pi 0.85 or later. Toggling the setting reinstalls the editor through pi, so it applies
+immediately, even mid-response. Only the statusline's own editor opts in: when another
+extension owns the editor slot and is wrapped, pi keeps its standalone working row.
+
 ## Segments
 
 Ported with pi data: `pi`, `model` (model · provider · thinking level), `path`
@@ -129,7 +141,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,17 +25,28 @@ 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";
-import { createSettingsState } from "./src/settings.js";
+import { createSettingsState, topLeftSegments } from "./src/settings.js";
+import { easeFade } from "./src/theme.js";
 import { theme } from "./src/theme.js";
 import { TokenRateMonitor } from "./src/token-rate.js";
 type EditorFactory = NonNullable<ReturnType<ExtensionContext["ui"]["getEditorComponent"]>>;
 
+/** Cross-fade budget when the embedded working status disappears: half out, half in. */
+const WORKING_FADE_MS = 750;
+const WORKING_FADE_FRAME_MS = 15;
+
 export default function (pi: ExtensionAPI) {
 	const state = createSettingsState();
 	const builder = new SegmentContextBuilder(pi);
@@ -47,9 +58,78 @@ 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;
+	// The CustomEditor this extension constructed itself (undefined when it wraps
+	// another extension's editor), and the host's working indicator captured
+	// from that editor while a response streams.
+	let activeEditor: CustomEditor | undefined;
+	let embeddedWorkingStatus: ((width: number) => string) | undefined;
+	// Fade from the working status back to the user's left segments when a
+	// stream ends. The last status text is kept so the outgoing half still has
+	// something to fade after pi has cleared its indicator.
+	let workingShown = false;
+	let lastWorkingText: string | undefined;
+	let workingFade: { start: number } | undefined;
+	let workingFadeTimer: ReturnType<typeof setInterval> | undefined;
+	const stopWorkingFadeTimer = (): void => {
+		if (workingFadeTimer) clearInterval(workingFadeTimer);
+		workingFadeTimer = undefined;
+	};
+
+	const syncEmbed = (): void => {
+		const ctx = activeCtx;
+		const factory = ourFactory;
+		if (!activeEditor || !ctx || !factory) return;
+		const next = state.effective.embedWorkingStatus;
+		if (activeEditor.embedWorkingStatus === next) return;
+		ctx.ui.setEditorComponent(factory);
+	};
 
 	const requestRender = () => activeTui?.requestRender();
 	builder.setRequestRender(requestRender);
+	const startWorkingFadeTimer = (): void => {
+		if (workingFadeTimer) return;
+		workingFadeTimer = setInterval(() => {
+			if (!workingFade || Date.now() - workingFade.start >= WORKING_FADE_MS) {
+				workingFade = undefined;
+				stopWorkingFadeTimer();
+			}
+			requestRender();
+		}, WORKING_FADE_FRAME_MS);
+		workingFadeTimer.unref?.();
+	};
+
+	/**
+	 * Which left group this frame shows and how far it has faded. A stream
+	 * starting shows the working status at once. A stream ending starts a
+	 * 750ms clock: the status sinks into the bar background for the first
+	 * half, then the user's segments rise out of it.
+	 */
+	const resolveWorkingFrame = (live: string | undefined): { working: string | undefined; leftFade?: number } => {
+		const now = Date.now();
+		const liveShown = live !== undefined;
+		if (liveShown) lastWorkingText = live;
+		if (liveShown !== workingShown) {
+			workingShown = liveShown;
+			if (liveShown) {
+				// Instant cut in, and it cancels any fade-out still running.
+				workingFade = undefined;
+			} else {
+				workingFade = { start: now };
+				startWorkingFadeTimer();
+			}
+		}
+		if (!workingFade) return { working: live };
+		const half = WORKING_FADE_MS / 2;
+		const elapsed = now - workingFade.start;
+		if (elapsed >= WORKING_FADE_MS) {
+			workingFade = undefined;
+			return { working: live };
+		}
+		const outgoing = elapsed < half;
+		const leftFade = easeFade(outgoing ? 1 - elapsed / half : (elapsed - half) / half);
+		return { working: outgoing ? lastWorkingText : undefined, leftFade };
+	};
 
 	const rateMonitor = new TokenRateMonitor(requestRender);
 	rateMonitor.attach(pi);
@@ -83,6 +163,7 @@ export default function (pi: ExtensionAPI) {
 
 	registerSettingsCommand(pi, state, builder, () => {
 		syncRainbow();
+		syncEmbed();
 		requestRender();
 	});
 
@@ -120,16 +201,20 @@ export default function (pi: ExtensionAPI) {
 		const rainbowOn = rainbowActive();
 		const box = theme.getBox(effective.borderStyle);
 		const painters = makeBoxPainters({ rainbowOn, rainbow, box, width, bottomIdx, flat: border });
+		// The layout truncates the status to fit, so it is rendered at full width here.
+		const live = effective.embedWorkingStatus ? embeddedWorkingStatus?.(innerWidth) || undefined : undefined;
+		const { working, leftFade } = resolveWorkingFrame(live);
 		const bar = buildStatusLine(
 			innerWidth,
-			segCtx,
+			{ ...segCtx, workingStatus: working },
 			effective,
 			painters.gapColor,
 			{
-				left: effective.leftSegments,
+				left: topLeftSegments(effective, working !== undefined),
 				right: effective.rightSegments,
 			},
 			{ col: 3, row: 0 },
+			{ leftFade },
 		);
 		// Leading spacer row: keeps the transcript from sitting flush on the box.
 		const out: string[] = ["", renderBoxRow(painters, bar, 0, width, box.topLeft, box.topRight)];
@@ -149,7 +234,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]}`);
 		}
@@ -159,11 +244,45 @@ export default function (pi: ExtensionAPI) {
 	const wrapFactory = (inner: EditorFactory | undefined): EditorFactory => {
 		return (tui, editorTheme, keybindings) => {
 			activeTui = tui;
-			const editor = inner
-				? inner(tui, editorTheme, keybindings)
-				: new CustomEditor(tui, editorTheme, keybindings);
+			let editor: ReturnType<EditorFactory>;
+			if (inner) {
+				// A wrapped third-party editor is not opted in: pi keeps its
+				// standalone working row for it.
+				editor = inner(tui, editorTheme, keybindings);
+				activeEditor = undefined;
+				embeddedWorkingStatus = undefined;
+			} else {
+				const own = new CustomEditor(tui, editorTheme, keybindings, {
+					embedWorkingStatus: state.effective.embedWorkingStatus,
+				});
+				// Capture the host's indicator on its way in; renderBoxed draws it
+				// into the top bar since the inner top border (lines[0]) is discarded.
+				if (typeof own.setWorkingStatusIndicator === "function") {
+					const setIndicator = own.setWorkingStatusIndicator.bind(own);
+					own.setWorkingStatusIndicator = indicator => {
+						embeddedWorkingStatus = indicator ? width => indicator.renderInBorder(width) : undefined;
+						setIndicator(indicator);
+					};
+				}
+				activeEditor = own;
+				editor = own;
+			}
 			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 +331,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());
@@ -239,6 +364,7 @@ export default function (pi: ExtensionAPI) {
 		rateMonitor.enable();
 		syncRainbow();
 		ensureInstalled();
+		syncEmbed();
 		ensureFooterPatched();
 		ensureTimer ??= setInterval(() => {
 			ensureInstalled();
@@ -267,10 +393,18 @@ export default function (pi: ExtensionAPI) {
 		if (patchedFooter && footerRenderOriginal) {
 			patchedFooter.render = footerRenderOriginal;
 		}
+		restoreFooterLayout?.();
 		patchedFooter = undefined;
 		footerRenderOriginal = undefined;
+		restoreFooterLayout = undefined;
 		ourFactory = undefined;
 		wrappedFactory = undefined;
+		activeEditor = undefined;
+		embeddedWorkingStatus = undefined;
+		stopWorkingFadeTimer();
+		workingFade = undefined;
+		workingShown = false;
+		lastWorkingText = undefined;
 		activeTui = undefined;
 		activeCtx = undefined;
 	});

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@underactive/pi-topping-statusline",
-	"version": "0.1.3",
+	"version": "0.2.0",
 	"description": "oh-my-pi's powerline statusline as a pi extension with some customizations",
 	"keywords": [
 		"pi-package",
@@ -45,9 +45,10 @@
 		"@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.85.0",
+		"@earendil-works/pi-coding-agent": "0.85.0",
+		"@earendil-works/pi-server": "0.85.0",
+		"@earendil-works/pi-tui": "0.85.0",
 		"@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;
@@ -40,7 +63,7 @@ function deriveContextUsage(ctx: ExtensionContext | undefined): {
 	const usage = ctx?.getContextUsage();
 	const contextWindow = usage?.contextWindow ?? ctx?.model?.contextWindow ?? 0;
 	const tokens = usage?.tokens ?? undefined;
-	const percent = usage ? usage.percent : contextWindow > 0 && tokens != null ? (tokens / contextWindow) * 100 : null;
+	const percent = usage ? usage.percent : null;
 	return { contextWindow, tokens, percent };
 }
 
@@ -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);