@underactive/pi-topping-statusline 0.2.0 → 0.2.2

package/src/settings-menu.ts

@@ -5,13 +5,16 @@
  */
 import type { ExtensionAPI, ExtensionCommandContext, Theme } from "@earendil-works/pi-coding-agent";
 import { makeBoxPainters, renderBoxRow } from "./box.js";
+import { COMPACTION_FIT_PROBE } from "./compaction-embed.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,
 	BORDER_STYLES,
+	bottomRightSegments,
 	DEFAULT_FEEDS,
 	DEFAULT_SEGMENTS,
 	FEED_FORMATS,
@@ -34,8 +37,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",
@@ -68,48 +73,64 @@ const SEGMENT_ROWS: readonly {
 	{ id: "tokenRateBottomLeft", label: "Token rate", section: "Bottom Left Segment Group" },
 ];
 
-// Feed rows are addressed by index so a rebuild can drop one cleanly.
+// Feed rows carry a stable key (independent of on-screen position) so
+// MenuComponent.rebuild's id-keyed value carry-over survives a removal.
 const FEED_PREFIX = "feed";
-const feedKey = (index: number, part: keyof StatusLineFeed) => `${FEED_PREFIX}.${index}.${part}`;
+const feedKey = (key: number, part: keyof StatusLineFeed) => `${FEED_PREFIX}.${key}.${part}`;
 const ADD_FEED_ID = `${FEED_PREFIX}.add`;
-const removeFeedId = (index: number) => `${FEED_PREFIX}.${index}.remove`;
+const removeFeedId = (key: number) => `${FEED_PREFIX}.${key}.remove`;
 const FEED_ROW_RE = new RegExp(`^${FEED_PREFIX}\\.(\\d+)\\.`);
+const REMOVE_FEED_RE = new RegExp(`^${FEED_PREFIX}\\.(\\d+)\\.remove$`);
 
-function feedSection(feeds: readonly StatusLineFeed[]): MenuSection {
+interface FeedPair {
+	key: number;
+	feed: StatusLineFeed;
+}
+
+const pairsFromFeeds = (feeds: readonly StatusLineFeed[]): FeedPair[] => feeds.map((feed, key) => ({ key, feed }));
+
+function feedSection(pairs: readonly FeedPair[]): MenuSection {
 	const items: MenuSection["items"] = [];
-	for (const [index, feed] of feeds.entries()) {
+	pairs.forEach(({ key, feed }, index) => {
 		const n = index + 1;
 		items.push(
-			{ id: feedKey(index, "customType"), label: `${n}. type`, value: feed.customType, text: true, placeholder: "ext/custom-type" },
-			{ id: feedKey(index, "field"), label: `${n}. field`, value: feed.field, text: true, placeholder: "fieldName" },
-			{ id: feedKey(index, "prefix"), label: `${n}. prefix`, value: feed.prefix, text: true, placeholder: "(none)" },
-			{ id: feedKey(index, "format"), label: `${n}. format`, value: feed.format, cycleValues: FEED_FORMATS },
-			{ id: removeFeedId(index), label: `${n}. remove this feed`, value: false, action: true },
+			{ id: feedKey(key, "customType"), label: `${n}. type`, value: feed.customType, text: true, placeholder: "ext/custom-type" },
+			{ id: feedKey(key, "field"), label: `${n}. field`, value: feed.field, text: true, placeholder: "fieldName" },
+			{ id: feedKey(key, "prefix"), label: `${n}. prefix`, value: feed.prefix, text: true, placeholder: "(none)" },
+			{ id: feedKey(key, "format"), label: `${n}. format`, value: feed.format, cycleValues: FEED_FORMATS },
+			{ id: removeFeedId(key), label: `${n}. remove this feed`, value: false, action: true },
 		);
-	}
+	});
 	items.push({ id: ADD_FEED_ID, label: "+ add feed", value: false, action: true });
 	return { title: "Feeds", items };
 }
 
-/** Read the feed rows back out of the menu's flat value map. */
-function feedsFromValues(values: Record<string, MenuValue>): StatusLineFeed[] {
-	const indices = new Set<number>();
-	for (const key of Object.keys(values)) {
-		const match = FEED_ROW_RE.exec(key);
-		if (match) indices.add(Number(match[1]));
+/** Read the feed rows back out of the menu's flat value map, keyed by their stable id. */
+function feedPairsFromValues(values: Record<string, MenuValue>): FeedPair[] {
+	const keys = new Set<number>();
+	for (const id of Object.keys(values)) {
+		const match = FEED_ROW_RE.exec(id);
+		if (match) keys.add(Number(match[1]));
 	}
-	return [...indices]
+	return [...keys]
 		.sort((a, b) => a - b)
-		.map((index): StatusLineFeed => {
-			const rawFormat = String(values[feedKey(index, "format")] ?? "text");
+		.map((key): FeedPair => {
+			const rawFormat = String(values[feedKey(key, "format")] ?? "text");
 			return {
-				customType: String(values[feedKey(index, "customType")] ?? ""),
-				field: String(values[feedKey(index, "field")] ?? ""),
-				prefix: String(values[feedKey(index, "prefix")] ?? ""),
-				format: FEED_FORMATS.includes(rawFormat as FeedFormat) ? (rawFormat as FeedFormat) : "text",
+				key,
+				feed: {
+					customType: String(values[feedKey(key, "customType")] ?? ""),
+					field: String(values[feedKey(key, "field")] ?? ""),
+					prefix: String(values[feedKey(key, "prefix")] ?? ""),
+					format: FEED_FORMATS.includes(rawFormat as FeedFormat) ? (rawFormat as FeedFormat) : "text",
+				},
 			};
 		})
-		.filter(feed => feed.customType.trim() || feed.field.trim() || feed.prefix.trim());
+		.filter(({ feed }) => feed.customType.trim() || feed.field.trim() || feed.prefix.trim());
+}
+
+function feedsFromValues(values: Record<string, MenuValue>): StatusLineFeed[] {
+	return feedPairsFromValues(values).map(({ feed }) => feed);
 }
 
 function buildSections(settings: StatusLineSettings): MenuSection[] {
@@ -141,11 +162,26 @@ 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,
 			},
+			{
+				id: "embedCompactionProgress",
+				label: "Embed compaction progress",
+				value: settings.embedCompactionProgress ?? true,
+			},
 		],
 	};
 	return [
@@ -158,7 +194,7 @@ function buildSections(settings: StatusLineSettings): MenuSection[] {
 				value: seg[row.id],
 			})),
 		})),
