@underactive/pi-topping-statusline 0.2.0 → 0.2.2

package/README.md

@@ -36,13 +36,16 @@ and apply live.
 ║ ╰── ↑ 3 more ── ↑ 12.4K ↓ 3.1K R 148K W 12K 92.3% $0.42 42%──╯ ║
 ║                                                                ║
 ╟─ Global ───────────────────────────────────────────────────────╢
-║  ▸ [■] Transparent Segments                                ON  ║
+║  > [■] Transparent Segments                                ON  ║
 ║    Separator                               ‹ powerline-thin ›  ║
 ║    Symbols                                       ‹ nerdfont ›  ║
 ║    Border style                                   ‹ rounded ›  ║
 ║    [■] Rainbow border on max thinking                      ON  ║
 ║    [■] Animate rainbow border                              ON  ║
-║    [ ] Embed 'Working' indicator                           OFF ║
+║    [■] NVIDIA-green when using Switchyard                  ON  ║
+║    [■] Animate Switchyard green border                     ON  ║
+║    [ ] Embed status spinners                               OFF ║
+║    [■] Embed compaction progress                           ON  ║
 ║                                                                ║
 ╟─ Top Left Segment Group ───────────────────────────────────────╢
 ║    [■] Pi symbol                                           ON  ║
@@ -67,18 +70,18 @@ and apply live.
 ║    + add feed                                                  ║
 ║                                                                ║
 ║  ↑↓ move  ←→ cycle  ␣ toggle  ⏎ apply/edit  esc cancel         ║
-╚════════════════════════════════════════════════════════[ 1/30 ]╝
+╚════════════════════════════════════════════════════════[ 1/33 ]╝
 ```
 
 | 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 · Embed 'Working' indicator |
+| 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 · NVIDIA-green when using Switchyard · Animate Switchyard green border · Embed status spinners · Embed compaction progress |
 | 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 · Embed 'Working' indicator off |
+| Defaults | Transparent on · Separator `powerline-thin` · Symbols `nerdfont` · Border style `rounded` · Rainbow border on · Animate rainbow border on · NVIDIA-green when using Switchyard on · Animate Switchyard green border on · Embed status spinners off · Embed compaction progress on |
 
 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
@@ -88,16 +91,49 @@ 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.
+When the active model provider is `switchyard` and **NVIDIA-green when using Switchyard** is on (the
+default), the border uses an NVIDIA-green gradient from `#84c51a` to `#0b3d20`. **Animate Switchyard
+green border** is also on by default, so it sweeps around the box on the same ~14s cycle as the
+max-thinking rainbow, independently of **Animate rainbow border**. Turn the animation setting off to
+keep the green gradient at a fixed color phase without its repaint timer. When enabled, green takes
+precedence over the max-thinking rainbow and ignores thinking level; turn the NVIDIA-green setting off
+to restore the normal theme or rainbow border.
+
+**Embed status spinners** (off by default) moves pi's status indicators out of their own row
+and into the top-left group, right after the Pi symbol and its chevron. On pi 0.86 and later
+this covers the working, retry, compaction, and branch-summary spinners; pi 0.85 embeds only
+the working indicator. The configured model, provider, and thinking details remain visible after
+the status; path, git, and PR step aside while a status is visible, and the Pi symbol never moves.
+An appearing status slides out from behind the Pi symbol's chevron over 300ms, pushing the model
+details right; one that replaces a status still on screen swaps in place without sliding.
+A cleared status is held briefly so handoffs between spinners do not flash the left segments.
+Only the working status cross-fades over 750ms; stable model details remain solid, and the
+message-style spinners cut after the hold. While the bar hosts the working status, it announces
+that on pi's extension event bus, and pi-topping's loader slides its response model out the same
+way; anywhere else that model appears at once.
+
+A status too long for the bar is truncated. The working spinner keeps pi's bare cut, while the
+message-style spinners use an ellipsis. Focusing the embed row in the settings preview shows
+the longest compaction sample. 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 status row.
+
+**Embed compaction progress** (on by default) hosts
+[pi-topping-compact](https://github.com/underactive/pi-topping-compact)'s compaction progress in
+the box's bottom border while a compaction runs. Its phosphor bar stands in for the context
+graph, followed by the tokens being compacted over the window and as a share of it
+(`86K/131K (66%)`), and `57% summarized · 16.3s` — how much has been summarized so far, and the
+time taken — stands in for pi's stats. The bar and its label follow the Context bar and Context
+stats toggles. The moment the compaction ends, pi's stats and the context graph return, the
+graph sizing the compacted context as an estimate until the next response (see Segments), and
+pi-topping-compact shows its completion result above the editor as it always has. Nothing
+changes without pi-topping-compact installed: the two talk over pi's extension event bus, this
+bar announcing whether it hosts the progress and pi-topping-compact broadcasting it only while
+it does, otherwise keeping its own above-editor widget. With the setting off, with Pi stats,
+Context bar, and Context stats all off, or with the terminal too narrow for the stand-ins, that
+widget is used instead. Focusing the setting's row in the settings preview shows the bottom bar
+mid-compaction.
 
 ## Segments
 
@@ -108,7 +144,17 @@ fs-watch), `pr` (via `gh`, hidden if missing), `session_name`, `token_rate` (liv
 accent while active, held 1.5s, faded 0.5s, then a dim `--- tok/s` placeholder; estimate
 pipelined from pi-topping's word-count EMA; available in the top-right, bottom-left, and
 bottom-right groups), `pi_stats`, `context_graph` (bar + stats), `scroll_hint`, plus `feeds`
