@underactive/pi-topping-statusline 0.2.0 → 0.2.1

package/README.md

@@ -42,7 +42,9 @@ and apply live.
 ║    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 ║
 ║                                                                ║
 ╟─ Top Left Segment Group ───────────────────────────────────────╢
 ║    [■] Pi symbol                                           ON  ║
@@ -67,18 +69,18 @@ and apply live.
 ║    + add feed                                                  ║
 ║                                                                ║
 ║  ↑↓ move  ←→ cycle  ␣ toggle  ⏎ apply/edit  esc cancel         ║
-╚════════════════════════════════════════════════════════[ 1/30 ]╝
+╚════════════════════════════════════════════════════════[ 1/32 ]╝
 ```
 
 | 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 |
 | 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 |
 
 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 +90,28 @@ 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 remaining left segments (model, path, git, PR) step aside while a
+status is visible, and the Pi symbol never moves. A cleared status is held briefly so handoffs
+between spinners do not flash the left segments. Only the end of a working spinner then
+cross-fades back over 750ms; the message-style spinners cut after the hold.
+
+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.
 
 ## Segments
 
@@ -108,7 +122,9 @@ 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). 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.
 
 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

@@ -35,17 +35,16 @@ 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 { theme } from "./src/theme.js";
 import { TokenRateMonitor } from "./src/token-rate.js";
+import { isMessageKind, type StatusIndicatorKind, StatusTransition } from "./src/working-status.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 WORKING_FADE_FRAME_MS = 30;
 
 export default function (pi: ExtensionAPI) {
 	const state = createSettingsState();
@@ -60,16 +59,12 @@ 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 embeddedStatusKind: StatusIndicatorKind | undefined;
+	const statusTransition = new StatusTransition();
 	let workingFadeTimer: ReturnType<typeof setInterval> | undefined;
 	const stopWorkingFadeTimer = (): void => {
 		if (workingFadeTimer) clearInterval(workingFadeTimer);
@@ -90,79 +85,53 @@ export default function (pi: ExtensionAPI) {
 	const startWorkingFadeTimer = (): void => {
 		if (workingFadeTimer) return;
 		workingFadeTimer = setInterval(() => {
-			if (!workingFade || Date.now() - workingFade.start >= WORKING_FADE_MS) {
-				workingFade = undefined;
-				stopWorkingFadeTimer();
-			}
 			requestRender();
+			if (!statusTransition.pending(Date.now())) stopWorkingFadeTimer();
 		}, 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);
 	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();
 	});
@@ -198,23 +167,34 @@ export default function (pi: ExtensionAPI) {
 		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 });
+		const painters = makeBoxPainters({
+			colorizerOn: colorizer !== undefined,
+			colorizer: colorizer ?? 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 frame = statusTransition.resolve(live, embeddedStatusKind, Date.now());
+		if (frame.pending) startWorkingFadeTimer();
 		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,
+				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)];
@@ -247,20 +227,24 @@ 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);
 					};
 				}
@@ -270,6 +254,7 @@ export default function (pi: ExtensionAPI) {
 			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) {
@@ -299,6 +284,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 +333,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 +353,7 @@ export default function (pi: ExtensionAPI) {
 		activeCtx = ctx;
 		builder.attach(ctx);
 		rateMonitor.enable();
-		syncRainbow();
+		syncBorderAnimation();
 		ensureInstalled();
 		syncEmbed();
 		ensureFooterPatched();
@@ -371,7 +362,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 +370,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,10 +392,9 @@ export default function (pi: ExtensionAPI) {
 		wrappedFactory = undefined;
 		activeEditor = undefined;
 		embeddedWorkingStatus = undefined;
+		embeddedStatusKind = undefined;
 		stopWorkingFadeTimer();
-		workingFade = undefined;
-		workingShown = false;
-		lastWorkingText = undefined;
+		statusTransition.reset();
 		activeTui = undefined;
 		activeCtx = undefined;
 	});

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@underactive/pi-topping-statusline",
-	"version": "0.2.0",
+	"version": "0.2.1",
 	"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"
 	}

package/src/box.ts

@@ -2,16 +2,16 @@
  * Shared box-chrome painting for the live editor box (index.ts) and the
  * settings-menu preview, so the 3/2/+2 row geometry has one definition.
  *
- * Rainbow mode colors each glyph by its perimeter-walk position; otherwise
+ * Gradient mode colors each glyph by its perimeter-walk position; otherwise
  * the caller's flat painter wraps whole runs in one escape sequence, which
  * renders identically to per-glyph wraps with fewer bytes. The flat painter
- * and the RainbowBorder instance are injected because they differ per caller
+ * and the border colorizer are injected because they differ per caller
  * (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 { perimeterLength, perimeterPosition, type BorderColorizer } from "./rainbow.js";
 import type { BoxGlyphs } from "./theme.js";
 
 export interface BoxPainters {
@@ -22,28 +22,50 @@ export interface BoxPainters {
 }
 
 export function makeBoxPainters(opts: {
-	rainbowOn: boolean;
-	rainbow: RainbowBorder;
+	colorizerOn: boolean;
+	colorizer: BorderColorizer;
 	box: BoxGlyphs;
 	width: number;
 	bottomIdx: number;
 	flat: (str: string) => string;
 }): BoxPainters {
-	const { rainbowOn, rainbow, box, width, bottomIdx, flat } = opts;
+	const { colorizerOn, colorizer, box, width, bottomIdx, flat } = opts;
 	const perimeter = perimeterLength(width, bottomIdx);
 	const paint = (row: number, col: number, ch: string): string =>
-		rainbowOn ? rainbow.colorChar(ch, perimeterPosition(row, col, width, bottomIdx), perimeter) : flat(ch);
+		colorizerOn ? colorizer.colorChar(ch, perimeterPosition(row, col, width, bottomIdx), perimeter) : flat(ch);
 	const horizRun = (row: number, startCol: number, count: number): string => {
-		if (!rainbowOn) return flat(box.horizontal.repeat(count));
+		if (!colorizerOn) return flat(box.horizontal.repeat(count));
 		let out = "";
-		for (let k = 0; k < count; k++) out += paint(row, startCol + k, box.horizontal);
+		let runPrefix: string | undefined;
+		let runChars = "";
+		for (let k = 0; k < count; k++) {
+			const prefix = colorizer.prefix(perimeterPosition(row, startCol + k, width, bottomIdx), perimeter);
+			if (runPrefix !== undefined && prefix !== runPrefix) {
+				out += `${runPrefix}${runChars}\x1b[39m`;
+				runChars = "";
+			}
+			runPrefix = prefix;
+			runChars += box.horizontal;
+		}
+		if (runPrefix !== undefined) out += `${runPrefix}${runChars}\x1b[39m`;
 		return out;
 	};
 	const gapColor = (str: string, startCol: number, row: number): string => {
-		if (!rainbowOn) return flat(str);
+		if (!colorizerOn) return flat(str);
 		let out = "";
+		let runPrefix: string | undefined;
+		let runChars = "";
 		let k = 0;
-		for (const ch of str) out += paint(row, startCol + k++, ch);
+		for (const ch of str) {
+			const prefix = colorizer.prefix(perimeterPosition(row, startCol + k++, width, bottomIdx), perimeter);
+			if (runPrefix !== undefined && prefix !== runPrefix) {
+				out += `${runPrefix}${runChars}\x1b[39m`;
+				runChars = "";
+			}
+			runPrefix = prefix;
+			runChars += ch;
+		}
+		if (runPrefix !== undefined) out += `${runPrefix}${runChars}\x1b[39m`;
 		return out;
 	};
 	return { paint, horizRun, gapColor };

package/src/footer.ts

@@ -27,8 +27,11 @@ function containsComponent(node: unknown, target: unknown, seen: Set<unknown>):
 }
 
 /**
- * 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.
+ * Let pi's fullscreen footer slot collapse when its component renders no rows.
+ * Hosts before 0.86 give that VStack entry minSize=1 regardless of render
+ * output; 0.86 fixed it (#8919), where this writes 0 over 0. Delete this
+ * helper, its index.ts call/restore path, and its test once the minimum
+ * supported host is 0.86.
  */
 export function collapseFooterLayoutSlot(layoutRoot: unknown, footer: unknown): (() => void) | undefined {
 	const seen = new Set<unknown>();

package/src/layout.ts

@@ -2,9 +2,11 @@
  * The bar layout engine, ported from oh-my-pi component.ts #buildStatusLine.
  *
  * Overflow strategy (in order): drop right segments right-to-left, truncate
- * the embedded `working` status (no ellipsis, as pi's own border does), shrink
- * the elastic `path` segment down to ~8 cells, drop left segments end-first
- * while protecting `path`. The gap between the two groups is filled with the
+ * the embedded `working` status with the caller's chosen ellipsis policy,
+ * shrink the elastic `path` segment down to ~8 cells, drop left segments
+ * end-first while protecting `path`. Working indicators retain pi's bare cut;
+ * message-style indicators use an ellipsis so truncated prose is apparent.
+ * The gap between the two groups is filled with the
  * box-horizontal glyph colored like the editor border, so it tracks the
  * thinking-level border color; the callback receives the gap's absolute
  * column and row in the box, so a caller can paint it as part of a
@@ -63,7 +65,7 @@ export function buildStatusLine(
 	gapBorderColor: (str: string, startCol: number, row: number) => string,
 	segmentGroups: { left: StatusLineSegmentId[]; right: StatusLineSegmentId[] },
 	barOrigin: { col: number; row: number } = { col: 0, row: 0 },
-	options: { leftFade?: number } = {},
+	options: { leftFade?: number; workingEllipsis?: string } = {},
 ): string {
 	const separatorDef = getSeparator(settings.separator);
 
@@ -124,7 +126,7 @@ export function buildStatusLine(
 		if (workingIdx >= 0 && totalWidth() > width) {
 			const available = visibleWidth(left[workingIdx]) - (totalWidth() - width);
 			if (available >= 1) {
-				left[workingIdx] = truncateToWidth(left[workingIdx], available, "");
+				left[workingIdx] = truncateToWidth(left[workingIdx], available, options.workingEllipsis ?? "");
 			} else {
 				left.splice(workingIdx, 1);
 				leftSegIds.splice(workingIdx, 1);

package/src/nvidia-green.ts

@@ -0,0 +1,66 @@
+/** Provider-specific NVIDIA green border colorizer for Switchyard. */
+import { rgbToHex, wrapDeg, type BorderColorizer } from "./rainbow.js";
+import { detectColorMode, hexToFgAnsi, parseHex, type ColorMode } from "./theme.js";
+
+export const SWITCHYARD_PROVIDER = "switchyard";
+export const NVIDIA_GREEN_HEX = "#84c51a";
+export const NVIDIA_GREEN_DARK_HEX = "#0b3d20";
+const GREEN_SHADE_COUNT = 256;
+const GREEN_BIAS = 0.65;
+
+export function isSwitchyardProvider(provider: string | undefined): boolean {
+	return provider?.trim().toLowerCase() === SWITCHYARD_PROVIDER;
+}
+
+const ansiByShadeByMode = new Map<ColorMode, string[]>();
+
+function buildAnsiByShade(mode: ColorMode): string[] {
+	const cached = ansiByShadeByMode.get(mode);
+	if (cached !== undefined) return cached;
+
+	const dark = parseHex(NVIDIA_GREEN_DARK_HEX);
+	const bright = parseHex(NVIDIA_GREEN_HEX);
+	if (dark === undefined || bright === undefined) {
+		throw new Error("Invalid NVIDIA green palette");
+	}
+
+	const ansiByShade: string[] = [];
+	for (let i = 0; i < GREEN_SHADE_COUNT; i++) {
+		const progress = i / (GREEN_SHADE_COUNT - 1);
+		const rgb: [number, number, number] = [
+			Math.round(dark[0] + (bright[0] - dark[0]) * progress),
+			Math.round(dark[1] + (bright[1] - dark[1]) * progress),
+			Math.round(dark[2] + (bright[2] - dark[2]) * progress),
+		];
+		ansiByShade.push(hexToFgAnsi(rgbToHex(rgb), mode));
+	}
+
+	ansiByShadeByMode.set(mode, ansiByShade);
+	return ansiByShade;
+}
+
+export class NvidiaGreenBorder implements BorderColorizer {
+	#phaseDeg: number;
+	readonly #ansiByShade: string[];
+
+	constructor(phaseDeg = 0) {
+		this.#phaseDeg = wrapDeg(phaseDeg);
+		this.#ansiByShade = buildAnsiByShade(detectColorMode());
+	}
+
+	step(deltaDeg: number): void {
+		this.#phaseDeg = wrapDeg(this.#phaseDeg + deltaDeg);
+	}
+
+	colorChar(char: string, perimeterPos: number, perimeter: number): string {
+		return `${this.prefix(perimeterPos, perimeter)}${char}\x1b[39m`;
+	}
+
+	prefix(perimeterPos: number, perimeter: number): string {
+		const t = (perimeterPos / perimeter + this.#phaseDeg / 360) % 1;
+		const u = (1 - Math.cos(2 * Math.PI * t)) / 2;
+		const eased = u ** GREEN_BIAS;
+		const shadeIndex = Math.round((1 - eased) * (GREEN_SHADE_COUNT - 1));
+		return this.#ansiByShade[shadeIndex];
+	}
+}

package/src/rainbow.ts

@@ -24,6 +24,9 @@ export const RAINBOW_DEG_PER_FRAME = (360 * RAINBOW_FRAME_MS) / RAINBOW_CYCLE_MS
 const SATURATION = 1;
 const LIGHTNESS = 0.62;
 
+/** Normalize a degree value into the [0, 360) range. */
+export const wrapDeg = (deg: number): number => ((deg % 360) + 360) % 360;
+
 /**
  * Number of border cells in the box (rows 0..bottomIdx, cols 0..width-1):
  * two horizontal edges of `width` cells plus two vertical edges of
@@ -64,27 +67,38 @@ export function rgbToHex([r, g, b]: [number, number, number]): string {
 	return `#${((r << 16) | (g << 8) | b).toString(16).padStart(6, "0")}`;
 }
 
+export interface BorderColorizer {
+	colorChar(ch: string, perimeterPos: number, perimeter: number): string;
+	/** ANSI foreground-color escape for a perimeter position, with no glyph or reset. */
+	prefix(perimeterPos: number, perimeter: number): string;
+	step(deltaDeg: number): void;
+}
+
 /**
  * Colors box glyphs with a hue that travels around the border perimeter as
  * the phase advances — the spectrum appears to flow around the box.
  */
-export class RainbowBorder {
+export class RainbowBorder implements BorderColorizer {
 	#phaseDeg: number;
 	readonly #mode: ColorMode;
 	readonly #ansiByHue: string[] = [];
 
 	constructor(phaseDeg = 0) {
-		this.#phaseDeg = ((phaseDeg % 360) + 360) % 360;
+		this.#phaseDeg = wrapDeg(phaseDeg);
 		this.#mode = detectColorMode();
 	}
 
 	/** Advance the whole spectrum by `deltaDeg` (mod 360). */
 	step(deltaDeg: number): void {
-		this.#phaseDeg = ((this.#phaseDeg + deltaDeg) % 360 + 360) % 360;
+		this.#phaseDeg = wrapDeg(this.#phaseDeg + deltaDeg);
 	}
 
 	/** Color one border glyph whose walk position is `perimeterPos` of `perimeter`. */
 	colorChar(char: string, perimeterPos: number, perimeter: number): string {
+		return `${this.prefix(perimeterPos, perimeter)}${char}\x1b[39m`;
+	}
+
+	prefix(perimeterPos: number, perimeter: number): string {
 		const hue = (this.#phaseDeg + (360 * perimeterPos) / perimeter) % 360;
 		const bucket = Math.round(hue) % 360;
 		let ansi = this.#ansiByHue[bucket];
@@ -93,6 +107,6 @@ export class RainbowBorder {
 			ansi = hexToFgAnsi(hex, this.#mode);
 			this.#ansiByHue[bucket] = ansi;
 		}
-		return `${ansi}${char}\x1b[39m`;
+		return ansi;
 	}
 }