-		feedSection(settings.feeds ? sanitizeFeeds(settings.feeds) : DEFAULT_FEEDS),
+		feedSection(pairsFromFeeds(settings.feeds ? sanitizeFeeds(settings.feeds) : DEFAULT_FEEDS)),
 	];
 }
 
@@ -176,7 +212,10 @@ 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,
+		embedCompactionProgress: values.embedCompactionProgress === true,
 	};
 }
 
@@ -193,6 +232,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 +262,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 +270,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 +284,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 +310,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,15 +334,19 @@ class StatusLinePreview {
 					right: effective.rightSegments,
 				},
 				{ col: 3, row: 0 },
+				{ workingEllipsis: compactionDemo ? "…" : "" },
 			);
+			// Focusing the compaction row demos the bottom bar hosting
+			// pi-topping-compact's progress, while the setting is on.
+			const progressDemo = activeItemId === "embedCompactionProgress" && effective.embedCompactionProgress;
 			const bottom = buildStatusLine(
 				barWidth,
-				ctx,
+				progressDemo ? { ...ctx, compaction: COMPACTION_FIT_PROBE } : ctx,
 				effective,
 				painters.gapColor,
 				{
 					left: effective.bottomLeftSegments,
-					right: effective.bottomRightSegments,
+					right: bottomRightSegments(effective, progressDemo),
 				},
 				{ col: 3, row: bottomIdx },
 			);
