@underactive/pi-topping-statusline 0.1.4 → 0.2.1

package/README.md

@@ -42,6 +42,9 @@ and apply live.
 ║    Border style                                   ‹ rounded ›  ║
 ║    [■] Rainbow border on max thinking                      ON  ║
 ║    [■] Animate rainbow border                              ON  ║
+║    [■] NVIDIA-green when using Switchyard                  ON  ║
+║    [■] Animate Switchyard green border                     ON  ║
+║    [ ] Embed status spinners                               OFF ║
 ║                                                                ║
 ╟─ Top Left Segment Group ───────────────────────────────────────╢
 ║    [■] Pi symbol                                           ON  ║
@@ -66,18 +69,18 @@ and apply live.
 ║    + add feed                                                  ║
 ║                                                                ║
 ║  ↑↓ move  ←→ cycle  ␣ toggle  ⏎ apply/edit  esc cancel         ║
-╚════════════════════════════════════════════════════════[ 1/29 ]╝
+╚════════════════════════════════════════════════════════[ 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 |
+| 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 |
+| 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
@@ -87,6 +90,29 @@ 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.
 
+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
 
 Ported with pi data: `pi`, `model` (model · provider · thinking level), `path`
@@ -96,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,13 +35,17 @@ 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 } from "./src/settings.js";
+import { createSettingsState, topLeftSegments } from "./src/settings.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"]>>;
 
+const WORKING_FADE_FRAME_MS = 30;
+
 export default function (pi: ExtensionAPI) {
 	const state = createSettingsState();
 	const builder = new SegmentContextBuilder(pi);
@@ -54,42 +58,81 @@ export default function (pi: ExtensionAPI) {
 	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 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;
+	let embeddedStatusKind: StatusIndicatorKind | undefined;
+	const statusTransition = new StatusTransition();
+	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(() => {
+			requestRender();
+			if (!statusTransition.pending(Date.now())) stopWorkingFadeTimer();
+		}, WORKING_FADE_FRAME_MS);
+		workingFadeTimer.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();
 	});
 
@@ -124,19 +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 frame = statusTransition.resolve(live, embeddedStatusKind, Date.now());
+		if (frame.pending) startWorkingFadeTimer();
 		const bar = buildStatusLine(
 			innerWidth,
-			segCtx,
+			{ ...segCtx, workingStatus: frame.status },
 			effective,
 			painters.gapColor,
 			{
-				left: effective.leftSegments,
+				left: topLeftSegments(effective, frame.status !== undefined),
 				right: effective.rightSegments,
 			},
 			{ col: 3, row: 0 },
+			{
+				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)];
@@ -166,12 +224,37 @@ 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 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 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;
+			}
 			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) {
@@ -201,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();
@@ -248,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());
@@ -264,15 +353,16 @@ export default function (pi: ExtensionAPI) {
 		activeCtx = ctx;
 		builder.attach(ctx);
 		rateMonitor.enable();
-		syncRainbow();
+		syncBorderAnimation();
 		ensureInstalled();
+		syncEmbed();
 		ensureFooterPatched();
 		ensureTimer ??= setInterval(() => {
 			ensureInstalled();
 			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?.();
 	});
@@ -280,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);
@@ -300,6 +390,11 @@ export default function (pi: ExtensionAPI) {
 		restoreFooterLayout = undefined;
 		ourFactory = undefined;
 		wrappedFactory = undefined;
+		activeEditor = undefined;
+		embeddedWorkingStatus = undefined;
+		embeddedStatusKind = undefined;
+		stopWorkingFadeTimer();
+		statusTransition.reset();
 		activeTui = undefined;
 		activeCtx = undefined;
 	});

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@underactive/pi-topping-statusline",
-	"version": "0.1.4",
+	"version": "0.2.1",
 	"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.84.4",
-		"@earendil-works/pi-coding-agent": "0.84.4",
-		"@earendil-works/pi-tui": "0.84.4",
+		"@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/context.ts

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

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

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

package/src/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];
+	}
+}