@underactive/pi-topping-statusline 0.2.5 → 0.2.7

package/src/context.ts

@@ -77,8 +77,7 @@ interface ContextEstimate {
 /**
  * pi's own estimate of the context after a compaction: the summary plus the
  * kept and later messages, sized by its per-message estimator. This is the
- * figure pi hands compaction callers as estimatedTokensAfter, so it agrees with
- * what pi-topping-compact reports in its result.
+ * figure pi hands compaction callers as estimatedTokensAfter.
  */
 export function estimateCompactedContextTokens(sessionManager: ExtensionContext["sessionManager"]): number {
 	let tokens = 0;
@@ -88,7 +87,8 @@ export function estimateCompactedContextTokens(sessionManager: ExtensionContext[
 	return tokens;
 }
 
-function parseGitStatus(porcelain: string): GitStatusCounts {
+/** Count staged, unstaged, and untracked paths in `git status --porcelain` output. */
+export function parseGitStatusCounts(porcelain: string): GitStatusCounts {
 	let staged = 0;
 	let unstaged = 0;
 	let untracked = 0;
@@ -134,7 +134,7 @@ export class SegmentContextBuilder {
 
 	#feedData: Record<string, unknown> = emptyFeedData();
 	#feedsScannedAt = 0;
-	#feedsScannedRef: readonly string[] | undefined;
+	#feedsScannedKey: string | undefined;
 	#runStartedAt = 0;
 	#feedTracking = new Map<string, FeedTracking>();
 	#feedTimer: ReturnType<typeof setTimeout> | undefined;
@@ -167,7 +167,7 @@ export class SegmentContextBuilder {
 		this.#runStartedAt = Date.now();
 		this.#feedData = emptyFeedData();
 		this.#feedsScannedAt = 0;
-		this.#feedsScannedRef = undefined;
+		this.#feedsScannedKey = undefined;
 		this.#clearFeedLifecycle();
 		this.#contextEstimate = undefined;
 		if (this.#repoCwd !== ctx.cwd) {
@@ -310,7 +310,7 @@ export class SegmentContextBuilder {
 			const out = await this.#exec("git", ["status", "--porcelain"], cwd);
 			if (this.#repoCwd !== cwd) return;
 			this.#gitStatusFetchedAt = Date.now();
-			const next = out === undefined ? null : parseGitStatus(out);
+			const next = out === undefined ? null : parseGitStatusCounts(out);
 			const changed =
 				next?.staged !== this.#gitStatus?.staged ||
 				next?.unstaged !== this.#gitStatus?.unstaged ||
@@ -495,8 +495,9 @@ export class SegmentContextBuilder {
 		let feedDisplayState: Record<string, FeedDisplayState> | undefined;
 		if (include.feeds.length > 0) {
 			// Editing the subscription list mid-session must not wait out the TTL.
-			if (include.feeds !== this.#feedsScannedRef || now - this.#feedsScannedAt > FEED_TTL_MS) {
-				this.#feedsScannedRef = include.feeds;
+			const feedsKey = include.feeds.join("\0");
+			if (feedsKey !== this.#feedsScannedKey || now - this.#feedsScannedAt > FEED_TTL_MS) {
+				this.#feedsScannedKey = feedsKey;
 				this.#refreshFeeds(include.feeds, now);
 			}
 			feedDisplayState = this.#syncFeedTracking(options.feeds, now);

package/src/nvidia-green.ts

@@ -1,8 +1,8 @@
 /** 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";
+import { wrapDeg, type BorderColorizer } from "./rainbow.js";
+import { detectColorMode, mixRgb, parseHex, rgbToFgAnsi, type ColorMode } from "./theme.js";
 
-export const SWITCHYARD_PROVIDER = "switchyard";
+const SWITCHYARD_PROVIDER = "switchyard";
 export const NVIDIA_GREEN_HEX = "#84c51a";
 export const NVIDIA_GREEN_DARK_HEX = "#0b3d20";
 const GREEN_SHADE_COUNT = 256;
@@ -27,12 +27,8 @@ function buildAnsiByShade(mode: ColorMode): string[] {
 	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));
+		const rgb = mixRgb(dark, bright, progress);
+		ansiByShade.push(rgbToFgAnsi(...rgb, mode));
 	}
 
 	ansiByShadeByMode.set(mode, ansiByShade);

package/src/rainbow.ts

@@ -12,7 +12,7 @@
  * (renderBoxed in index.ts) or construct a fresh instance with a phase
  * derived from elapsed time (the settings preview).
  */
-import { detectColorMode, hexToFgAnsi, type ColorMode } from "./theme.js";
+import { detectColorMode, rgbToFgAnsi, type ColorMode } from "./theme.js";
 
 /** Frame cadence of the sweep (also the settings-preview refresh delay). */
 export const RAINBOW_FRAME_MS = 50;
@@ -23,6 +23,7 @@ export const RAINBOW_DEG_PER_FRAME = (360 * RAINBOW_FRAME_MS) / RAINBOW_CYCLE_MS
 
 const SATURATION = 1;
 const LIGHTNESS = 0.62;
+const ansiByHueByMode = new Map<ColorMode, string[]>();
 
 /** Normalize a degree value into the [0, 360) range. */
 export const wrapDeg = (deg: number): number => ((deg % 360) + 360) % 360;
@@ -80,8 +81,6 @@ export interface BorderColorizer {
  */
 export class RainbowBorder implements BorderColorizer {
 	#phaseDeg: number;
-	#mode: ColorMode | undefined;
-	readonly #ansiByHue: string[] = [];
 
 	constructor(phaseDeg = 0) {
 		this.#phaseDeg = wrapDeg(phaseDeg);
@@ -99,17 +98,17 @@ export class RainbowBorder implements BorderColorizer {
 
 	prefix(perimeterPos: number, perimeter: number): string {
 		const mode = detectColorMode();
-		if (mode !== this.#mode) {
-			this.#mode = mode;
-			this.#ansiByHue.length = 0;
+		let ansiByHue = ansiByHueByMode.get(mode);
+		if (ansiByHue === undefined) {
+			ansiByHue = [];
+			ansiByHueByMode.set(mode, ansiByHue);
 		}
 		const hue = (this.#phaseDeg + (360 * perimeterPos) / perimeter) % 360;
 		const bucket = Math.round(hue) % 360;
-		let ansi = this.#ansiByHue[bucket];
+		let ansi = ansiByHue[bucket];
 		if (ansi === undefined) {
-			const hex = rgbToHex(hslToRgb(bucket, SATURATION, LIGHTNESS));
-			ansi = hexToFgAnsi(hex, mode);
-			this.#ansiByHue[bucket] = ansi;
+			ansi = rgbToFgAnsi(...hslToRgb(bucket, SATURATION, LIGHTNESS), mode);
+			ansiByHue[bucket] = ansi;
 		}
 		return ansi;
 	}

package/src/segments.ts

@@ -355,7 +355,10 @@ const contextGraphSegment: StatusLineSegment = {
 
 const clampPercent = (percent: number): number => Math.round(Math.min(100, Math.max(0, percent)));
 
-/** "57% summarized · 16.3s": how much of the context has been summarized so far, and the time taken. */
+/**
+ * "47% summarized · 16.3s": the estimated share summarized so far (time-based until pi completes),
+ * and the time taken.
+ */
 export function formatCompactionInfo(view: CompactionProgressView): string {
 	const elapsed = `${(Math.max(0, view.elapsedMs) / 1000).toFixed(1)}s`;
 	return `${clampPercent(view.percent)}% summarized${theme.sep.dot}${elapsed}`;
@@ -373,7 +376,7 @@ export function formatCompactionTokens(view: CompactionProgressView): string {
 	return `${before}/${formatNumber(view.contextWindow)} (${usage}%)`;
 }
 
-/** pi-topping-compact's figures, standing in for pi's stats while its progress is hosted. */
+/** The compaction's figures, standing in for pi's stats while its progress is hosted. */
 const compactionInfoSegment: StatusLineSegment = {
 	id: "compaction_info",
 	render(ctx) {
@@ -384,9 +387,9 @@ const compactionInfoSegment: StatusLineSegment = {
 };
 
 /**
- * pi-topping-compact's bar, standing in for the context graph while its progress
- * is hosted, under the graph's own bar and stats toggles. The bar arrives
- * pre-rendered with fg-only resets, so it is passed through verbatim.
+ * The compaction bar, standing in for the context graph while its progress is
+ * hosted, under the graph's own bar and stats toggles. The bar arrives
+ * pre-rendered with fg/attribute-only resets, so it is passed through verbatim.
  */
 const compactionGraphSegment: StatusLineSegment = {
 	id: "compaction_graph",

package/src/settings-menu.ts

@@ -5,7 +5,7 @@
  */
 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 { compactionPreviewView } 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";
@@ -336,12 +336,11 @@ class StatusLinePreview {
 				{ 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.
+			// Focusing the compaction row demos the bottom bar hosting a compaction's progress, while the setting is on.
 			const progressDemo = activeItemId === "embedCompactionProgress" && effective.embedCompactionProgress;
 			const bottom = buildStatusLine(
 				barWidth,
-				progressDemo ? { ...ctx, compaction: COMPACTION_FIT_PROBE } : ctx,
+				progressDemo ? { ...ctx, compaction: compactionPreviewView() } : ctx,
 				effective,
 				painters.gapColor,
 				{

package/src/settings.ts

@@ -195,8 +195,8 @@ export const COMPACTION_STAND_INS: Partial<Record<StatusLineSegmentId, StatusLin
 };
 
 /**
- * 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.
+ * The bottom-right group for one frame. While a compaction 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;

package/src/tests/compaction-bar.test.ts

@@ -0,0 +1,67 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { resetCapabilitiesCache, setCapabilities, setCapabilityOverrides } from "@earendil-works/pi-tui";
+import { renderCompactionBar } from "../compaction-bar.ts";
+
+const MODE = { mode: "truecolor" as const };
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+const stripAnsi = (text: string) => text.replace(ANSI_RE, "");
+
+function filledColors(bar: string): Array<[number, number, number]> {
+	const colors: Array<[number, number, number]> = [];
+	for (const match of bar.matchAll(/\x1b\[38;2;(\d+);(\d+);(\d+)m▋/g)) {
+		colors.push([Number(match[1]), Number(match[2]), Number(match[3])]);
+	}
+	return colors;
+}
+
+function brightestCell(colors: Array<[number, number, number]>): number {
+	let brightest = 0;
+	for (let i = 1; i < colors.length; i++) {
+		if ((colors[i]?.[1] ?? 0) > (colors[brightest]?.[1] ?? 0)) brightest = i;
+	}
+	return brightest;
+}
+
+test("bar has the expected glyphs, green trough, and foreground-only resets", () => {
+	const bar = renderCompactionBar(50, MODE);
+	assert.equal(stripAnsi(bar), `${"▋".repeat(10)}${"░".repeat(10)}`);
+	assert.match(bar, /\x1b\[38;2;38;100;70m/);
+	assert.match(bar, /\x1b\[2m/);
+	assert.doesNotMatch(bar, /\x1b\[0m/);
+});
+
+test("the phosphor comet moves from right to left", () => {
+	const right = filledColors(renderCompactionBar(100, { ...MODE, shimmerElapsedMs: 500 }));
+	const left = filledColors(renderCompactionBar(100, { ...MODE, shimmerElapsedMs: 1_500 }));
+	assert.equal(right.length, 20);
+	assert.equal(left.length, 20);
+	assert.notDeepEqual(right, left);
+	assert.ok(brightestCell(right) > brightestCell(left));
+});
+
+test("bar supports 256-color escapes", () => {
+	const bar = renderCompactionBar(100, { mode: "256color", shimmerElapsedMs: 500 });
+	assert.match(bar, /\x1b\[38;5;\d+m/);
+	assert.doesNotMatch(bar, /\x1b\[38;2;/);
+	assert.doesNotMatch(bar, /\x1b\[0m/);
+});
+
+test("bar clamps NaN and out-of-range percentages", () => {
+	const empty = renderCompactionBar(0, MODE);
+	const full = renderCompactionBar(100, MODE);
+	assert.equal(renderCompactionBar(Number.NaN, MODE), empty);
+	assert.equal(renderCompactionBar(-10, MODE), empty);
+	assert.equal(renderCompactionBar(150, MODE), full);
+});
+
+test("default bar color follows terminal capability detection", () => {
+	try {
+		setCapabilities({ images: null, trueColor: true, hyperlinks: false });
+		resetCapabilitiesCache();
+		assert.match(renderCompactionBar(50), /\x1b\[38;2;/);
+	} finally {
+		setCapabilityOverrides({});
+		resetCapabilitiesCache();
+	}
+});

package/src/tests/compaction-embed.test.ts

@@ -1,12 +1,12 @@
 /**
- * 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.
+ * Contracts for hosting compaction progress: the preconditions for hosting it,
+ * the bottom-right stand-ins, the two segments that draw the bar and figures,
+ * and the preview view.
  */
 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 { compactionPreviewView, hostsCompactionProgress } from "../compaction-embed.ts";
 import { stripAnsi } from "../footer.ts";
 import { buildStatusLine } from "../layout.ts";
 import { formatCompactionInfo, formatCompactionTokens, SEGMENTS } from "../segments.ts";
@@ -47,23 +47,13 @@ function ctxWith(compaction: CompactionProgressView | undefined): SegmentContext
 	};
 }
 
-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("the settings preview uses representative compaction progress", () => {
+	const preview = compactionPreviewView();
+	assert.equal(stripAnsi(preview.bar), "▋".repeat(7) + "░".repeat(13));
+	assert.equal(preview.percent, 47);
+	assert.equal(preview.tokensBefore, 86_000);
+	assert.equal(preview.contextWindow, 131_072);
+	assert.equal(preview.elapsedMs, 16_300);
 });
 
 test("embedCompactionProgress resolves on by default and off when set", () => {

package/src/tests/compaction-progress.test.ts

@@ -0,0 +1,183 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { CompactionMonitor, estimateCompactionPercent } from "../compaction-progress.ts";
+
+const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
+type Handler = (payload?: unknown, ctx?: unknown) => void;
+
+function fakePi(): { pi: ExtensionAPI; emit: (event: string, payload?: unknown, ctx?: unknown) => void } {
+	const handlers = new Map<string, Handler>();
+	const pi = { on: (event: string, handler: Handler) => handlers.set(event, handler) } as unknown as ExtensionAPI;
+	return { pi, emit: (event, payload, ctx) => handlers.get(event)?.(payload, ctx) };
+}
+
+const ctx = {
+	getContextUsage: () => ({ contextWindow: 131_072, tokens: null, percent: null }),
+	model: { contextWindow: 200_000 },
+};
+const beforeCompact = (tokensBefore = 86_000) => ({ preparation: { tokensBefore } });
+const filledCells = (bar: string) => (bar.match(/▋/g) ?? []).length;
+const stripAnsi = (bar: string) => bar.replace(/\x1b\[[0-9;]*m/g, "");
+
+test("estimateCompactionPercent follows the bounded time curve", () => {
+	assert.equal(estimateCompactionPercent(0), 10);
+	const one = estimateCompactionPercent(1_000);
+	const ten = estimateCompactionPercent(10_000);
+	const sixty = estimateCompactionPercent(60_000);
+	assert.ok(one > 10 && ten > one && sixty > ten);
+	assert.ok(sixty <= 86);
+	assert.equal(estimateCompactionPercent(Number.NaN), 10);
+	assert.equal(estimateCompactionPercent(-5), 10);
+	assert.equal(estimateCompactionPercent(1_000_000), 86);
+});
+
+test("monitor tracks starts, elapsed time and context usage", () => {
+	const { pi, emit } = fakePi();
+	let now = 1_000;
+	const monitor = new CompactionMonitor(() => {}, { now: () => now });
+	monitor.attach(pi);
+	assert.equal(monitor.view(), undefined);
+	emit("session_before_compact", beforeCompact(), ctx);
+	assert.equal(monitor.view(), undefined, "disabled monitor ignores events");
+	monitor.enable();
+	emit("session_before_compact", beforeCompact(), ctx);
+	now += 1_000;
+	const view = monitor.view();
+	assert.ok(view);
+	assert.equal(view.tokensBefore, 86_000);
+	assert.equal(view.contextWindow, 131_072);
+	assert.equal(view.elapsedMs, 1_000);
+	monitor.disable();
+});
+
+test("context window falls back to the model and progress advances with elapsed time", () => {
+	const { pi, emit } = fakePi();
+	let now = 10_000;
+	const monitor = new CompactionMonitor(() => {}, { now: () => now });
+	monitor.attach(pi);
+	monitor.enable();
+	emit("session_before_compact", beforeCompact(), { getContextUsage: () => undefined, model: { contextWindow: 200_000 } });
+	const first = monitor.view();
+	assert.ok(first);
+	assert.equal(first.contextWindow, 200_000);
+	now += 15_000;
+	const later = monitor.view();
+	assert.ok(later);
+	assert.ok(later.percent > first.percent);
+	monitor.disable();
+});
+
+test("remaining filled cells decrease with time and unknown usage is trough only", () => {
+	const { pi, emit } = fakePi();
+	let now = 0;
+	const monitor = new CompactionMonitor(() => {}, { now: () => now });
+	monitor.attach(pi);
+	monitor.enable();
+	emit("session_before_compact", beforeCompact(), ctx);
+	const first = monitor.view();
+	assert.ok(first);
+	now = 60_000;
+	const later = monitor.view();
+	assert.ok(later);
+	assert.ok(filledCells(later.bar) < filledCells(first.bar));
+	monitor.disable();
+
+	const unknown = fakePi();
+	const emptyMonitor = new CompactionMonitor(() => {}, { now: () => 0 });
+	emptyMonitor.attach(unknown.pi);
+	emptyMonitor.enable();
+	unknown.emit("session_before_compact", beforeCompact(), { getContextUsage: () => ({ contextWindow: 0 }), model: { contextWindow: 0 } });
+	assert.equal(stripAnsi(emptyMonitor.view()!.bar), "░".repeat(20));
+	emptyMonitor.disable();
+});
+
+test("completion freezes a drained bar during the hold and then releases the run", async () => {
+	const { pi, emit } = fakePi();
+	let now = 100;
+	let renders = 0;
+	const monitor = new CompactionMonitor(() => renders++, { now: () => now, holdMs: 20 });
+	monitor.attach(pi);
+	monitor.enable();
+	emit("session_before_compact", beforeCompact(), ctx);
+	now = 500;
+	emit("session_compact");
+	const completed = monitor.view();
+	assert.ok(completed);
+	assert.equal(completed.percent, 100);
+	assert.equal(stripAnsi(completed.bar), "░".repeat(20));
+	now = 5_000;
+	assert.equal(monitor.view()?.elapsedMs, completed.elapsedMs);
+	await sleep(40);
+	assert.equal(monitor.view(), undefined);
+	assert.ok(renders >= 3, "completion and hold end both request renders");
+	monitor.disable();
+});
+
+test("failure ends at once, including a pending hold, and is a no-op without a run", () => {
+	const { pi, emit } = fakePi();
+	let renders = 0;
+	const monitor = new CompactionMonitor(() => renders++, { now: () => 0, holdMs: 10_000 });
+	monitor.attach(pi);
+	monitor.enable();
+	emit("session_compact_failed");
+	assert.equal(renders, 0);
+	emit("session_before_compact", beforeCompact(), ctx);
+	emit("session_compact");
+	emit("session_compact_failed");
+	assert.equal(monitor.view(), undefined);
+	const afterFailure = renders;
+	emit("session_compact_failed");
+	assert.equal(renders, afterFailure);
+	monitor.disable();
+});
+
+test("agent_start guards an active run but leaves a completion hold intact", () => {
+	const { pi, emit } = fakePi();
+	const monitor = new CompactionMonitor(() => {}, { now: () => 0, holdMs: 10_000 });
+	monitor.attach(pi);
+	monitor.enable();
+	emit("session_before_compact", beforeCompact(), ctx);
+	emit("agent_start");
+	assert.equal(monitor.view(), undefined);
+	emit("session_before_compact", beforeCompact(), ctx);
+	emit("session_compact");
+	emit("agent_start");
+	assert.equal(monitor.view()?.percent, 100);
+	monitor.disable();
+});
+
+test("a new compaction replaces the previous run", () => {
+	const { pi, emit } = fakePi();
+	let now = 1_000;
+	const monitor = new CompactionMonitor(() => {}, { now: () => now });
+	monitor.attach(pi);
+	monitor.enable();
+	emit("session_before_compact", beforeCompact(), ctx);
+	now += 1_000;
+	emit("session_before_compact", beforeCompact(70_000), ctx);
+	assert.equal(monitor.view()?.elapsedMs, 0);
+	assert.equal(monitor.view()?.tokensBefore, 70_000);
+	monitor.disable();
+});
+
+test("disable ends the run and stops repeated ticks", async () => {
+	const { pi, emit } = fakePi();
+	let renders = 0;
+	const monitor = new CompactionMonitor(() => renders++);
+	monitor.attach(pi);
+	monitor.enable();
+	emit("session_before_compact", beforeCompact(), ctx);
+	await sleep(250);
+	assert.ok(renders >= 3);
+	emit("session_compact_failed");
+	const endedRenders = renders;
+	await sleep(150);
+	assert.equal(renders, endedRenders);
+	emit("session_before_compact", beforeCompact(), ctx);
+	monitor.disable();
+	const disabledRenders = renders;
+	await sleep(150);
+	assert.equal(renders, disabledRenders);
+	assert.equal(monitor.view(), undefined);
+});

package/src/tests/context-estimate.test.ts

@@ -2,8 +2,7 @@
  * The context graph between a compaction and the next response. pi reports
  * usage as unknown for that stretch; the builder fills it with pi's own
  * estimate of the compacted context, the figure pi hands compaction callers as
- * estimatedTokensAfter, so the graph never vanishes and agrees with the result
- * pi-topping-compact reports.
+ * estimatedTokensAfter.
  */
 import assert from "node:assert/strict";
 import test from "node:test";

package/src/tests/feeds.test.ts

@@ -354,7 +354,7 @@ test("renders share one scan per TTL, and attach forces a fresh one", async () =
 	await sleep(3);
 	entries.push(feedEntry({ savedUsd: 1.5 }));
 
-	for (let i = 0; i < 50; i++) builder.build(80, OPTIONS, INCLUDE, undefined);
+	for (let i = 0; i < 50; i++) builder.build(80, OPTIONS, { ...INCLUDE, feeds: [...INCLUDE.feeds] }, undefined);
 	assert.equal(scans, 1, `expected 1 scan across 50 renders, got ${scans}`);
 
 	builder.attach(fakeCtx(entries, () => scans++));

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

@@ -0,0 +1,62 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { SegmentContextBuilder, parseGitStatusCounts } from "../context.ts";
+import { stripAnsi } from "../footer.ts";
+import { SEGMENTS } from "../segments.ts";
+import { resolveEffectiveSettings } from "../settings.ts";
+
+const OPTIONS = resolveEffectiveSettings({}).segmentOptions;
+const GIT_INCLUDE = { git: true, pr: false, piStats: false, tokenRate: false, feeds: [] };
+const NO_GIT_INCLUDE = { ...GIT_INCLUDE, git: false };
+const CWD = "/repo";
+
+const flush = () => new Promise<void>(resolve => setImmediate(resolve));
+
+function fakeCtx(): ExtensionContext {
+	return {
+		cwd: CWD,
+		getContextUsage: () => undefined,
+		sessionManager: {
+			getSessionName: () => undefined,
+		},
+	} as unknown as ExtensionContext;
+}
+
+test("parseGitStatusCounts separates staged, unstaged, and untracked paths", () => {
+	assert.deepEqual(
+		parseGitStatusCounts(" M unstaged.ts\nM  staged.ts\nMM both.ts\nR  renamed.ts\n?? new.ts\n"),
+		{ staged: 3, unstaged: 2, untracked: 1 },
+	);
+});
+
+test("the context builder supplies changed-file counts to the git segment", async () => {
+	const commands: string[][] = [];
+	const pi = {
+		exec: async (_cmd: string, args: string[]) => {
+			commands.push(args);
+			if (args[0] === "rev-parse") return { code: 0, stdout: "/repo/.git\n/repo/.git\n/repo\n" };
+			if (args[0] === "branch") return { code: 0, stdout: "main\n" };
+			if (args[0] === "status") return { code: 0, stdout: " M unstaged.ts\nM  staged.ts\n?? new.ts\n" };
+			return { code: 1, stdout: "" };
+		},
+		getThinkingLevel: () => "off",
+	} as unknown as ExtensionAPI;
+	const builder = new SegmentContextBuilder(pi);
+	builder.attach(fakeCtx());
+	await flush();
+
+	assert.equal(builder.build(80, OPTIONS, NO_GIT_INCLUDE, undefined).git.status, null);
+	builder.build(80, OPTIONS, GIT_INCLUDE, undefined);
+	await flush();
+
+	const snapshot = builder.build(80, OPTIONS, GIT_INCLUDE, undefined);
+	assert.deepEqual(snapshot.git.status, {
+		staged: 1,
+		unstaged: 1,
+		untracked: 1,
+	});
+	assert.equal(stripAnsi(SEGMENTS.git.render(snapshot).content).includes("main *1 +1 ?1"), true);
+	assert.ok(commands.some(args => args.join(" ") === "status --porcelain"));
+	builder.dispose();
+});

package/src/theme.ts

@@ -284,7 +284,20 @@ function rgbTo256(r: number, g: number, b: number): number {
 	return 16 + 36 * scale(r) + 6 * scale(g) + scale(b);
 }
 
-function rgbToFgAnsi(r: number, g: number, b: number, mode: ColorMode): string {
+export function mixRgb(
+	from: readonly [number, number, number],
+	to: readonly [number, number, number],
+	amount: number,
+): [number, number, number] {
+	const clamped = Math.min(1, Math.max(0, amount));
+	return [
+		Math.round(from[0] + (to[0] - from[0]) * clamped),
+		Math.round(from[1] + (to[1] - from[1]) * clamped),
+		Math.round(from[2] + (to[2] - from[2]) * clamped),
+	];
+}
+
+export function rgbToFgAnsi(r: number, g: number, b: number, mode: ColorMode): string {
 	return mode === "truecolor" ? `\x1b[38;2;${r};${g};${b}m` : `\x1b[38;5;${rgbTo256(r, g, b)}m`;
 }
 

package/src/types.ts

@@ -82,7 +82,7 @@ export interface StatusLineSettings {
 	nvidiaGreenAnimation?: boolean;
 	/** Render pi's status spinners in the top bar instead of their own row. */
 	embedWorkingStatus?: boolean;
-	/** Host pi-topping-compact's compaction progress in the bottom bar while a compaction runs. */
+	/** Host compaction progress in the bottom bar while pi compacts. */
 	embedCompactionProgress?: boolean;
 }
 
@@ -159,8 +159,8 @@ export interface SegmentContext {
 	 */
 	workingStatus?: string;
 	/**
-	 * pi-topping-compact's live compaction progress, while its bar and figures
-	 * stand in for the context graph and pi's stats in the bottom-right group.
+	 * The live compaction progress, while its bar and figures stand in for the
+	 * context graph and pi's stats in the bottom-right group.
 	 */
 	compaction?: CompactionProgressView;
 	/** Live tok/s display state, when this frame needs it. */
@@ -179,14 +179,17 @@ export interface SegmentContext {
 	feedDisplayState?: Record<string, FeedDisplayState>;
 }
 
-/** One broadcast from pi-topping-compact: its bar, pre-rendered, plus the snapshot it was drawn from. */
+/** One frame of a compaction from CompactionMonitor, from its start through the completion hold. */
 export interface CompactionProgressView {
-	/** The 20-cell bar, pre-rendered and pre-colored by pi-topping-compact with fg-only resets. */
+	/** The 20-cell bar, pre-rendered by compaction-bar.ts with fg/attribute-only resets (39/22, never 0). Its fill is the context share not yet summarized, so it drains as `percent` rises. */
 	bar: string;
-	/** How much of the context has been summarized so far, 0..100. */
+	/** How far the compaction has progressed, 0..100 (a time-based estimate until pi completes). */
 	percent: number;
+	/** Context tokens being compacted, from pi's compaction preparation. */
 	tokensBefore: number;
+	/** The model's context window; 0 when unknown. */
 	contextWindow: number;
+	/** Time since the compaction started, frozen at completion. */
 	elapsedMs: number;
 }