@underactive/pi-topping-statusline 0.2.8 → 0.3.0

package/src/tests/cache-hit.test.ts

@@ -0,0 +1,318 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import type { ExtensionAPI, ExtensionContext, SessionEntry } from "@earendil-works/pi-coding-agent";
+import {
+	CACHE_HIT_DEFAULT_CELLS,
+	CACHE_HIT_MAX_CELLS,
+	CACHE_HIT_MIN_CELLS,
+	clampCacheHitCells,
+	getCacheHitGraphCells,
+	getCacheHitPercent,
+	getCacheHitThresholds,
+	parseCacheHitStat,
+	renderCacheHitGraph,
+	stripCacheHitStat,
+} from "../cache-hit.ts";
+import { SegmentContextBuilder } from "../context.ts";
+import { stripAnsi } from "../footer.ts";
+import { buildStatusLine } from "../layout.ts";
+import { SEGMENTS } from "../segments.ts";
+import { resolveEffectiveSettings } from "../settings.ts";
+import { buildSections, valuesToSettings } from "../settings-menu.ts";
+import { theme } from "../theme.ts";
+import type { SegmentContext } from "../types.ts";
+
+const usage = (input: number, cacheRead: number, cacheWrite = 0) => ({
+	input,
+	output: 0,
+	cacheRead,
+	cacheWrite,
+	totalTokens: input + cacheRead + cacheWrite,
+	cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+});
+
+const entry = (value: unknown): SessionEntry => value as SessionEntry;
+
+test("the fallback rate is pi's CH: the latest assistant response only", () => {
+	const entries = [
+		entry({ type: "message", message: { role: "assistant", usage: usage(80, 20) } }),
+		entry({ type: "message", message: { role: "assistant", usage: usage(6, 990, 4) } }),
+		entry({ type: "usage", usage: usage(500, 0) }),
+		entry({ type: "compaction", usage: usage(500, 0) }),
+	];
+	assert.equal(getCacheHitPercent(entries), 99);
+});
+
+test("the fallback rate stays absent before an assistant reports prompt tokens", () => {
+	assert.equal(getCacheHitPercent([entry({ type: "usage", usage: usage(10, 90) })]), null);
+	assert.equal(getCacheHitPercent([entry({ type: "message", message: { role: "assistant", usage: usage(0, 0) } })]), null);
+});
+
+test("pi's CH stat is parsed from its stats line", () => {
+	assert.equal(parseCacheHitStat("↑1.2M ↓48K R6.1M W120K CH99.4% $2.357"), 99.4);
+	assert.equal(parseCacheHitStat("↑1.2M ↓48K $2.357"), null);
+	assert.equal(parseCacheHitStat(undefined), null);
+});
+
+test("99.1% fills four cells and 99.4% fills all five at five segments", () => {
+	assert.equal(getCacheHitGraphCells(99.1, 5), 4);
+	assert.equal(getCacheHitGraphCells(99.4, 5), 5);
+});
+
+test("the Cache hit bar toggle controls a standalone segment", () => {
+	const on = resolveEffectiveSettings({});
+	assert.equal(on.includes.cacheHit, true);
+	assert.ok(on.bottomRightSegments.includes("cache_hit_graph"));
+
+	const off = resolveEffectiveSettings({ segments: { cacheHitBar: false } });
+	assert.equal(off.includes.cacheHit, false);
+	assert.equal(off.segmentOptions.context.showBar, true);
+	assert.ok(!off.bottomRightSegments.includes("cache_hit_graph"));
+
+	const cacheOnly = resolveEffectiveSettings({ segments: { piStats: false, contextBar: false, contextStats: false } });
+	assert.deepEqual(cacheOnly.bottomRightSegments.slice(-1), ["cache_hit_graph"]);
+});
+
+test("the cache graph owns its CH label", () => {
+	const options = resolveEffectiveSettings({}).segmentOptions;
+	const result = SEGMENTS.cache_hit_graph.render({ options, cacheHitPercent: 100 } as SegmentContext);
+	assert.equal(stripAnsi(result.content), `${"▋".repeat(4)} CH100.0%`);
+	assert.equal(SEGMENTS.cache_hit_graph.render({ options, cacheHitPercent: null } as SegmentContext).visible, false);
+});
+
+test("the cache graph is as long as the CH bar segments setting", () => {
+	for (const cells of [4, 7, 10]) {
+		const options = resolveEffectiveSettings({ cacheHitBarSegments: cells }).segmentOptions;
+		const result = SEGMENTS.cache_hit_graph.render({ options, cacheHitPercent: 100 } as SegmentContext);
+		assert.equal(stripAnsi(result.content), `${"▋".repeat(cells)} CH100.0%`);
+	}
+});
+
+test("the builder prefers pi's CH stat and falls back to the derived rate", () => {
+	const effective = resolveEffectiveSettings({});
+	const fakePi = { exec: async () => undefined, getThinkingLevel: () => "off" } as unknown as ExtensionAPI;
+	const entries = [entry({ type: "message", message: { role: "assistant", usage: usage(50, 50) } })];
+	const ctx = {
+		cwd: "/tmp/pi-topping-statusline-tests",
+		model: undefined,
+		getContextUsage: () => undefined,
+		sessionManager: { getSessionName: () => undefined, getEntries: () => entries },
+	} as unknown as ExtensionContext;
+	const include = { ...effective.includes, git: false, pr: false, piStats: true, feeds: [] };
+
+	let stats: string | undefined = "↑1.2M CH99.4% $2.357";
+	const builder = new SegmentContextBuilder(fakePi);
+	builder.setPiStatsProvider(() => stats);
+	builder.attach(ctx);
+	const fromStats = builder.build(80, effective.segmentOptions, include, undefined);
+	assert.equal(fromStats.cacheHitPercent, 99.4);
+	assert.equal(fromStats.piStats, "↑1.2M $2.357", "CH moves beside its graph");
+
+	stats = undefined;
+	const fallback = new SegmentContextBuilder(fakePi);
+	fallback.setPiStatsProvider(() => stats);
+	fallback.attach(ctx);
+	assert.equal(fallback.build(80, effective.segmentOptions, include, undefined).cacheHitPercent, 50);
+	builder.dispose();
+	fallback.dispose();
+});
+
+test("the builder does not derive a CH rate when pi's stats line omits it", () => {
+	const effective = resolveEffectiveSettings({});
+	const fakePi = { exec: async () => undefined, getThinkingLevel: () => "off" } as unknown as ExtensionAPI;
+	const entries = [entry({ type: "message", message: { role: "assistant", usage: usage(100, 0) } })];
+	const ctx = {
+		cwd: "/tmp/pi-topping-statusline-tests",
+		model: undefined,
+		getContextUsage: () => undefined,
+		sessionManager: { getSessionName: () => undefined, getEntries: () => entries },
+	} as unknown as ExtensionContext;
+	const include = { ...effective.includes, git: false, pr: false, piStats: true, feeds: [] };
+	const builder = new SegmentContextBuilder(fakePi);
+	builder.setPiStatsProvider(() => "↑1.2M ↓48K $2.357");
+	builder.attach(ctx);
+	assert.equal(builder.build(80, effective.segmentOptions, include, undefined).cacheHitPercent, null);
+	builder.dispose();
+});
+
+test("only 0% is empty; after 50% each cell quarters the remaining miss rate", () => {
+	assert.equal(getCacheHitGraphCells(0, 5), 0);
+	assert.equal(getCacheHitGraphCells(0.1, 5), 1);
+	assert.equal(getCacheHitGraphCells(49.9, 5), 1);
+	assert.equal(getCacheHitGraphCells(50, 5), 2);
+	assert.equal(getCacheHitGraphCells(87.4, 5), 2);
+	assert.equal(getCacheHitGraphCells(87.5, 5), 3);
+	assert.equal(getCacheHitGraphCells(96.875, 5), 4);
+	assert.equal(getCacheHitGraphCells(99.21875, 5), 5);
+	assert.equal(getCacheHitGraphCells(100, 5), 5);
+	assert.equal(getCacheHitGraphCells(Number.NaN, 5), 0);
+});
+
+test("the rendered bar is five cells wide at five segments", () => {
+	assert.equal(stripAnsi(renderCacheHitGraph(0, 5)), "░".repeat(5));
+	assert.equal(stripAnsi(renderCacheHitGraph(10, 5)), `▋${"░".repeat(4)}`);
+	assert.equal(stripAnsi(renderCacheHitGraph(50, 5)), `${"▋".repeat(2)}${"░".repeat(3)}`);
+});
+
+test("the entire filled bar uses its current hit-rate color", () => {
+	assert.ok(renderCacheHitGraph(10).includes(theme.getFgAnsi("error")));
+
+	const sixty = renderCacheHitGraph(60);
+	assert.ok(sixty.includes(theme.getFgAnsi("statusLineContextElevated")));
+	assert.ok(!sixty.includes(theme.getFgAnsi("error")));
+
+	const ninetyFive = renderCacheHitGraph(95);
+	assert.ok(ninetyFive.includes(theme.getFgAnsi("warning")));
+	assert.ok(!ninetyFive.includes(theme.getFgAnsi("error")));
+	assert.ok(!ninetyFive.includes(theme.getFgAnsi("statusLineContextElevated")));
+
+	assert.ok(renderCacheHitGraph(99.1).includes(theme.getFgAnsi("statusLineCacheHit")));
+
+	const perfect = renderCacheHitGraph(100);
+	assert.equal(stripAnsi(perfect), "▋".repeat(4));
+	assert.ok(perfect.includes(theme.getFgAnsi("statusLineCacheHit")));
+	assert.ok(!perfect.includes(theme.getFgAnsi("warning")));
+});
+
+test("cache hit stat stripping preserves the other footer figures", () => {
+	assert.equal(stripCacheHitStat("↑425k ↓40k R11M W328k CH99.1% $5.091"), "↑425k ↓40k R11M W328k $5.091");
+	assert.equal(stripCacheHitStat("↑425k $5.091"), "↑425k $5.091");
+});
+
+test("the bottom bar groups Pi stats, the CH graph and context graph separately", () => {
+	const effective = resolveEffectiveSettings({ transparent: true, separator: "powerline-thin", cacheHitBarSegments: 5 });
+	const ctx = {
+		options: effective.segmentOptions,
+		model: undefined,
+		thinkingLevel: "off",
+		cwd: "/tmp",
+		sessionName: undefined,
+		contextPercent: 17.8,
+		contextTokens: 178_000,
+		contextWindow: 1_000_000,
+		cacheHitPercent: 99.1,
+		git: { branch: null, status: null, pr: null },
+		worktree: null,
+		scrollHint: undefined,
+		piStats: "↑425k ↓40k R11M W328k $5.091",
+		tokenRate: undefined,
+		feedData: undefined,
+	} satisfies SegmentContext;
+	const bar = buildStatusLine(0, ctx, effective, text => text, { left: [], right: effective.bottomRightSegments });
+	assert.equal(
+		stripAnsi(bar),
+		` ↑425k ↓40k R11M W328k $5.091  ${"▋".repeat(4)}░ CH99.1%  ${"▋".repeat(4)}${"░".repeat(16)} 17.8%/1.0M `,
+	);
+
+	let fittedRight: readonly string[] = [];
+	const narrowBar = buildStatusLine(
+		50,
+		ctx,
+		effective,
+		text => text,
+		{ left: [], right: effective.bottomRightSegments },
+		undefined,
+		{ onFit: fit => { fittedRight = fit.right; } },
+	);
+	assert.deepEqual(fittedRight, ["pi_stats", "cache_hit_graph"]);
+	assert.ok(stripAnsi(narrowBar).includes("CH99.1%"));
+});
+
+test("the 5-segment scale is the quartering scale: 50, 87.5, 96.875, 99.21875", () => {
+	assert.deepEqual(getCacheHitThresholds(5), [50, 87.5, 96.875, 99.21875]);
+	assert.deepEqual(getCacheHitThresholds(4), [50, 93.75, 99.21875]);
+});
+
+test("every bar size is logarithmic, from 50% at the second cell to 99.21875% at the last", () => {
+	for (let cells = CACHE_HIT_MIN_CELLS; cells <= CACHE_HIT_MAX_CELLS; cells++) {
+		const thresholds = getCacheHitThresholds(cells);
+		assert.equal(thresholds.length, cells - 1, `${cells} cells: one threshold per cell after the first`);
+		assert.equal(thresholds[0], 50);
+		assert.equal(thresholds.at(-1), 99.21875);
+		const misses = thresholds.map(t => 100 - t);
+		for (let i = 1; i < misses.length; i++) {
+			assert.ok(misses[i]! < misses[i - 1]!, `${cells} cells: thresholds strictly increase`);
+		}
+		// A log scale shrinks the miss rate by the same factor from cell to cell.
+		const ratios = misses.slice(1).map((miss, i) => miss / misses[i]!);
+		for (const ratio of ratios) assert.ok(Math.abs(ratio - ratios[0]!) < 1e-4, `${cells} cells: constant ratio ${ratios}`);
+	}
+});
+
+test("every bar size keeps the rules: 0% is empty, anything above fills a cell, 100% is full", () => {
+	for (let cells = CACHE_HIT_MIN_CELLS; cells <= CACHE_HIT_MAX_CELLS; cells++) {
+		assert.equal(getCacheHitGraphCells(0, cells), 0);
+		assert.equal(getCacheHitGraphCells(0.01, cells), 1);
+		assert.equal(getCacheHitGraphCells(49.9, cells), 1);
+		assert.equal(getCacheHitGraphCells(50, cells), 2);
+		assert.equal(getCacheHitGraphCells(100, cells), cells);
+		let previous = 0;
+		for (const percent of [1, 20, 50, 70, 90, 95, 98, 99, 99.5, 100]) {
+			const filled = getCacheHitGraphCells(percent, cells);
+			assert.ok(filled >= previous && filled <= cells, `${cells} cells at ${percent}%: ${filled}`);
+			previous = filled;
+		}
+		assert.equal(stripAnsi(renderCacheHitGraph(0, cells)), "░".repeat(cells));
+		assert.equal(stripAnsi(renderCacheHitGraph(100, cells)), "▋".repeat(cells));
+	}
+});
+
+test("more segments resolve finer near 100%", () => {
+	assert.equal(getCacheHitGraphCells(99.1, 3), 2);
+	assert.equal(getCacheHitGraphCells(99.4, 3), 3);
+	assert.equal(getCacheHitGraphCells(99.1, 4), 3);
+	assert.equal(getCacheHitGraphCells(99.1, 5), 4);
+	assert.equal(getCacheHitGraphCells(99.1, 10), 9, "98.69% is the ninth cell's threshold; the tenth needs 99.22%");
+	assert.equal(getCacheHitGraphCells(99.4, 10), 10);
+});
+
+test("a hit rate keeps its color at every bar size", () => {
+	for (const percent of [10, 60, 95, 99.1]) {
+		const colors = new Set<string>();
+		for (let cells = CACHE_HIT_MIN_CELLS; cells <= CACHE_HIT_MAX_CELLS; cells++) {
+			colors.add(renderCacheHitGraph(percent, cells).match(/^\x1b\[[\d;]+m/)![0]);
+		}
+		assert.equal(colors.size, 1, `${percent}% should be one color across sizes`);
+	}
+});
+
+test("the bar size is clamped to 3–10, with 4 for anything unusable", () => {
+	assert.equal(CACHE_HIT_DEFAULT_CELLS, 4);
+	assert.equal(clampCacheHitCells(2), 3);
+	assert.equal(clampCacheHitCells(3), 3);
+	assert.equal(clampCacheHitCells(11), 10);
+	assert.equal(clampCacheHitCells(6.4), 6);
+	assert.equal(clampCacheHitCells(Number.NaN), 4);
+	assert.equal(clampCacheHitCells(Number.POSITIVE_INFINITY), 4);
+	assert.equal(clampCacheHitCells("7"), 4);
+	assert.equal(clampCacheHitCells(undefined), 4);
+	assert.equal(renderCacheHitGraph(100, 99).length, renderCacheHitGraph(100, 10).length, "a bad size renders as the clamped size");
+});
+
+test("the CH bar segments setting resolves to the segment options, default 4", () => {
+	assert.equal(resolveEffectiveSettings({}).segmentOptions.cacheHit.cells, 4);
+	assert.equal(resolveEffectiveSettings({ cacheHitBarSegments: 8 }).segmentOptions.cacheHit.cells, 8);
+	assert.equal(resolveEffectiveSettings({ cacheHitBarSegments: 2 }).segmentOptions.cacheHit.cells, 3);
+	assert.equal(resolveEffectiveSettings({ cacheHitBarSegments: 40 }).segmentOptions.cacheHit.cells, 10);
+});
+
+test("the settings menu offers CH bar segments 3–10 under the Cache hit bar toggle and reads the choice back", () => {
+	const items = buildSections({}).flatMap(section => section.items);
+	const toggle = items.findIndex(item => item.id === "cacheHitBar");
+	const row = items[toggle + 1]!;
+	assert.equal(row.kind, "cycle");
+	if (row.kind !== "cycle") return;
+	assert.equal(row.id, "cacheHitBarSegments");
+	assert.equal(row.label, "CH bar segments");
+	assert.equal(row.value, "4", "defaults to 4");
+	assert.deepEqual(row.values, ["3", "4", "5", "6", "7", "8", "9", "10"]);
+
+	const saved = buildSections({ cacheHitBarSegments: 9 }).flatMap(section => section.items);
+	const savedRow = saved.find(item => item.id === "cacheHitBarSegments");
+	assert.equal(savedRow?.kind === "cycle" && savedRow.value, "9", "shows the saved size");
+
+	// Action rows hold no value, so only value-bearing rows seed the draft.
+	const values = Object.fromEntries(saved.flatMap(item => ("value" in item ? [[item.id, item.value]] : [])));
+	assert.equal(valuesToSettings({ ...values, cacheHitBarSegments: "7" }).cacheHitBarSegments, 7);
+	assert.equal(valuesToSettings({ ...values, cacheHitBarSegments: "garbage" }).cacheHitBarSegments, 4);
+});

package/src/tests/color-mode.test.ts

@@ -87,6 +87,26 @@ test("pi capability overrides take precedence over terminal hints", () => {
 	}
 });
 
