@underactive/pi-topping-statusline 0.2.1 → 0.2.3

package/src/settings.ts

@@ -96,6 +96,7 @@ function loadSettings(): StatusLineSettings {
 		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.
@@ -161,6 +162,7 @@ export function resolveEffectiveSettings(settings: StatusLineSettings): Effectiv
 		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 },
@@ -171,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 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.
+ * 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/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",
+	);
+});

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

@@ -0,0 +1,207 @@
+/**
+ * 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.
+ */
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+	buildSessionContext,
+	estimateTokens,
+	type ExtensionAPI,
+	type ExtensionContext,
+	type SessionEntry,
+} from "@earendil-works/pi-coding-agent";
+import { SegmentContextBuilder, estimateCompactedContextTokens } from "../context.ts";
+import { stripAnsi } from "../footer.ts";
+import { SEGMENTS } from "../segments.ts";
+import { resolveEffectiveSettings } from "../settings.ts";
+import type { SegmentContext } from "../types.ts";
+
+const WINDOW = 131_072;
+const OPTIONS = resolveEffectiveSettings({}).segmentOptions;
+const INCLUDE = { git: false, pr: false, piStats: false, tokenRate: false, feeds: [] };
+/** Outside any repo, so the builder's git probes stay inert. */
+const CWD = "/tmp/pi-topping-statusline-tests";
+const fakePi = { exec: async () => undefined, getThinkingLevel: () => "off" } as unknown as ExtensionAPI;
+
+type Usage = { tokens: number | null; contextWindow: number; percent: number | null } | undefined;
+const UNKNOWN: Usage = { tokens: null, contextWindow: WINDOW, percent: null };
+
+const EPOCH = 1_700_000_000_000;
+const at = (i: number) => new Date(EPOCH + i * 1000).toISOString();
+const user = (id: string, parentId: string | null, text: string, i: number): SessionEntry =>
+	({
+		type: "message",
+		id,
+		parentId,
+		timestamp: at(i),
+		message: { role: "user", content: text, timestamp: EPOCH + i * 1000 },
+	}) as unknown as SessionEntry;
+const assistant = (id: string, parentId: string, text: string, i: number): SessionEntry =>
+	({
+		type: "message",
+		id,
+		parentId,
+		timestamp: at(i),
+		message: {
+			role: "assistant",
+			content: [{ type: "text", text }],
+			api: "anthropic-messages",
+			provider: "anthropic",
+			model: "m",
+			usage: { input: 80_000, output: 500, cacheRead: 0, cacheWrite: 0, totalTokens: 80_500 },
+			stopReason: "stop",
+			timestamp: EPOCH + i * 1000,
+		},
+	}) as unknown as SessionEntry;
+
+/** A branch just after compaction: the first exchange summarized, the second kept, the leaf on the compaction. */
+function compactedBranch(): SessionEntry[] {
+	return [
+		user("e1", null, "Please review the repository layout.", 1),
+		assistant("e2", "e1", "x".repeat(60_000), 2),
+		user("e3", "e2", "Now write the tests.", 3),
+		assistant("e4", "e3", "Done, all pass.", 4),
+		{
+			type: "compaction",
+			id: "e5",
+			parentId: "e4",
+			timestamp: at(5),
+			summary: "The layout was reviewed. ".repeat(80),
+			firstKeptEntryId: "e3",
+			tokensBefore: 86_000,
+		} as unknown as SessionEntry,
+	];
+}
+
+function fakeCtx(branch: SessionEntry[], usage: Usage, counters = { branch: 0 }): ExtensionContext {
+	return {
+		cwd: CWD,
+		model: { id: "m", provider: "anthropic", name: "M", contextWindow: WINDOW },
+		getContextUsage: () => usage,
+		sessionManager: {
+			getSessionId: () => "session-1",
+			getSessionName: () => undefined,
+			getLeafId: () => branch.at(-1)?.id ?? null,
+			getBranch: () => {
+				counters.branch++;
+				return [...branch];
+			},
+			getEntries: () => branch,
+		},
+	} as unknown as ExtensionContext;
+}
+
+/** What pi itself computes as estimatedTokensAfter for this branch. */
+function piEstimate(branch: SessionEntry[]): number {
+	let tokens = 0;
+	for (const message of buildSessionContext(branch, branch.at(-1)?.id).messages) tokens += estimateTokens(message);
+	return tokens;
+}
+
+function segmentCtx(overrides: Partial<SegmentContext>): SegmentContext {
+	return {
+		options: OPTIONS,
+		model: undefined,
+		thinkingLevel: "off",
+		cwd: CWD,
+		sessionName: undefined,
+		contextPercent: null,
+		contextTokens: 0,
+		contextWindow: WINDOW,
+		git: { branch: null, status: null, pr: null },
+		worktree: null,
+		scrollHint: undefined,
+		piStats: undefined,
+		tokenRate: undefined,
+		feedData: undefined,
+		...overrides,
+	};
+}
+
+test("after a compaction the builder sizes the context as pi does, leaving out what was summarized", () => {
+	const branch = compactedBranch();
+	const builder = new SegmentContextBuilder(fakePi);
+	builder.attach(fakeCtx(branch, UNKNOWN));
+	const ctx = builder.build(80, OPTIONS, INCLUDE, undefined);
+
+	const expected = piEstimate(branch);
+	assert.equal(ctx.contextTokens, expected);
+	assert.equal(ctx.contextPercent, (expected / WINDOW) * 100);
+	assert.equal(ctx.contextEstimated, true);
+	assert.equal(ctx.contextWindow, WINDOW);
+	assert.ok(expected > 0);
+	const summarized = branch[1] as SessionEntry & { message: Parameters<typeof estimateTokens>[0] };
+	assert.ok(expected < estimateTokens(summarized.message), "the summarized reply no longer counts");
+});
+
+test("the estimate is cached per leaf and rebuilt when the branch grows", () => {
+	const branch = compactedBranch();
+	const counters = { branch: 0 };
+	const builder = new SegmentContextBuilder(fakePi);
+	builder.attach(fakeCtx(branch, UNKNOWN, counters));
+
+	const first = builder.build(80, OPTIONS, INCLUDE, undefined);
+	builder.build(80, OPTIONS, INCLUDE, undefined);
+	assert.equal(counters.branch, 1, "the same leaf reuses the estimate");
+
+	const followUp = user("e6", "e5", "And now the docs, please.", 6);
+	branch.push(followUp);
+	const grown = builder.build(80, OPTIONS, INCLUDE, undefined);
+	assert.equal(counters.branch, 2, "a new leaf rebuilds it");
+	const added = estimateTokens((followUp as SessionEntry & { message: Parameters<typeof estimateTokens>[0] }).message);
+	assert.equal(grown.contextTokens, first.contextTokens + added);
+	assert.equal(grown.contextTokens, piEstimate(branch));
+});
+
+test("pi's measured figure takes over as soon as it has one", () => {
+	const counters = { branch: 0 };
+	const builder = new SegmentContextBuilder(fakePi);
+	builder.attach(fakeCtx(compactedBranch(), { tokens: 12_345, contextWindow: WINDOW, percent: 9.4 }, counters));
+	const ctx = builder.build(80, OPTIONS, INCLUDE, undefined);
+	assert.equal(ctx.contextTokens, 12_345);
+	assert.equal(ctx.contextPercent, 9.4);
+	assert.equal(ctx.contextEstimated, false);
+	assert.equal(counters.branch, 0, "no estimate is computed");
+});
+
+test("a broken session manager costs the estimate, not the frame", () => {
+	const builder = new SegmentContextBuilder(fakePi);
+	const ctx = fakeCtx(compactedBranch(), UNKNOWN);
+	(ctx as { sessionManager: Partial<ExtensionContext["sessionManager"]> }).sessionManager = {
+		getSessionName: () => undefined,
+		getEntries: () => [],
+	};
+	builder.attach(ctx);
+	const built = builder.build(80, OPTIONS, INCLUDE, undefined);
+	assert.equal(built.contextPercent, null);
+	assert.equal(built.contextTokens, 0);
+	assert.equal(built.contextEstimated, false);
+});
+
+test("an empty branch estimates zero", () => {
+	assert.equal(
+		estimateCompactedContextTokens({
+			getBranch: () => [],
+			getLeafId: () => null,
+		} as unknown as ExtensionContext["sessionManager"]),
+		0,
+	);
+});
+
+test("the graph draws an estimate with a ~ on its label", () => {
+	const estimated = SEGMENTS.context_graph.render(
+		segmentCtx({ contextPercent: 9.2, contextTokens: 12_000, contextEstimated: true }),
+	);
+	assert.ok(estimated.visible);
+	assert.equal(stripAnsi(estimated.content), `${"▋".repeat(2)}${"░".repeat(18)} ~9.2%/131K`);
+
+	const measured = SEGMENTS.context_graph.render(segmentCtx({ contextPercent: 9.2, contextTokens: 12_000 }));
+	assert.equal(stripAnsi(measured.content), `${"▋".repeat(2)}${"░".repeat(18)} 9.2%/131K`);
+
+	const unknown = SEGMENTS.context_graph.render(segmentCtx({}));
+	assert.equal(unknown.visible, false, "with nothing to size against, the graph still stays out");
+});

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