@@ -306,8 +358,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 +374,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, the embedded status spinners, and the embedded compaction progress",
 		handler: async (_args, ctx: ExtensionCommandContext) => {
 			if (ctx.mode !== "tui") {
 				ctx.ui.notify("/topping-statusline-settings requires TUI mode", "error");
@@ -335,17 +387,20 @@ export function registerSettingsCommand(
 				hints: ["↑↓ move", "←→ cycle", "␣ toggle", "⏎ apply/edit", "esc cancel"],
 				preview: preview.render.bind(preview),
 				onAction: (id, values) => {
-					const feeds = feedsFromValues(values);
+					const pairs = feedPairsFromValues(values);
+					let nextPairs: FeedPair[];
 					if (id === ADD_FEED_ID) {
-						feeds.push({ customType: "", field: "", prefix: "", format: "currency" });
+						const key = Math.max(-1, ...pairs.map(p => p.key)) + 1;
+						nextPairs = [...pairs, { key, feed: { customType: "", field: "", prefix: "", format: "currency" } }];
 					} else {
-						const match = new RegExp(`^${FEED_PREFIX}\\.(\\d+)\\.remove$`).exec(id);
+						const match = REMOVE_FEED_RE.exec(id);
 						if (!match) return undefined;
-						feeds.splice(Number(match[1]), 1);
+						const removedKey = Number(match[1]);
+						nextPairs = pairs.filter(p => p.key !== removedKey);
 					}
-					// Rows are index-addressed, so the whole menu is regenerated to
-					// keep ids contiguous after an insert or removal.
-					return [...buildSections(valuesToSettings(values)).slice(0, -1), feedSection(feeds)];
+					// The whole menu is regenerated so positional labels stay correct
+					// after an insert or removal; row ids are untouched by this.
+					return [...buildSections(valuesToSettings(values)).slice(0, -1), feedSection(nextPairs)];
 				},
 			});
 			if (!result.applied) return;

package/src/settings.ts

@@ -93,7 +93,10 @@ 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;
+		if (typeof raw.embedCompactionProgress === "boolean") settings.embedCompactionProgress = raw.embedCompactionProgress;
 		return settings;
 	} catch {
 		// Missing or corrupt settings.json falls back to defaults.
@@ -156,7 +159,10 @@ 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,
+		embedCompactionProgress: settings.embedCompactionProgress ?? true,
 		includes,
 		segmentOptions: {
 			model: { showModel: seg.model, showProvider: seg.provider, showThinking: seg.thinking },
@@ -167,14 +173,34 @@ export function resolveEffectiveSettings(settings: StatusLineSettings): Effectiv
 	};
 }
 