+test("the working-group fade keeps the git indicators' hues in both colour modes", () => {
+	try {
+		forceTrueColor(false);
+		const untracked256 = theme.fadeAnsi(theme.fg("statusLineUntracked", "?1"), 0.9);
+		const dirty256 = theme.fadeAnsi(theme.fg("statusLineDirty", "*1"), 0.9);
+		forceTrueColor(true);
+		const untrackedTruecolor = theme.fadeAnsi(
+			theme.fg("statusLineUntracked", "?1"),
+			0.9,
+		);
+		const actual = [untracked256, dirty256, untrackedTruecolor];
+		const details = `actual fades: ${JSON.stringify(actual)}`;
+		assert.ok(untracked256.startsWith("\x1b[38;5;39m?1"), details);
+		assert.ok(dirty256.startsWith("\x1b[38;5;178m*1"), details);
+		assert.ok(untrackedTruecolor.startsWith("\x1b[38;2;2;159;231m?1"), details);
+	} finally {
+		resetCapabilities();
+	}
+});
+
 test("PI_TRUE_COLOR controls capability detection", () => {
 	const previousTrueColor = process.env.PI_TRUE_COLOR;
 	const previousHyperlinks = process.env.PI_HYPERLINKS;

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

@@ -1,58 +1,19 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import { resetCapabilitiesCache, setCapabilities, setCapabilityOverrides } from "@earendil-works/pi-tui";
+import { renderCometBar } from "@underactive/pi-topping-primitives/color";
 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, "");
+// The bar's geometry, glyphs, clamping and 256-color path are tested where the renderer lives:
+// @underactive/pi-topping-primitives tests/color-comet-bar.test.ts.
 
-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])]);
+test("the compaction bar is the shared comet bar, with shimmerElapsedMs as its elapsed time", () => {
+	for (const mode of ["truecolor", "256color"] as const) {
+		assert.equal(
+			renderCompactionBar(50, { mode, shimmerElapsedMs: 500 }),
+			renderCometBar(50, { mode, elapsedMs: 500 }),
+		);
 	}
-	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", () => {

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

@@ -68,17 +68,21 @@ test("the bar hosts the progress only with the setting on and a stand-in slot sh
 	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 } });