@@ -48,3 +48,9 @@ test("a null or undefined percent against a known window renders '?'", () => {
 test("a known percent renders with one decimal", () => {
 	assert.equal(formatContextUsage(42.567, 200_000), "42.6%/200K");
 });
+
+test("an estimate wears ~ wherever it shows a figure", () => {
+	assert.equal(formatContextUsage(9.2, 131_072, 12_000, true), "~9.2%/131K");
+	assert.equal(formatContextUsage(9.2, 0, 12_000, true), "~12K/?");
+	assert.equal(formatContextUsage(null, 131_072, 0, true), "?/131K", "nothing to mark");
+});

package/src/tests/feeds.test.ts

@@ -14,9 +14,10 @@ import test from "node:test";
 import type { ExtensionAPI, ExtensionContext, SessionEntry } from "@earendil-works/pi-coding-agent";
 import { renderBoxRowIfVisible } from "../box.ts";
 import { FEED_FADE_MS, FEED_HOLD_MS, SegmentContextBuilder, getFeedDisplayState } from "../context.ts";
+import { stripAnsi } from "../footer.ts";
 import { buildStatusLine } from "../layout.ts";
 import { SEGMENTS } from "../segments.ts";
-import { DEFAULT_FEEDS, DEFAULT_SEGMENTS, resolveEffectiveSettings, sanitizeFeeds } from "../settings.ts";
+import { DEFAULT_SEGMENTS, resolveEffectiveSettings, sanitizeFeeds } from "../settings.ts";
 import { theme } from "../theme.ts";
 import type { FeedDisplayState, SegmentContext, StatusLineFeed } from "../types.ts";
 import { feedKey } from "../utils.ts";
@@ -31,7 +32,6 @@ const feedMap = (entries: Record<string, unknown> = {}): Record<string, unknown>
 	Object.assign(Object.create(null) as Record<string, unknown>, entries);
 
 const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
-const stripAnsi = (text: string) => text.replace(/\x1b\[[0-9;]*m/g, "");
 
 // Partial stand-ins: the builder only reaches the members defined here.
 const fakePi = { exec: async () => undefined, getThinkingLevel: () => "off" } as unknown as ExtensionAPI;
@@ -507,9 +507,3 @@ test("sanitizeFeeds drops unusable rows and normalizes the rest", () => {
 test("an explicitly empty feed list is honoured rather than reseeded", () => {
 	assert.deepEqual(resolveEffectiveSettings({ feeds: [] }).segmentOptions.feeds, []);
 });
-
-test("the default subscription matches what pi-prompt-cache publishes", () => {
-	assert.equal(DEFAULT_FEEDS[0]?.customType, SAVINGS);
-	assert.equal(DEFAULT_FEEDS[0]?.field, "savedUsd");
-	assert.equal(DEFAULT_FEEDS[0]?.format, "currency");
-});

package/src/tests/menu.test.ts

@@ -1,11 +1,17 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import type { Theme } from "@earendil-works/pi-coding-agent";
+import { stripAnsi } from "../footer.ts";
 import { MenuComponent } from "../menu.ts";
 import type { MenuSection } from "../menu.ts";
 
-const theme = { fg: (_c: string, s: string) => s, bold: (s: string) => s } as unknown as Theme;
-const plain = (lines: string[]) => lines.map(l => l.replace(/\x1b\[[0-9;]*m/g, ""));
+const theme = {
+	fg: (_c: string, s: string) => s,
+	bg: (color: string, s: string) => color === "selectedBg" ? `\x1b[48;5;1m${s}\x1b[49m` : s,
+	bold: (s: string) => s,
+	getBgAnsi: (color: string) => color === "selectedBg" ? "\x1b[48;5;1m" : "",
+} as unknown as Theme;
+const plain = (lines: string[]) => lines.map(stripAnsi);
 
 function makeSections(feeds: { customType: string; prefix: string }[]): MenuSection[] {
 	const items: any[] = [];
@@ -47,6 +53,29 @@ function drive() {
 
 const type = (menu: any, s: string) => { for (const ch of s) menu.handleInput(ch); };
 
+test("selected rows use the pi-topping marker and background", () => {
+	const { menu } = drive();
+	const lines = menu.render(60);
+	const plainText = plain(lines).join("\n");
+	assert.match(plainText, /> 1\. type/);
+	assert.ok(!plainText.includes("▸"));
+	assert.ok(lines.some(line => line.includes("\x1b[48;5;1m")), "selected row background is missing");
+});
+
+test("selected row background survives an embedded reset from truncated content", () => {
+	const { menu } = drive();
+	// Width narrow enough that the "1. type" label truncates, which embeds a raw \x1b[0m reset.
+	const lines = menu.render(15);
+	const selectedLine = lines.find(line => line.includes("\x1b[48;5;1m"))!;
+	assert.ok(selectedLine, "selected row not found");
+	assert.ok(selectedLine.includes("\x1b[0m"), "expected a reset from truncateToWidth in the selected row");
+	assert.doesNotMatch(
+		selectedLine,
+		/\x1b\[0m(?!\x1b\[48;5;1m)/,
+		"selected background must be reopened after every reset",
+	);
+});
+
 test("typing into a text row edits only on commit", () => {
 	const { menu } = drive();
 	menu.handleInput("\r");                    // Enter on row 0 -> begin editing

package/src/tests/token-rate.test.ts

@@ -8,6 +8,7 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { SegmentContextBuilder } from "../context.ts";
+import { stripAnsi } from "../footer.ts";
 import { SEGMENTS } from "../segments.ts";
 import { resolveEffectiveSettings } from "../settings.ts";
 import { FADE_SHADE_COUNT, theme } from "../theme.ts";
@@ -31,7 +32,7 @@ const BASE = builder.build(
 );
 
 const render = (tokenRate: TokenRateDisplay) => SEGMENTS.token_rate.render({ ...BASE, tokenRate });
-const plain = (tokenRate: TokenRateDisplay) => render(tokenRate).content.replace(/\x1b\[[0-9;]*m/g, "");
+const plain = (tokenRate: TokenRateDisplay) => stripAnsi(render(tokenRate).content);
 const active = (rate: number | null): TokenRateDisplay => ({ rate, phase: "active", fadeShade: 0 });
 
 test("the rate is right-aligned to the placeholder's width", () => {

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

@@ -0,0 +1,12 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { hostsWorkingStatus } from "../working-status-embed.ts";
+
+test("only an opted-in editor that receives the host's status hosts the working status", () => {
+	const setWorkingStatusIndicator = (): void => {};
+	assert.equal(hostsWorkingStatus({ embedWorkingStatus: true, setWorkingStatusIndicator }), true);
+	assert.equal(hostsWorkingStatus({ embedWorkingStatus: false, setWorkingStatusIndicator }), false);
+	assert.equal(hostsWorkingStatus({ embedWorkingStatus: true }), false, "pre-0.85 hosts never send the status");
+	assert.equal(hostsWorkingStatus({}), false);
+	assert.equal(hostsWorkingStatus(undefined), false, "a wrapped third-party editor keeps pi's standalone status row");
+});