+/** Segments that remain visible, unfaded, while a pi status spinner is embedded. */
+export const STATUS_STABLE_SEGMENTS: ReadonlySet<StatusLineSegmentId> = new Set(["pi", "model"]);
+
 /**
- * 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 the path and repository segments but keeps the leading Pi
+ * symbol and configured model details visible.
  */
 export function topLeftSegments(effective: EffectiveStatusLineSettings, working: boolean): StatusLineSegmentId[] {
 	if (!working) return effective.leftSegments;
-	return effective.leftSegments[0] === "pi" ? ["pi", "working"] : ["working"];
+	const segments = effective.leftSegments.filter((id) => STATUS_STABLE_SEGMENTS.has(id));
+	segments.splice(segments.indexOf("pi") + 1, 0, "working");
+	return segments;
+}
+
+/** Bottom-right segments a hosted compaction stands in for, and their stand-ins. */
+export const COMPACTION_STAND_INS: Partial<Record<StatusLineSegmentId, StatusLineSegmentId>> = {
+	pi_stats: "compaction_info",
+	context_graph: "compaction_graph",
+};
+
+/**
+ * The bottom-right group for one frame. While pi-topping-compact's progress is
+ * hosted, its figures stand in for pi's stats and its bar for the context graph.
+ */
+export function bottomRightSegments(effective: EffectiveStatusLineSettings, compacting: boolean): StatusLineSegmentId[] {
+	if (!compacting) return effective.bottomRightSegments;
+	return effective.bottomRightSegments.map((id) => COMPACTION_STAND_INS[id] ?? id);
 }
 
 export interface SettingsState {

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/compaction-embed.test.ts

@@ -0,0 +1,184 @@
+/**
+ * Contracts for hosting pi-topping-compact's compaction progress: the broadcast
+ * parser, the preconditions for announcing that the bar hosts it, the
+ * bottom-right stand-ins, and the two segments that draw the bar and figures.
+ */
+import assert from "node:assert/strict";
+import test from "node:test";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { hostsCompactionProgress, parseCompactionProgress } from "../compaction-embed.ts";
+import { stripAnsi } from "../footer.ts";
+import { buildStatusLine } from "../layout.ts";
+import { formatCompactionInfo, formatCompactionTokens, SEGMENTS } from "../segments.ts";
+import { bottomRightSegments, resolveEffectiveSettings } from "../settings.ts";
+import { theme } from "../theme.ts";
+import type { CompactionProgressView, SegmentContext } from "../types.ts";
+
+const noGap = (s: string) => s;
+const EFFECTIVE = resolveEffectiveSettings({ transparent: true });
+
+const BAR = `\x1b[38;2;114;241;184m${"▋".repeat(7)}\x1b[39m\x1b[2m${"░".repeat(13)}\x1b[22m\x1b[39m`;
+const VIEW: CompactionProgressView = {
+	bar: BAR,
+	percent: 47,
+	tokensBefore: 86_000,
+	contextWindow: 131_072,
+	elapsedMs: 16_300,
+};
+const DOT = theme.sep.dot;
+
+function ctxWith(compaction: CompactionProgressView | undefined): SegmentContext {
+	return {
+		options: EFFECTIVE.segmentOptions,
+		model: undefined,
+		thinkingLevel: "off",
+		cwd: "/tmp/pi-topping-statusline-tests",
+		sessionName: undefined,
+		contextPercent: 41,
+		contextTokens: 53_740,
+		contextWindow: 131_072,
+		git: { branch: null, status: null, pr: null },
+		worktree: null,
+		scrollHint: undefined,
+		piStats: "↑ 142K ↓ 16K R 4.2M",
+		tokenRate: undefined,
+		feedData: undefined,
+		compaction,
+	};
+}
+
+test("parseCompactionProgress accepts an active broadcast and rejects everything else", () => {
+	assert.deepEqual(
+		parseCompactionProgress({ active: true, ...VIEW, phase: "summarizing", remainingPercent: 35 }),
+		VIEW,
+		"the rest of the snapshot is ignored",
+	);
+	assert.equal(parseCompactionProgress({ active: false }), undefined);
+	assert.equal(parseCompactionProgress({ ...VIEW, active: "true" }), undefined);
+	assert.equal(parseCompactionProgress({ active: true, ...VIEW, bar: 7 }), undefined);
+	assert.equal(parseCompactionProgress({ active: true, ...VIEW, percent: undefined }), undefined);
+	assert.equal(parseCompactionProgress({ active: true, ...VIEW, percent: Number.NaN }), undefined);
+	assert.equal(parseCompactionProgress({ active: true, ...VIEW, tokensBefore: "86000" }), undefined);
+	assert.equal(parseCompactionProgress({ active: true, ...VIEW, elapsedMs: "16.3" }), undefined);
+	assert.equal(parseCompactionProgress(undefined), undefined);
+	assert.equal(parseCompactionProgress(null), undefined);
+	assert.equal(parseCompactionProgress([{ active: true, ...VIEW }]), undefined);
+	assert.equal(parseCompactionProgress("active"), undefined);
+});
+
+test("embedCompactionProgress resolves on by default and off when set", () => {
+	assert.equal(resolveEffectiveSettings({}).embedCompactionProgress, true);
+	assert.equal(resolveEffectiveSettings({ embedCompactionProgress: false }).embedCompactionProgress, false);
+});
+
+test("the bar hosts the progress only with the setting on and a stand-in slot shown", () => {
+	assert.equal(hostsCompactionProgress(EFFECTIVE), true);
+	assert.equal(hostsCompactionProgress(resolveEffectiveSettings({ embedCompactionProgress: false })), false);
+	const graphOnly = resolveEffectiveSettings({ segments: { piStats: false } });
+	assert.equal(hostsCompactionProgress(graphOnly), true, "the context graph alone hosts the bar");
+	const statsOnly = resolveEffectiveSettings({ segments: { contextBar: false, contextStats: false } });
+	assert.equal(hostsCompactionProgress(statsOnly), true, "pi stats alone host the figures");
+	const nowhere = resolveEffectiveSettings({ segments: { piStats: false, contextBar: false, contextStats: false } });
+	assert.equal(hostsCompactionProgress(nowhere), false);
+});
+
+test("bottomRightSegments swaps in the stand-ins in place while compacting", () => {
+	const effective = resolveEffectiveSettings({ segments: { feeds: true, tokenRate: true } });
+	assert.deepEqual(effective.bottomRightSegments, ["feeds", "token_rate", "pi_stats", "context_graph"]);
+	assert.deepEqual(bottomRightSegments(effective, true), [
+		"feeds",
+		"token_rate",
+		"compaction_info",
+		"compaction_graph",
+	]);
+	assert.equal(bottomRightSegments(effective, false), effective.bottomRightSegments);
+});
+
+test("formatCompactionInfo reads how much is summarized and the time taken", () => {
+	assert.equal(formatCompactionInfo(VIEW), `47% summarized${DOT}16.3s`);
+	assert.equal(formatCompactionInfo({ ...VIEW, percent: 0, elapsedMs: 0 }), `0% summarized${DOT}0.0s`);
+	assert.equal(formatCompactionInfo({ ...VIEW, percent: 33.4, elapsedMs: 1_234_567 }), `33% summarized${DOT}1234.6s`);
+	assert.equal(formatCompactionInfo({ ...VIEW, percent: 140 }), `100% summarized${DOT}16.3s`, "clamped high");
+	assert.equal(formatCompactionInfo({ ...VIEW, percent: -3, elapsedMs: -5 }), `0% summarized${DOT}0.0s`, "clamped low");
+});
+
+test("formatCompactionTokens uses the context label's number style", () => {
+	assert.equal(formatCompactionTokens(VIEW), "86K/131K (66%)");
+	assert.equal(
+		formatCompactionTokens({ ...VIEW, tokensBefore: 1_250_000, contextWindow: 2_000_000 }),
+		"1.3M/2.0M (63%)",
+	);
+	assert.equal(formatCompactionTokens({ ...VIEW, contextWindow: 0 }), "86K/?", "no share of an unknown window");
+	assert.equal(formatCompactionTokens({ ...VIEW, tokensBefore: 200_000 }), "200K/131K (100%)", "clamped");
+});
+
+test("compaction segments are invisible without a hosted compaction", () => {
+	assert.equal(SEGMENTS.compaction_info.render(ctxWith(undefined)).visible, false);
+	assert.equal(SEGMENTS.compaction_graph.render(ctxWith(undefined)).visible, false);
+});
+
+test("compaction_info renders the figures in dim text", () => {
+	assert.deepEqual(SEGMENTS.compaction_info.render(ctxWith(VIEW)), {
+		content: theme.fg("dim", formatCompactionInfo(VIEW)),
+		visible: true,
+	});
+});
+
+test("compaction_graph passes the bar through verbatim and honors the graph toggles", () => {
+	const both = SEGMENTS.compaction_graph.render(ctxWith(VIEW));
+	assert.ok(both.visible && both.content.startsWith(BAR), "bar first, untouched");
+	assert.equal(stripAnsi(both.content), `${"▋".repeat(7)}${"░".repeat(13)} 86K/131K (66%)`);
+
+	const barOnly = ctxWith(VIEW);
+	barOnly.options = resolveEffectiveSettings({ segments: { contextStats: false } }).segmentOptions;
+	assert.equal(SEGMENTS.compaction_graph.render(barOnly).content, BAR);
+
+	const statsOnly = ctxWith(VIEW);
+	statsOnly.options = resolveEffectiveSettings({ segments: { contextBar: false } }).segmentOptions;
+	assert.equal(stripAnsi(SEGMENTS.compaction_graph.render(statsOnly).content), "86K/131K (66%)");
+
+	const neither = ctxWith(VIEW);
+	neither.options = resolveEffectiveSettings({ segments: { contextBar: false, contextStats: false } }).segmentOptions;
+	assert.equal(SEGMENTS.compaction_graph.render(neither).visible, false);
+});
+
+test("the bottom bar swaps pi's stats and the context graph for the compaction while hosted", () => {
+	const groups = (compacting: boolean) => ({
+		left: EFFECTIVE.bottomLeftSegments,
+		right: bottomRightSegments(EFFECTIVE, compacting),
+	});
+	const idle = stripAnsi(buildStatusLine(100, ctxWith(undefined), EFFECTIVE, noGap, groups(false)));
+	assert.ok(idle.includes("↑ 142K"), "pi stats show while idle");
+	assert.ok(idle.includes("41.0%/131K"), "the context label shows while idle");
+
+	const bar = buildStatusLine(100, ctxWith(VIEW), EFFECTIVE, noGap, groups(true));
+	const plain = stripAnsi(bar);
+	assert.equal(visibleWidth(bar), 100);
+	assert.ok(plain.includes(`47% summarized${DOT}16.3s`), "the compaction figures replace pi stats");
+	assert.ok(plain.includes(`${"▋".repeat(7)}${"░".repeat(13)} 86K/131K (66%)`), "the compaction bar replaces the graph");
+	assert.ok(!plain.includes("↑ 142K"), "pi stats are gone");
+	assert.ok(!plain.includes("41.0%"), "the context label is gone");
+	assert.ok(bar.includes(BAR), "the bar's own colors survive the layout");
+});
+
+test("onFit reports which segments actually survived overflow trimming, not just what was requested", () => {
+	const groups = { left: [], right: bottomRightSegments(EFFECTIVE, true) };
+	let wide: { left: readonly string[]; right: readonly string[] } | undefined;
+	buildStatusLine(100, ctxWith(VIEW), EFFECTIVE, noGap, groups, undefined, {
+		onFit: fit => {
+			wide = fit;
+		},
+	});
+	assert.deepEqual(wide?.right, ["compaction_info", "compaction_graph"], "both stand-ins fit at full width");
+
+	let narrow: { left: readonly string[]; right: readonly string[] } | undefined;
+	buildStatusLine(20, ctxWith(VIEW), EFFECTIVE, noGap, groups, undefined, {
+		onFit: fit => {
+			narrow = fit;
+		},
+	});
+	assert.ok(
+		!narrow?.right.includes("compaction_info") && !narrow?.right.includes("compaction_graph"),
+		"too narrow for either stand-in, so a caller checking onFit knows not to claim it hosts the progress",
+	);
+});