+	const nowhere = resolveEffectiveSettings({ segments: { piStats: false, cacheHitBar: false, contextBar: false, contextStats: false } });
 	assert.equal(hostsCompactionProgress(nowhere), false);
+	const cacheOnly = resolveEffectiveSettings({ segments: { piStats: false, contextBar: false, contextStats: false } });
+	assert.ok(cacheOnly.bottomRightSegments.includes("cache_hit_graph"), "the cache bar keeps its segment");
+	assert.equal(hostsCompactionProgress(cacheOnly), false, "the cache bar alone is not a stand-in slot");
 });
 
 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(effective.bottomRightSegments, ["feeds", "token_rate", "pi_stats", "cache_hit_graph", "context_graph"]);
 	assert.deepEqual(bottomRightSegments(effective, true), [
 		"feeds",
 		"token_rate",
 		"compaction_info",
+		"cache_hit_graph",
 		"compaction_graph",
 	]);
 	assert.equal(bottomRightSegments(effective, false), effective.bottomRightSegments);

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

@@ -21,7 +21,7 @@ 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: [] };
+const INCLUDE = { git: false, pr: false, piStats: false, tokenRate: false, cacheHit: 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;

package/src/tests/feeds.test.ts

@@ -1,7 +1,8 @@
 /**
  * Contracts for the feeds segment, which surfaces values other extensions
- * publish as custom session entries. The default subscription targets
- * pi-prompt-cache's savings feed, whose author specified the currency rules.
+ * publish as custom session entries. The currency rules are those of
+ * pi-topping-compact's savings feed, whose author specified them. No
+ * subscription ships by default, so every test here passes its feeds explicitly.
  *
  * Ordering matters here: a publisher emits at turn end or after compaction,
  * both of which require a completed model call, so a live entry is always
@@ -22,9 +23,12 @@ import { theme } from "../theme.ts";
 import type { FeedDisplayState, SegmentContext, StatusLineFeed } from "../types.ts";
 import { feedKey } from "../utils.ts";
 
-const SAVINGS = "pi-prompt-cache/savings";
-const OPTIONS = resolveEffectiveSettings({}).segmentOptions;
-const INCLUDE = { git: false, pr: false, piStats: false, tokenRate: false, feeds: [SAVINGS] };
+const SAVINGS = "pi-topping-compact/savings";
+/** The subscription the old default seeded, passed explicitly now that no default ships. */
+const OPTIONS = resolveEffectiveSettings({
+	feeds: [{ customType: SAVINGS, field: "savedUsd", prefix: "CS", format: "currency" }],
+}).segmentOptions;
+const INCLUDE = { git: false, pr: false, piStats: false, tokenRate: false, cacheHit: false, feeds: [SAVINGS] };
 /** Outside any repo, so the builder's git probes stay inert. */
 const CWD = "/tmp/pi-topping-statusline-tests";
 /** Match the builder's intentional prototype-less feed map in deep equality assertions. */
@@ -56,13 +60,14 @@ const feedEntry = (data: unknown, customType = SAVINGS, timestamp = new Date().t
 async function contextAfterEmitting(
 	makeEntries: () => SessionEntry[],
 	include = INCLUDE,
+	options = OPTIONS,
 ): Promise<SegmentContext> {
 	const entries: SessionEntry[] = [];
 	const builder = new SegmentContextBuilder(fakePi);
 	builder.attach(fakeCtx(entries));
 	await sleep(3);
 	entries.push(...makeEntries());
-	return builder.build(80, OPTIONS, include, undefined);
+	return builder.build(80, options, include, undefined);
 }
 
 const BASE = await contextAfterEmitting(() => []);
@@ -456,23 +461,36 @@ test("the prefix is literal, so the currency symbol can live in either place", (
 
 // ── settings ───────────────────────────────────────────────────────────────
 
-test("defaults: segment off, seeded with the pi-prompt-cache subscription", () => {
+test("defaults: segment off, no subscriptions", () => {
 	assert.equal(DEFAULT_SEGMENTS.feeds, false);
 	assert.ok(!resolveEffectiveSettings({}).bottomRightSegments.includes("feeds"));
-	assert.deepEqual(resolveEffectiveSettings({}).segmentOptions.feeds, [
-		{ customType: SAVINGS, field: "savedUsd", prefix: "CS", format: "currency" },
-	]);
+	assert.deepEqual(resolveEffectiveSettings({}).segmentOptions.feeds, []);
 	assert.deepEqual(resolveEffectiveSettings({ segments: { feeds: true } }).bottomRightSegments, [
 		"feeds",
 		"pi_stats",
+		"cache_hit_graph",
 		"context_graph",
 	]);
 });
 
+test("a saved subscription renders a fresh entry as CS currency", async () => {
+	const { segmentOptions } = resolveEffectiveSettings({ feeds: [savingsFeed("currency", "CS")] });
+	const include = { ...INCLUDE, feeds: segmentOptions.feeds.map(feed => feed.customType) };
+	const ctx = await contextAfterEmitting(() => [feedEntry({ savedUsd: 1.44 })], include, segmentOptions);
+	assert.equal(stripAnsi(SEGMENTS.feeds.render(ctx).content), "CS$1.44");
+});
+
+test("an entry nobody subscribed to renders nothing under the default settings", async () => {
+	const { segmentOptions } = resolveEffectiveSettings({});
+	const include = { ...INCLUDE, feeds: segmentOptions.feeds.map(feed => feed.customType) };
+	const ctx = await contextAfterEmitting(() => [feedEntry({ savedUsd: 1.44 })], include, segmentOptions);
+	assert.equal(SEGMENTS.feeds.render(ctx).visible, false);
+});
+
 test("feeds lead the bottom-right group", () => {
 	assert.deepEqual(
 		resolveEffectiveSettings({ segments: { feeds: true, tokenRate: true } }).bottomRightSegments,
-		["feeds", "token_rate", "pi_stats", "context_graph"],
+		["feeds", "token_rate", "pi_stats", "cache_hit_graph", "context_graph"],
 	);
 });
 

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

@@ -7,7 +7,7 @@ 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 GIT_INCLUDE = { git: true, pr: false, piStats: false, tokenRate: false, cacheHit: false, feeds: [] };
 const NO_GIT_INCLUDE = { ...GIT_INCLUDE, git: false };
 const CWD = "/repo";
 
@@ -37,7 +37,7 @@ test("the context builder supplies changed-file counts to the git segment", asyn
 			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" };
+			if (args.includes("status")) return { code: 0, stdout: " M unstaged.ts\nM  staged.ts\n?? new.ts\n" };
 			return { code: 1, stdout: "" };
 		},
 		getThinkingLevel: () => "off",
@@ -57,6 +57,6 @@ test("the context builder supplies changed-file counts to the git segment", asyn
 		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"));
+	assert.ok(commands.some(args => args.join(" ") === "-c core.fsmonitor=false status --porcelain"));
 	builder.dispose();
 });

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

@@ -4,19 +4,10 @@ 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);

package/src/tests/rainbow.test.ts

@@ -25,7 +25,7 @@ builder.attach(fakeCtx);
 const BASE = builder.build(
 	80,
 	resolveEffectiveSettings({}).segmentOptions,
-	{ git: false, pr: false, piStats: false, tokenRate: false, feeds: [] },
+	{ git: false, pr: false, piStats: false, tokenRate: false, cacheHit: false, feeds: [] },
 	undefined,
 );