@underactive/pi-topping-statusline 0.2.0 → 0.2.1

package/src/segments.ts

@@ -75,6 +75,24 @@ function classifyProjectDir(pwd: string): { scratch: boolean; relative: string |
 	return { scratch: false, relative: null };
 }
 
+interface PathClassification {
+	scratch: boolean;
+	relative: string | null;
+	strippedDisplay: string;
+}
+
+let cachedCwd: string | undefined;
+let cachedClassification: PathClassification | undefined;
+
+/** cwd is effectively constant for a session, so cache the root scans instead of redoing them on every render (including repeated shrink passes). */
+function classifyCwd(cwd: string): PathClassification {
+	if (cachedCwd === cwd && cachedClassification) return cachedClassification;
+	const { scratch, relative } = classifyProjectDir(cwd);
+	cachedClassification = { scratch, relative, strippedDisplay: stripDisplayRoot(cwd) };
+	cachedCwd = cwd;
+	return cachedClassification;
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Segment implementations
 // ═══════════════════════════════════════════════════════════════════════════
@@ -133,14 +151,14 @@ const pathSegment: StatusLineSegment = {
 			return { content: theme.fg("statusLinePath", content), visible: true };
 		}
 
-		const { scratch, relative } = classifyProjectDir(ctx.cwd);
+		const { scratch, relative, strippedDisplay } = classifyCwd(ctx.cwd);
 		let pwd = ctx.cwd;
 
 		if (opts.stripWorkPrefix) {
 			if (scratch) {
 				if (relative) pwd = relative;
 			} else {
-				pwd = stripDisplayRoot(pwd);
+				pwd = strippedDisplay;
 			}
 		}
 		if (opts.abbreviate) {
@@ -296,9 +314,9 @@ const scrollHintSegment: StatusLineSegment = {
 };
 
 /**
- * Pi's embedded working indicator (spinner + message), already colored by the
- * host, so it is passed through verbatim. The layout truncates it, without an
- * ellipsis, when it overflows, mirroring pi's own border rendering.
+ * Pi's embedded status spinner (spinner + message), already colored by the
+ * host, so it is passed through verbatim. The layout applies the caller's
+ * truncation style: a bare cut for working, ellipsis for message-style kinds.
  */
 const workingSegment: StatusLineSegment = {
 	id: "working",

package/src/settings-menu.ts

@@ -8,6 +8,7 @@ import { makeBoxPainters, renderBoxRow } from "./box.js";
 import type { SegmentContextBuilder } from "./context.js";
 import { buildStatusLine } from "./layout.js";
 import { showMenu, type MenuSection, type MenuValue, type PreviewResult } from "./menu.js";
+import { NvidiaGreenBorder, isSwitchyardProvider } from "./nvidia-green.js";
 import { RAINBOW_CYCLE_MS, RAINBOW_FRAME_MS, RainbowBorder } from "./rainbow.js";
 import {
 	applySettings,
@@ -34,8 +35,10 @@ import type {
 } from "./types.js";
 
 const SYMBOL_LABELS: Record<SymbolPreset, string> = { nerd: "nerdfont", unicode: "unicode", ascii: "ascii" };
-const SYMBOL_FROM_LABEL: Record<string, SymbolPreset> = { nerdfont: "nerd", unicode: "unicode", ascii: "ascii" };
-const SYMBOL_VALUES: readonly string[] = ["nerdfont", "unicode", "ascii"];
+const SYMBOL_VALUES: readonly string[] = Object.values(SYMBOL_LABELS);
+const SYMBOL_FROM_LABEL: Record<string, SymbolPreset> = Object.fromEntries(
+	(Object.entries(SYMBOL_LABELS) as [SymbolPreset, string][]).map(([preset, label]) => [label, preset]),
+);
 
 const SECTION_TITLES = [
 	"Top Left Segment Group",
@@ -141,9 +144,19 @@ function buildSections(settings: StatusLineSettings): MenuSection[] {
 				label: "Animate rainbow border",
 				value: settings.rainbowAnimation ?? true,
 			},
+			{
+				id: "nvidiaGreenBorder",
+				label: "NVIDIA-green when using Switchyard",
+				value: settings.nvidiaGreenBorder ?? true,
+			},
+			{
+				id: "nvidiaGreenAnimation",
+				label: "Animate Switchyard green border",
+				value: settings.nvidiaGreenAnimation ?? true,
+			},
 			{
 				id: "embedWorkingStatus",
-				label: "Embed 'Working' indicator",
+				label: "Embed status spinners",
 				value: settings.embedWorkingStatus ?? false,
 			},
 		],
@@ -176,6 +189,8 @@ function valuesToSettings(values: Record<string, MenuValue>): StatusLineSettings
 		feeds: sanitizeFeeds(feedsFromValues(values)),
 		rainbowBorder: values.rainbowBorder === true,
 		rainbowAnimation: values.rainbowAnimation === true,
+		nvidiaGreenBorder: values.nvidiaGreenBorder === true,
+		nvidiaGreenAnimation: values.nvidiaGreenAnimation === true,
 		embedWorkingStatus: values.embedWorkingStatus === true,
 	};
 }
@@ -193,6 +208,8 @@ const CANNED_PERCENT = 42;
 const CANNED_WINDOW = 200_000;
 /** What pi's border indicator looks like mid-stream with pi-topping's loader installed. */
 const CANNED_WORKING = "⠙ Mulling ⢾⣿⣿⣿⣿⣿⢾⢾  28 tps · 11s · ↓ 316 tokens";
+/** pi 0.86's compaction spinner: the longest status the bar has to carry. */
+const CANNED_COMPACTION = "⠙ Context overflow detected, Auto-compacting... (esc to cancel)";
 
 /** Fill any feed the live session has no entry for, so the preview stays legible. */
 function cannedFeedData(
@@ -221,7 +238,7 @@ class StatusLinePreview {
 	render(
 		values: Record<string, MenuValue>,
 		elapsedMs: number,
-		_activeItemId: string | undefined,
+		activeItemId: string | undefined,
 		innerWidth: number,
 	): PreviewResult {
 		const effective = resolveEffectiveSettings(valuesToSettings(values));
@@ -229,8 +246,6 @@ class StatusLinePreview {
 		// 6-cell chrome budget for the bars themselves.
 		const boxWidth = Math.max(24, innerWidth - 1);
 		const barWidth = boxWidth - 6;
-		const rainbowOn = effective.rainbowBorder;
-		const rainbowAnimationOn = rainbowOn && effective.rainbowAnimation;
 
 		// The theme singleton drives glyph lookups everywhere, so swap the
 		// symbol preset for this synchronous render only; the live bar behind
@@ -245,6 +260,10 @@ class StatusLinePreview {
 				feeds: effective.segmentOptions.feeds.map(f => f.customType),
 			};
 			const base = this.#builder.build(barWidth, effective.segmentOptions, include, CANNED_HINT);
+			const greenOn = effective.nvidiaGreenBorder && isSwitchyardProvider(base.model?.provider);
+			const rainbowOn = !greenOn && effective.rainbowBorder;
+			const animationOn = greenOn ? effective.nvidiaGreenAnimation : rainbowOn && effective.rainbowAnimation;
+			const phase = animationOn ? (elapsedMs * 360) / RAINBOW_CYCLE_MS : 0;
 			const contextWindow = base.contextWindow || CANNED_WINDOW;
 			const ctx: SegmentContext = {
 				...base,
@@ -267,18 +286,23 @@ class StatusLinePreview {
 			const box = theme.getBox(effective.borderStyle);
 			// The preview box is three rows tall: top bar, side verticals, bottom bar.
 			const bottomIdx = 2;
+			const colorizer = greenOn ? new NvidiaGreenBorder(phase) : new RainbowBorder(phase);
 			const painters = makeBoxPainters({
-				rainbowOn,
-				rainbow: new RainbowBorder(rainbowAnimationOn ? (elapsedMs * 360) / RAINBOW_CYCLE_MS : 0),
+				colorizerOn: greenOn || rainbowOn,
+				colorizer,
 				box,
 				width: boxWidth,
 				bottomIdx,
 				flat: s => this.#uiTheme.fg("border", s),
 			});
 			const embedOn = effective.embedWorkingStatus;
+			// Focusing the embed row demos the message-style spinners pi 0.86
+			// routes through the same slot, including their ellipsis truncation.
+			const compactionDemo = activeItemId === "embedWorkingStatus";
+			const sample = compactionDemo ? CANNED_COMPACTION : CANNED_WORKING;
 			const top = buildStatusLine(
 				barWidth,
-				embedOn ? { ...ctx, workingStatus: this.#uiTheme.fg("border", CANNED_WORKING) } : ctx,
+				embedOn ? { ...ctx, workingStatus: this.#uiTheme.fg("border", sample) } : ctx,
 				effective,
 				painters.gapColor,
 				{
@@ -286,6 +310,7 @@ class StatusLinePreview {
 					right: effective.rightSegments,
 				},
 				{ col: 3, row: 0 },
+				{ workingEllipsis: compactionDemo ? "…" : "" },
 			);
 			const bottom = buildStatusLine(
 				barWidth,
@@ -306,8 +331,8 @@ class StatusLinePreview {
 						painters.paint(1, boxWidth - 1, box.vertical),
 					renderBoxRow(painters, bottom, bottomIdx, boxWidth, box.bottomLeft, box.bottomRight),
 				],
-				// A static rainbow stays at phase zero and needs no repaint timer.
-				nextRefreshInMs: rainbowAnimationOn ? RAINBOW_FRAME_MS : undefined,
+				// A static colorizer stays at phase zero and needs no repaint timer.
+				nextRefreshInMs: animationOn ? RAINBOW_FRAME_MS : undefined,
 			};
 		} finally {
 			theme.setSymbolPreset(applied);
@@ -322,7 +347,7 @@ export function registerSettingsCommand(
 	onChange: () => void,
 ): void {
 	pi.registerCommand("topping-statusline-settings", {
-		description: "Configure transparent segments, statusline segments, separator, symbols, border style, feeds, rainbow border animation, and the embedded working indicator",
+		description: "Configure transparent segments, statusline segments, separator, symbols, border style, feeds, rainbow border animation, the Switchyard NVIDIA-green border, and the embedded status spinners",
 		handler: async (_args, ctx: ExtensionCommandContext) => {
 			if (ctx.mode !== "tui") {
 				ctx.ui.notify("/topping-statusline-settings requires TUI mode", "error");

package/src/settings.ts

@@ -93,6 +93,8 @@ function loadSettings(): StatusLineSettings {
 		if (raw.feeds !== undefined) settings.feeds = sanitizeFeeds(raw.feeds);
 		if (typeof raw.rainbowBorder === "boolean") settings.rainbowBorder = raw.rainbowBorder;
 		if (typeof raw.rainbowAnimation === "boolean") settings.rainbowAnimation = raw.rainbowAnimation;
+		if (typeof raw.nvidiaGreenBorder === "boolean") settings.nvidiaGreenBorder = raw.nvidiaGreenBorder;
+		if (typeof raw.nvidiaGreenAnimation === "boolean") settings.nvidiaGreenAnimation = raw.nvidiaGreenAnimation;
 		if (typeof raw.embedWorkingStatus === "boolean") settings.embedWorkingStatus = raw.embedWorkingStatus;
 		return settings;
 	} catch {
@@ -156,6 +158,8 @@ export function resolveEffectiveSettings(settings: StatusLineSettings): Effectiv
 		bottomRightSegments,
 		rainbowBorder: settings.rainbowBorder ?? true,
 		rainbowAnimation: settings.rainbowAnimation ?? true,
+		nvidiaGreenBorder: settings.nvidiaGreenBorder ?? true,
+		nvidiaGreenAnimation: settings.nvidiaGreenAnimation ?? true,
 		embedWorkingStatus: settings.embedWorkingStatus ?? false,
 		includes,
 		segmentOptions: {
@@ -168,9 +172,9 @@ export function resolveEffectiveSettings(settings: StatusLineSettings): Effectiv
 }
 
 /**
- * The top-left group for one frame. While pi's working status is embedded,
- * it stands in for every left segment except the leading Pi symbol, so the
- * symbol and its chevron never move when a stream starts or ends.
+ * The top-left group for one frame. While a pi status spinner is embedded, it
+ * stands in for every left segment except the leading Pi symbol, so the symbol
+ * and its chevron never move when a status appears or clears.
  */
 export function topLeftSegments(effective: EffectiveStatusLineSettings, working: boolean): StatusLineSegmentId[] {
 	if (!working) return effective.leftSegments;

package/src/tests/box.test.ts

@@ -24,8 +24,8 @@ const ROUNDED: BoxGlyphs = {
 
 const identityPainters = (boxWidth: number) =>
 	makeBoxPainters({
-		rainbowOn: false,
-		rainbow: new RainbowBorder(0),
+		colorizerOn: false,
+		colorizer: new RainbowBorder(0),
 		box: ROUNDED,
 		width: boxWidth,
 		bottomIdx: 2,
@@ -71,8 +71,8 @@ test("a bar wider than the budget clamps pad to zero", () => {
 
 test("non-rainbow painters wrap whole runs in one flat call", () => {
 	const painters = makeBoxPainters({
-		rainbowOn: false,
-		rainbow: new RainbowBorder(0),
+		colorizerOn: false,
+		colorizer: new RainbowBorder(0),
 		box: ROUNDED,
 		width: 20,
 		bottomIdx: 2,
@@ -85,8 +85,8 @@ test("non-rainbow painters wrap whole runs in one flat call", () => {
 
 test("rainbow coloring never changes the geometry", () => {
 	const painters = makeBoxPainters({
-		rainbowOn: true,
-		rainbow: new RainbowBorder(0),
+		colorizerOn: true,
+		colorizer: new RainbowBorder(0),
 		box: ROUNDED,
 		width: 20,
 		bottomIdx: 2,

package/src/tests/footer.test.ts

@@ -48,6 +48,7 @@ test("filterVisibleRows drops empty notifications but keeps visible rows", () =>
 test("fullscreen footer slot can collapse and restores its minimum", () => {
 	const footer = { render: () => [] };
 	const footerContainer = { children: [footer] };
+	// minSize: 1 mirrors the footer dock shape used by hosts before pi 0.86.
 	const footerEntry = { component: footerContainer, minSize: 1 };
 	const dock = { entries: [{ component: {} }, footerEntry] };
 	const root = { entries: [{ component: {} }, { component: dock, minSize: 1 }] };

package/src/tests/nvidia-green.test.ts

@@ -0,0 +1,51 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+	NVIDIA_GREEN_DARK_HEX,
+	NVIDIA_GREEN_HEX,
+	NvidiaGreenBorder,
+	isSwitchyardProvider,
+} from "../nvidia-green.ts";
+import { resolveEffectiveSettings } from "../settings.ts";
+import { detectColorMode, hexToFgAnsi } from "../theme.ts";
+
+test("recognizes the Switchyard provider case-insensitively after trimming", () => {
+	assert.equal(isSwitchyardProvider("switchyard"), true);
+	assert.equal(isSwitchyardProvider(" Switchyard "), true);
+	assert.equal(isSwitchyardProvider(undefined), false);
+	assert.equal(isSwitchyardProvider(""), false);
+	assert.equal(isSwitchyardProvider("other"), false);
+});
+
+test("switchyard green settings default to true and resolve explicit false", () => {
+	const defaults = resolveEffectiveSettings({});
+	assert.equal(defaults.nvidiaGreenBorder, true);
+	assert.equal(defaults.nvidiaGreenAnimation, true);
+	const off = resolveEffectiveSettings({ nvidiaGreenBorder: false, nvidiaGreenAnimation: false });
+	assert.equal(off.nvidiaGreenBorder, false);
+	assert.equal(off.nvidiaGreenAnimation, false);
+});
+
+test("colorChar wraps a glyph in a color escape and foreground reset", () => {
+	const border = new NvidiaGreenBorder();
+	assert.match(border.colorChar("─", 0, 28), /^\x1b\[38;(2;\d+;\d+;\d+|5;\d+)m─\x1b\[39m$/);
+});
+
+test("phase zero has bright and dark opposite endpoints", () => {
+	const mode = detectColorMode();
+	const border = new NvidiaGreenBorder(0);
+	assert.equal(border.colorChar("─", 0, 28), `${hexToFgAnsi(NVIDIA_GREEN_HEX, mode)}─\x1b[39m`);
+	assert.equal(border.colorChar("─", 14, 28), `${hexToFgAnsi(NVIDIA_GREEN_DARK_HEX, mode)}─\x1b[39m`);
+});
+
+test("step by one full turn preserves the color", () => {
+	const stepped = new NvidiaGreenBorder(37);
+	const unchanged = new NvidiaGreenBorder(37);
+	stepped.step(360);
+	assert.equal(stepped.colorChar("─", 7, 28), unchanged.colorChar("─", 7, 28));
+});
+
+test("opposite positions receive different shades", () => {
+	const border = new NvidiaGreenBorder();
+	assert.notEqual(border.colorChar("─", 0, 28), border.colorChar("─", 14, 28));
+});

package/src/tests/working-status.test.ts

@@ -0,0 +1,158 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { STATUS_HOLD_MS, StatusTransition, WORKING_FADE_MS } from "../working-status.ts";
+
+test("a live status is returned verbatim without scheduling repaints", () => {
+	const transition = new StatusTransition();
+
+	assert.deepEqual(transition.resolve("⠙ Working", "working", 1_000), {
+		status: "⠙ Working",
+		kind: "working",
+		pending: false,
+	});
+	assert.equal(transition.pending(1_000), false);
+});
+
+test("clearing a working status holds it, cross-fades both halves, then settles", () => {
+	const transition = new StatusTransition();
+	transition.resolve("⠙ Working", "working", 1_000);
+
+	const clearedAt = 2_000;
+	const holdEndsAt = clearedAt + STATUS_HOLD_MS;
+	assert.deepEqual(transition.resolve(undefined, undefined, clearedAt), {
+		status: "⠙ Working",
+		kind: "working",
+		pending: true,
+	});
+	assert.deepEqual(transition.resolve(undefined, undefined, holdEndsAt - 1), {
+		status: "⠙ Working",
+		kind: "working",
+		pending: true,
+	});
+
+	const outgoingStart = transition.resolve(undefined, undefined, holdEndsAt);
+	const outgoingMiddle = transition.resolve(undefined, undefined, holdEndsAt + 150);
+	const outgoingEnd = transition.resolve(undefined, undefined, holdEndsAt + WORKING_FADE_MS / 2 - 1);
+	assert.equal(outgoingStart.status, "⠙ Working");
+	assert.equal(outgoingMiddle.status, "⠙ Working");
+	assert.equal(outgoingEnd.status, "⠙ Working");
+	assert.ok(
+		(outgoingStart.leftFade ?? -1) > (outgoingMiddle.leftFade ?? -1) &&
+			(outgoingMiddle.leftFade ?? -1) > (outgoingEnd.leftFade ?? -1),
+		"outgoing opacity decreases monotonically",
+	);
+
+	const incomingStart = transition.resolve(undefined, undefined, holdEndsAt + WORKING_FADE_MS / 2);
+	const incomingMiddle = transition.resolve(undefined, undefined, holdEndsAt + 550);
+	const incomingEnd = transition.resolve(undefined, undefined, holdEndsAt + WORKING_FADE_MS - 1);
+	assert.equal(incomingStart.status, undefined);
+	assert.equal(incomingMiddle.status, undefined);
+	assert.equal(incomingEnd.status, undefined);
+	assert.ok(
+		(incomingStart.leftFade ?? 2) < (incomingMiddle.leftFade ?? 2) &&
+			(incomingMiddle.leftFade ?? 2) < (incomingEnd.leftFade ?? 2),
+		"incoming opacity increases monotonically",
+	);
+	assert.equal(transition.pending(holdEndsAt + WORKING_FADE_MS - 1), true);
+
+	assert.deepEqual(transition.resolve(undefined, undefined, holdEndsAt + WORKING_FADE_MS), {
+		status: undefined,
+		kind: undefined,
+		pending: false,
+	});
+	assert.equal(transition.pending(holdEndsAt + WORKING_FADE_MS), false);
+});
+
+test("clearing message-style statuses holds them and then cuts without a fade", () => {
+	for (const kind of ["compaction", "retry"] as const) {
+		const transition = new StatusTransition();
+		transition.resolve(`⠙ ${kind}`, kind, 100);
+		assert.deepEqual(transition.resolve(undefined, undefined, 200), {
+			status: `⠙ ${kind}`,
+			kind,
+			pending: true,
+		});
+		assert.deepEqual(transition.resolve(undefined, undefined, 200 + STATUS_HOLD_MS - 1), {
+			status: `⠙ ${kind}`,
+			kind,
+			pending: true,
+		});
+		assert.deepEqual(transition.resolve(undefined, undefined, 200 + STATUS_HOLD_MS), {
+			status: undefined,
+			kind: undefined,
+			pending: false,
+		});
+	}
+});
+
+test("a new status during the hold cuts in immediately and cancels the exit", () => {
+	const transition = new StatusTransition();
+	transition.resolve("⠙ Working", "working", 1_000);
+	transition.resolve(undefined, undefined, 1_100);
+
+	assert.deepEqual(transition.resolve("⠹ Retrying", "retry", 1_200), {
+		status: "⠹ Retrying",
+		kind: "retry",
+		pending: false,
+	});
+	assert.equal(transition.pending(2_000), false);
+});
+
+test("a new status during the fade cuts in immediately and cancels the exit", () => {
+	const transition = new StatusTransition();
+	transition.resolve("⠙ Working", "working", 0);
+	transition.resolve(undefined, undefined, 100);
+	const fading = transition.resolve(undefined, undefined, 300);
+	assert.equal(fading.status, "⠙ Working");
+	assert.equal(fading.pending, true);
+
+	assert.deepEqual(transition.resolve("⠸ Compacting", "compaction", 301), {
+		status: "⠸ Compacting",
+		kind: "compaction",
+		pending: false,
+	});
+	assert.equal(transition.pending(1_000), false);
+});
+
+test("a working-to-compaction handoff across the hold never yields an empty status", () => {
+	const transition = new StatusTransition();
+	const frames = [
+		transition.resolve("⠙ Working", "working", 0),
+		transition.resolve(undefined, undefined, 100),
+		transition.resolve(undefined, undefined, 100 + STATUS_HOLD_MS - 1),
+		transition.resolve("⠸ Compacting", "compaction", 100 + STATUS_HOLD_MS),
+	];
+
+	assert.ok(frames.every(frame => frame.status !== undefined));
+	assert.equal(frames.at(-1)?.kind, "compaction");
+});
+
+test("an undefined kind preserves the pre-0.86 working fade", () => {
+	const transition = new StatusTransition();
+	transition.resolve("⠙ Working", undefined, 0);
+	transition.resolve(undefined, undefined, 10);
+
+	const fadeStarts = transition.resolve(undefined, undefined, 10 + STATUS_HOLD_MS);
+	assert.equal(fadeStarts.status, "⠙ Working");
+	assert.equal(fadeStarts.leftFade, 1);
+	assert.equal(fadeStarts.pending, true);
+	assert.deepEqual(transition.resolve(undefined, undefined, 10 + STATUS_HOLD_MS + WORKING_FADE_MS), {
+		status: undefined,
+		kind: undefined,
+		pending: false,
+	});
+});
+
+test("reset clears live and exiting state", () => {
+	const transition = new StatusTransition();
+	transition.resolve("⠙ Working", "working", 10);
+	transition.resolve(undefined, undefined, 20);
+	transition.reset();
+
+	assert.deepEqual(transition.resolve(undefined, undefined, 21), {
+		status: undefined,
+		kind: undefined,
+		pending: false,
+	});
+	assert.equal(transition.pending(21), false);
+});

package/src/tests/working.test.ts

@@ -1,8 +1,9 @@
 /**
- * Contracts for the opt-in embedded working indicator: the `working` segment
+ * Contracts for the opt-in embedded status indicator: the `working` segment
  * passes pi's pre-rendered status through verbatim, the top-left group swaps
  * everything but the Pi symbol for it while a stream is live, and the layout
- * truncates it (no ellipsis) before any other left segment is dropped.
+ * truncates it before any other left segment is dropped. The caller chooses
+ * whether truncated status text uses an ellipsis.
  */
 import assert from "node:assert/strict";
 import test from "node:test";
@@ -88,6 +89,26 @@ test("narrow widths truncate the status without an ellipsis and keep the pi symb
 	assert.equal(visibleWidth(bar), 20);
 });
 
+test("workingEllipsis marks truncated prose without changing the bar width", () => {
+	const status = "⠙ Context overflow detected, Auto-compacting... (esc to cancel)";
+	for (const width of [12, 16, 24, 40, 60]) {
+		const bar = buildStatusLine(
+			width,
+			ctxWith(status),
+			EFFECTIVE,
+			noGap,
+			{ left: ["pi", "working"], right: [] },
+			{ col: 0, row: 0 },
+			{ workingEllipsis: "…" },
+		);
+		const plain = stripAnsi(bar);
+		assert.ok(plain.includes(theme.icon.pi), `pi symbol survives at width ${width}`);
+		assert.ok(plain.includes("…"), `truncated status ends with an ellipsis at width ${width}`);
+		assert.ok(!plain.includes("cancel"), `status tail is cut at width ${width}`);
+		assert.equal(visibleWidth(bar), width, `width ${width}`);
+	}
+});
+
 test("a long ANSI-styled status never exceeds the bar width", () => {
 	const status = `\x1b[38;2;10;20;30m⠙ ${"Working ".repeat(30)}\x1b[39m`;
 	for (const width of [12, 16, 24, 40, 60]) {

package/src/types.ts

@@ -74,7 +74,11 @@ export interface StatusLineSettings {
 	rainbowBorder?: boolean;
 	/** Animate the rainbow border when it is visible. */
 	rainbowAnimation?: boolean;
-	/** Render pi's streaming working status in the top bar instead of its own row. */
+	/** NVIDIA-green gradient border while the model provider is Switchyard. */
+	nvidiaGreenBorder?: boolean;
+	/** Animate the Switchyard green border when it is visible. */
+	nvidiaGreenAnimation?: boolean;
+	/** Render pi's status spinners in the top bar instead of their own row. */
 	embedWorkingStatus?: boolean;
 }
 
@@ -108,6 +112,8 @@ export interface EffectiveStatusLineSettings {
 	segmentOptions: StatusLineSegmentOptions;
 	rainbowBorder: boolean;
 	rainbowAnimation: boolean;
+	nvidiaGreenBorder: boolean;
+	nvidiaGreenAnimation: boolean;
 	embedWorkingStatus: boolean;
 	includes: SegmentIncludes;
 }
@@ -138,8 +144,8 @@ export interface SegmentContext {
 	/** Pi's own footer stats, when this frame needs them. */
 	piStats: string | undefined;
 	/**
-	 * Pi's embedded working indicator, pre-rendered and pre-colored by the host
-	 * for this frame. Absent while no response is streaming.
+	 * Pi's embedded status spinner, pre-rendered and pre-colored by the host for
+	 * this frame. Absent while no status indicator is active.
 	 */
 	workingStatus?: string;
 	/** Live tok/s display state, when this frame needs it. */

package/src/working-status.ts

@@ -0,0 +1,98 @@
+import type { CustomEditor } from "@earendil-works/pi-coding-agent";
+import { easeFade } from "./theme.js";
+
+export type StatusIndicatorKind = NonNullable<Parameters<CustomEditor["setWorkingStatusIndicator"]>[0]>["kind"];
+
+/** Briefly retain a cleared status so handoffs between host indicators do not flash. */
+export const STATUS_HOLD_MS = 150;
+/** Cross-fade budget when the embedded working status disappears: half out, half in. */
+export const WORKING_FADE_MS = 750;
+
+/** True when a status kind is a message-style indicator rather than the working spinner. */
+export function isMessageKind(kind: StatusIndicatorKind | undefined): boolean {
+	return kind !== undefined && kind !== "working";
+}
+
+/** Which status the top-left group shows this frame and how far it has faded. */
+export interface StatusFrame {
+	status: string | undefined;
+	leftFade?: number;
+	/** Kind of the status this frame shows, for truncation styling. */
+	kind: StatusIndicatorKind | undefined;
+	/** True while a hold or fade still needs repaints. */
+	pending: boolean;
+}
+
+interface StatusExit {
+	holdUntil: number;
+	fadeMs: number;
+}
+
+/**
+ * Resolve host status-indicator handoffs into stable top-bar frames.
+ *
+ * pi 0.86 routes working, retry, compaction, and branch-summary indicators
+ * through the editor border and may clear the slot between them. A cleared
+ * status is held briefly to bridge that gap. Only the working indicator — the
+ * one that genuinely ends a stream — then cross-fades back to user segments.
+ */
+export class StatusTransition {
+	#liveShown = false;
+	#lastStatus: string | undefined;
+	#lastKind: StatusIndicatorKind | undefined;
+	#exit: StatusExit | undefined;
+
+	resolve(live: string | undefined, kind: StatusIndicatorKind | undefined, now: number): StatusFrame {
+		if (live !== undefined) {
+			this.#liveShown = true;
+			this.#lastStatus = live;
+			this.#lastKind = kind;
+			this.#exit = undefined;
+			return { status: live, kind, pending: false };
+		}
+
+		if (this.#liveShown) {
+			this.#liveShown = false;
+			this.#exit = {
+				holdUntil: now + STATUS_HOLD_MS,
+				fadeMs: isMessageKind(this.#lastKind) ? 0 : WORKING_FADE_MS,
+			};
+		}
+
+		const exit = this.#exit;
+		if (!exit) return { status: undefined, kind: undefined, pending: false };
+		if (now < exit.holdUntil) {
+			return { status: this.#lastStatus, kind: this.#lastKind, pending: true };
+		}
+		const elapsed = now - exit.holdUntil;
+		if (elapsed >= exit.fadeMs) {
+			this.#clearExit();
+			return { status: undefined, kind: undefined, pending: false };
+		}
+		const half = exit.fadeMs / 2;
+		const outgoing = elapsed < half;
+		const leftFade = easeFade(outgoing ? 1 - elapsed / half : (elapsed - half) / half);
+		return {
+			status: outgoing ? this.#lastStatus : undefined,
+			kind: outgoing ? this.#lastKind : undefined,
+			leftFade,
+			pending: true,
+		};
+	}
+
+	pending(now: number): boolean {
+		const exit = this.#exit;
+		return exit !== undefined && now < exit.holdUntil + exit.fadeMs;
+	}
+
+	reset(): void {
+		this.#liveShown = false;
+		this.#clearExit();
+	}
+
+	#clearExit(): void {
+		this.#lastStatus = undefined;
+		this.#lastKind = undefined;
+		this.#exit = undefined;
+	}
+}