-(documented below).
+(documented below), with `compaction_info` and `compaction_graph` standing in for `pi_stats` and
+`context_graph` while pi-topping-compact's progress is hosted. On pi 0.86 and later, `pi_stats`
+includes cache-warming refreshes folded
+into pi's own footer totals, so cache R/W and cost can increase while idle; this segment matches
+the host footer by construction.
+
+Between a compaction and the next response, pi reports context usage as unknown. Rather than
+vanish for that stretch, `context_graph` shows pi's own estimate of the compacted context, the
+summary plus the kept messages sized by pi's estimator, marked with `~` (`~9.2%/131K`). It is
+the same figure pi-topping-compact reports in its result. pi's measured figure replaces it after
+the next response.
 
 When the terminal narrows: right segments drop first, then the path shrinks (to ~8 cells),
 then left segments drop end-first — the path is always the last to go.

package/index.ts

@@ -26,6 +26,13 @@ import {
 } from "@earendil-works/pi-coding-agent";
 import type { Component, TUI } from "@earendil-works/pi-tui";
 import { makeBoxPainters, renderBoxRow, renderBoxRowIfVisible } from "./src/box.js";
+import {
+	COMPACTION_EMBED_CHANNEL,
+	COMPACTION_FIT_PROBE,
+	COMPACTION_PROGRESS_CHANNEL,
+	hostsCompactionProgress,
+	parseCompactionProgress,
+} from "./src/compaction-embed.js";
 import { SegmentContextBuilder } from "./src/context.js";
 import {
 	collapseFooterLayoutSlot,
@@ -35,17 +42,23 @@ import {
 	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 { NvidiaGreenBorder, isSwitchyardProvider } from "./src/nvidia-green.js";
+import { RAINBOW_DEG_PER_FRAME, RAINBOW_FRAME_MS, RainbowBorder, type BorderColorizer } from "./src/rainbow.js";
 import { registerSettingsCommand } from "./src/settings-menu.js";
-import { createSettingsState, topLeftSegments } from "./src/settings.js";
-import { easeFade } from "./src/theme.js";
+import { bottomRightSegments, COMPACTION_STAND_INS, createSettingsState, topLeftSegments } from "./src/settings.js";
 import { theme } from "./src/theme.js";
 import { TokenRateMonitor } from "./src/token-rate.js";
+import type {
+	CompactionProgressView,
+	EffectiveStatusLineSettings,
+	SegmentContext,
+	StatusLineSegmentId,
+} from "./src/types.js";
+import { isMessageKind, type StatusIndicatorKind, StatusTransition } from "./src/working-status.js";
+import { hostsWorkingStatus, WORKING_STATUS_EMBED_CHANNEL } from "./src/working-status-embed.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;
+const STATUS_ANIMATION_FRAME_MS = 30;
 
 export default function (pi: ExtensionAPI) {
 	const state = createSettingsState();
@@ -60,20 +73,16 @@ export default function (pi: ExtensionAPI) {
 	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.
+	// another extension's editor), and the host's status spinner captured from
+	// that editor. pi 0.85 sends only working; 0.86 sends all four kinds.
 	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;
+	let embeddedStatusKind: StatusIndicatorKind | undefined;
+	const statusTransition = new StatusTransition();
+	let statusAnimationTimer: ReturnType<typeof setInterval> | undefined;
+	const stopStatusAnimationTimer = (): void => {
+		if (statusAnimationTimer) clearInterval(statusAnimationTimer);
+		statusAnimationTimer = undefined;
 	};
 
 	const syncEmbed = (): void => {
@@ -85,84 +94,112 @@ export default function (pi: ExtensionAPI) {
 		ctx.ui.setEditorComponent(factory);
 	};
 
+	// pi-topping slides its loader's response model out only while this bar hosts the loader.
+	const announceEmbed = (embedded: boolean): void => pi.events.emit(WORKING_STATUS_EMBED_CHANNEL, { embedded });
+
 	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();
-			}
+	// pi-topping-compact's latest progress broadcast, while one is active.
+	let compaction: CompactionProgressView | undefined;
+	// The boxed render failed and the plain editor is showing instead.
+	let boxRenderFailed = false;
+	// A COMPACTION_PROGRESS_CHANNEL payload with active: true that parseCompactionProgress
+	// could not parse: pi-topping-compact and this bar have drifted out of sync. Latched, not
+	// reset, since the mismatch persists until the extensions reload.
+	let compactionPayloadRejected = false;
+	const hostingCompaction = (): boolean =>
+		activeCtx !== undefined && !boxRenderFailed && !compactionPayloadRejected && hostsCompactionProgress(state.effective);
+	// The last verdict sent on COMPACTION_EMBED_CHANNEL, so the channel only fires on change.
+	let announcedCompactionEmbed: boolean | undefined;
+	const announceCompactionEmbed = (hosts: boolean): void => {
+		if (hosts === announcedCompactionEmbed) return;
+		announcedCompactionEmbed = hosts;
+		pi.events.emit(COMPACTION_EMBED_CHANNEL, { embedded: hosts });
+	};
+	// Whether the compaction stand-ins would have room, cached by (innerWidth, effective) since
+	// it only changes on a resize or a settings change, not every frame: measured against a
+	// representative view rather than a fixed cell count, so it tracks the border/symbol/
+	// transparency settings and which segments are toggled on instead of assuming defaults.
+	const noGapColor = (s: string) => s;
+	let compactionFitCache: { innerWidth: number; effective: EffectiveStatusLineSettings; fits: boolean } | undefined;
+	const compactionWouldFit = (innerWidth: number, ctx: SegmentContext, effective: EffectiveStatusLineSettings): boolean => {
+		if (compactionFitCache && compactionFitCache.innerWidth === innerWidth && compactionFitCache.effective === effective) {
+			return compactionFitCache.fits;
 		}
-		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 compactionRightIds = bottomRightSegments(effective, true);
+		let fitRight: readonly StatusLineSegmentId[] = compactionRightIds;
+		buildStatusLine(
+			innerWidth,
+			{ ...ctx, compaction: COMPACTION_FIT_PROBE },
+			effective,
+			noGapColor,
+			{ left: effective.bottomLeftSegments, right: compactionRightIds },
+			{ col: 3, row: 0 },
+			{ onFit: fit => { fitRight = fit.right; } },
+		);
+		const fits = Object.values(COMPACTION_STAND_INS).some(id => fitRight.includes(id));
+		compactionFitCache = { innerWidth, effective, fits };
+		return fits;
+	};
+	pi.events.on(COMPACTION_PROGRESS_CHANNEL, data => {
+		compaction = parseCompactionProgress(data);
+		if (compaction === undefined && typeof data === "object" && data !== null && (data as { active?: unknown }).active === true) {
+			compactionPayloadRejected = true;
+			announceCompactionEmbed(false);
 		}
-		const outgoing = elapsed < half;
-		const leftFade = easeFade(outgoing ? 1 - elapsed / half : (elapsed - half) / half);
-		return { working: outgoing ? lastWorkingText : undefined, leftFade };
+		requestRender();
+	});
+	const startStatusAnimationTimer = (): void => {
+		if (statusAnimationTimer) return;
+		statusAnimationTimer = setInterval(() => {
+			requestRender();
+			if (!statusTransition.pending(Date.now())) stopStatusAnimationTimer();
+		}, STATUS_ANIMATION_FRAME_MS);
+		statusAnimationTimer.unref?.();
 	};
 
 	const rateMonitor = new TokenRateMonitor(requestRender);
 	rateMonitor.attach(pi);
 	builder.setTokenRateProvider(() => rateMonitor.getDisplay());
 
-	// The rainbow is visible at max thinking independently of whether its hue
-	// phase is animated. Stopping the timer preserves the current live phase.
+	// The active border colorizer is visible independently of whether its phase
+	// is animated. Stopping the timer preserves the current live phase.
 	const rainbow = new RainbowBorder();
-	let rainbowTimer: ReturnType<typeof setInterval> | undefined;
+	const green = new NvidiaGreenBorder();
+	let borderTimer: ReturnType<typeof setInterval> | undefined;
 	const rainbowActive = (): boolean =>
 		state.effective.rainbowBorder && activeCtx !== undefined && pi.getThinkingLevel() === "max";
-	const rainbowAnimationActive = (): boolean => rainbowActive() && state.effective.rainbowAnimation;
-	const syncRainbow = (): void => {
-		if (rainbowAnimationActive()) {
-			if (!rainbowTimer) {
-				rainbowTimer = setInterval(() => {
-					if (!rainbowAnimationActive()) {
-						syncRainbow();
+	const greenActive = (): boolean =>
+		state.effective.nvidiaGreenBorder && activeCtx !== undefined && isSwitchyardProvider(activeCtx.model?.provider);
+	const borderColorizer = (): BorderColorizer | undefined => (greenActive() ? green : rainbowActive() ? rainbow : undefined);
+	const borderAnimationActive = (): boolean => {
+		if (greenActive()) return state.effective.nvidiaGreenAnimation;
+		if (rainbowActive()) return state.effective.rainbowAnimation;
+		return false;
+	};
+	const syncBorderAnimation = (): void => {
+		if (borderAnimationActive()) {
+			if (!borderTimer) {
+				borderTimer = setInterval(() => {
+					const colorizer = borderColorizer();
+					if (!borderAnimationActive() || colorizer === undefined) {
+						syncBorderAnimation();
 						return;
 					}
-					rainbow.step(RAINBOW_DEG_PER_FRAME);
+					colorizer.step(RAINBOW_DEG_PER_FRAME);
 					requestRender();
 				}, RAINBOW_FRAME_MS);
-				rainbowTimer.unref?.();
+				borderTimer.unref?.();
 			}
-		} else if (rainbowTimer) {
-			clearInterval(rainbowTimer);
-			rainbowTimer = undefined;
+		} else if (borderTimer) {
+			clearInterval(borderTimer);
+			borderTimer = undefined;
 		}
 	};
 
 	registerSettingsCommand(pi, state, builder, () => {
-		syncRainbow();
+		syncBorderAnimation();
 		syncEmbed();
 		requestRender();
 	});
@@ -175,7 +212,10 @@ export default function (pi: ExtensionAPI) {
 		editor: { borderColor?: (str: string) => string },
 	): string[] => {
 		const ctx = activeCtx;
-		if (!ctx || width < MIN_BOXED_WIDTH) return innerRender(width);
+		if (!ctx || width < MIN_BOXED_WIDTH) {
+			announceCompactionEmbed(false);
+			return innerRender(width);
+		}
 
 		// Chrome totals 6 cells on every row, so the bar and the inner text rows
 		// share one width budget. Border rows split it 3/3 (╭── … ──╮); text rows
@@ -190,31 +230,48 @@ export default function (pi: ExtensionAPI) {
 		if ((editor as unknown as { autocompleteState?: unknown }).autocompleteState) {
 			while (bottomIdx > 0 && !isBorderRow(lines[bottomIdx] ?? "")) bottomIdx--;
 		}
-		if (lines.length < 3 || bottomIdx < 2) return innerRender(width);
+		if (lines.length < 3 || bottomIdx < 2) {
+			announceCompactionEmbed(false);
+			return innerRender(width);
+		}
 
 		const hint = stripAnsi(lines[bottomIdx] ?? "").match(/[↑↓] \d+ more/)?.[0] ?? "";
 		const effective = state.effective;
-		const include = effective.includes;
+		// The layout truncates the status to fit, so it is rendered at full width here.
+		const live = effective.embedWorkingStatus ? embeddedWorkingStatus?.(innerWidth) || undefined : undefined;
+		const frame = statusTransition.resolve(live, embeddedStatusKind, Date.now());
+		if (frame.pending) startStatusAnimationTimer();
+		const compactionCandidate = hostingCompaction();
+		let include = effective.includes;
+		if (frame.status !== undefined) include = { ...include, git: false, pr: false };
 		const segCtx = builder.build(innerWidth, effective.segmentOptions, include, hint || undefined);
 		// borderColor is assigned by the host after the factory returns — read late.
 		const border = editor.borderColor ?? ((s: string) => s);
-		const rainbowOn = rainbowActive();
+		const colorizer = borderColorizer();
 		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 painters = makeBoxPainters({
+			colorizerOn: colorizer !== undefined,
+			colorizer: colorizer ?? rainbow,
+			box,
+			width,
+			bottomIdx,
+			flat: border,
+		});
 		const bar = buildStatusLine(
 			innerWidth,
-			{ ...segCtx, workingStatus: working },
+			{ ...segCtx, workingStatus: frame.status },
 			effective,
 			painters.gapColor,
 			{
-				left: topLeftSegments(effective, working !== undefined),
+				left: topLeftSegments(effective, frame.status !== undefined),
 				right: effective.rightSegments,
 			},
 			{ col: 3, row: 0 },
-			{ leftFade },
+			{
+				leftFade: frame.leftFade,
+				workingReveal: frame.reveal,
+				workingEllipsis: isMessageKind(frame.kind) ? "…" : "",
+			},
 		);
 		// Leading spacer row: keeps the transcript from sitting flush on the box.
 		const out: string[] = ["", renderBoxRow(painters, bar, 0, width, box.topLeft, box.topRight)];
@@ -223,17 +280,43 @@ export default function (pi: ExtensionAPI) {
 				painters.paint(i, 0, box.vertical) + " " + (lines[i] ?? "") + "   " + painters.paint(i, width - 1, box.vertical),
 			);
 		}
-		const bottomBar = buildStatusLine(
-			innerWidth,
-			segCtx,
-			effective,
-			painters.gapColor,
-			{
-				left: effective.bottomLeftSegments,
-				right: effective.bottomRightSegments,
-			},
-			{ col: 3, row: bottomIdx },
-		);
+		// Swap in the stand-ins only once there is live progress to show, and only once they
+		// actually fit; otherwise pi's own stats and the context graph stay put, same as when
+		// the setting is off. Fit is checked against the real bar while a compaction is running,
+		// so the fallback below never trims further than that render already decided; before one
+		// starts, the cached probe stands in so the handshake doesn't wait on real progress.
+		const plainBottomBar = (): string =>
+			buildStatusLine(
+				innerWidth,
+				segCtx,
+				effective,
+				painters.gapColor,
+				{ left: effective.bottomLeftSegments, right: effective.bottomRightSegments },
+				{ col: 3, row: bottomIdx },
+			);
+		const activeCompaction = compactionCandidate ? compaction : undefined;
+		let compactionHostable: boolean;
+		let bottomBar: string;
+		if (activeCompaction === undefined) {
+			compactionHostable = compactionCandidate && compactionWouldFit(innerWidth, segCtx, effective);
+			bottomBar = plainBottomBar();
+		} else {
+			const compactionRightIds = bottomRightSegments(effective, true);
+			let fitRight: readonly StatusLineSegmentId[] = compactionRightIds;
+			const hostedBar = buildStatusLine(
+				innerWidth,
+				{ ...segCtx, compaction: activeCompaction },
+				effective,
+				painters.gapColor,
+				{ left: effective.bottomLeftSegments, right: compactionRightIds },
+				{ col: 3, row: bottomIdx },
+				{ onFit: fit => { fitRight = fit.right; } },
+			);
+			const shown = Object.values(COMPACTION_STAND_INS).some(id => fitRight.includes(id));
+			compactionHostable = shown;
+			bottomBar = shown ? hostedBar : plainBottomBar();
+		}
+		announceCompactionEmbed(compactionHostable);
 		out.push(...renderBoxRowIfVisible(painters, bottomBar, bottomIdx, width, box.bottomLeft, box.bottomRight));
 		for (let i = bottomIdx + 1; i < lines.length; i++) {
 			out.push(`  ${lines[i]}`);
@@ -247,39 +330,45 @@ export default function (pi: ExtensionAPI) {
 			let editor: ReturnType<EditorFactory>;
 			if (inner) {
 				// A wrapped third-party editor is not opted in: pi keeps its
-				// standalone working row for it.
+				// standalone status-spinner row for it.
 				editor = inner(tui, editorTheme, keybindings);
 				activeEditor = undefined;
 				embeddedWorkingStatus = undefined;
+				embeddedStatusKind = 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.
+				// Capture the host's status indicator on its way in; renderBoxed
+				// draws it in the top bar because the inner border is discarded.
 				if (typeof own.setWorkingStatusIndicator === "function") {
 					const setIndicator = own.setWorkingStatusIndicator.bind(own);
 					own.setWorkingStatusIndicator = indicator => {
+						// pi 0.86 sends retry, compaction, and branch-summary indicators
+						// through this setter too; renderInBorder now lives on the base class.
 						embeddedWorkingStatus = indicator ? width => indicator.renderInBorder(width) : undefined;
+						embeddedStatusKind = indicator?.kind;
 						setIndicator(indicator);
 					};
 				}
 				activeEditor = own;
 				editor = own;
 			}
+			announceEmbed(hostsWorkingStatus(activeEditor));
+			// A fresh editor retries the boxed path.
+			boxRenderFailed = false;
 			const innerRender = editor.render.bind(editor);
-			let boxRenderFailed = false;
 			editor.render = width => {
+				if (boxRenderFailed) return innerRender(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",
-						);
-					}
+					boxRenderFailed = true;
+					announceCompactionEmbed(false);
+					activeCtx?.ui.notify(
+						`Statusline render failed, using plain editor: ${err instanceof Error ? err.message : String(err)}`,
+						"error",
+					);
 					return innerRender(width);
 				}
 			};
@@ -299,6 +388,8 @@ export default function (pi: ExtensionAPI) {
 
 	const PI_STATS_CACHE_MS = 250;
 	let piStatsCache: { at: number; value: string | undefined } | undefined;
+	// From pi 0.86 these host totals include cache_warm usage entries, so R/W
+	// and cost can change while idle; mirroring the footer keeps this exact.
 	builder.setPiStatsProvider(width => {
 		if (!footerRenderOriginal) return undefined;
 		const now = Date.now();
@@ -346,13 +437,17 @@ export default function (pi: ExtensionAPI) {
 		}
 		if (!restoreFooterLayout) {
 			const layoutRoot = (tui as unknown as { layoutRoot?: unknown }).layoutRoot;
+			// No-op on pi >= 0.86; retained for supported 0.84/0.85 hosts.
 			restoreFooterLayout = collapseFooterLayoutSlot(layoutRoot, patchedFooter);
 		}
 	};
 
-	pi.on("model_select", () => requestRender());
+	pi.on("model_select", () => {
+		syncBorderAnimation();
+		requestRender();
+	});
 	pi.on("thinking_level_select", () => {
-		syncRainbow();
+		syncBorderAnimation();
 		requestRender();
 	});
 	pi.on("session_info_changed", () => requestRender());
@@ -362,7 +457,7 @@ export default function (pi: ExtensionAPI) {
 		activeCtx = ctx;
 		builder.attach(ctx);
 		rateMonitor.enable();
-		syncRainbow();
+		syncBorderAnimation();
 		ensureInstalled();
 		syncEmbed();
 		ensureFooterPatched();
@@ -371,7 +466,7 @@ export default function (pi: ExtensionAPI) {
 			ensureFooterPatched();
 			// The host's /settings dialog can change the thinking level without
 			// firing thinking_level_select, so reconcile the animator periodically.
-			syncRainbow();
+			syncBorderAnimation();
 		}, 1000);
 		ensureTimer.unref?.();
 	});
@@ -379,9 +474,9 @@ export default function (pi: ExtensionAPI) {
 	pi.on("session_shutdown", () => {
 		rateMonitor.disable();
 		builder.dispose();
-		if (rainbowTimer) {
-			clearInterval(rainbowTimer);
-			rainbowTimer = undefined;
+		if (borderTimer) {
+			clearInterval(borderTimer);
+			borderTimer = undefined;
 		}
 		if (ensureTimer) {
 			clearInterval(ensureTimer);
@@ -401,11 +496,13 @@ export default function (pi: ExtensionAPI) {
 		wrappedFactory = undefined;
 		activeEditor = undefined;
 		embeddedWorkingStatus = undefined;
-		stopWorkingFadeTimer();
-		workingFade = undefined;
-		workingShown = false;
-		lastWorkingText = undefined;
+		embeddedStatusKind = undefined;
+		announceEmbed(false);
+		stopStatusAnimationTimer();
+		statusTransition.reset();
+		compaction = undefined;
 		activeTui = undefined;
 		activeCtx = undefined;
+		announceCompactionEmbed(false);
 	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@underactive/pi-topping-statusline",
-	"version": "0.2.0",
+	"version": "0.2.2",
 	"description": "oh-my-pi's powerline statusline as a pi extension with some customizations",
 	"keywords": [
 		"pi-package",
@@ -45,10 +45,9 @@
 		"@earendil-works/pi-tui": "*"
 	},
 	"devDependencies": {
-		"@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",
+		"@earendil-works/pi-ai": "0.86.0",
+		"@earendil-works/pi-coding-agent": "0.86.0",
+		"@earendil-works/pi-tui": "0.86.0",
 		"@types/node": "^22.0.0",
 		"typescript": "^5.7.0"
 	}