@underactive/pi-topping-statusline 0.2.1 → 0.2.2

package/README.md

@@ -36,7 +36,7 @@ and apply live.
 ║ ╰── ↑ 3 more ── ↑ 12.4K ↓ 3.1K R 148K W 12K 92.3% $0.42 42%──╯ ║
 ║                                                                ║
 ╟─ Global ───────────────────────────────────────────────────────╢
-║  ▸ [■] Transparent Segments                                ON  ║
+║  > [■] Transparent Segments                                ON  ║
 ║    Separator                               ‹ powerline-thin ›  ║
 ║    Symbols                                       ‹ nerdfont ›  ║
 ║    Border style                                   ‹ rounded ›  ║
@@ -45,6 +45,7 @@ and apply live.
 ║    [■] NVIDIA-green when using Switchyard                  ON  ║
 ║    [■] Animate Switchyard green border                     ON  ║
 ║    [ ] Embed status spinners                               OFF ║
+║    [■] Embed compaction progress                           ON  ║
 ║                                                                ║
 ╟─ Top Left Segment Group ───────────────────────────────────────╢
 ║    [■] Pi symbol                                           ON  ║
@@ -69,18 +70,18 @@ and apply live.
 ║    + add feed                                                  ║
 ║                                                                ║
 ║  ↑↓ move  ←→ cycle  ␣ toggle  ⏎ apply/edit  esc cancel         ║
-╚════════════════════════════════════════════════════════[ 1/32 ]╝
+╚════════════════════════════════════════════════════════[ 1/33 ]╝
 ```
 
 | Section | Settings |
 | --- | --- |
-| Global | Transparent Segments · Separator (`powerline` `powerline-thin` `slash` `pipe` `ascii`) · Symbols (`nerdfont` `unicode` `ascii` — stored in settings.json as `nerd`/`unicode`/`ascii`) · Border style (`rounded` `heavy` `double` `single`) · Rainbow border on max thinking · Animate rainbow border · NVIDIA-green when using Switchyard · Animate Switchyard green border · Embed status spinners |
+| Global | Transparent Segments · Separator (`powerline` `powerline-thin` `slash` `pipe` `ascii`) · Symbols (`nerdfont` `unicode` `ascii` — stored in settings.json as `nerd`/`unicode`/`ascii`) · Border style (`rounded` `heavy` `double` `single`) · Rainbow border on max thinking · Animate rainbow border · NVIDIA-green when using Switchyard · Animate Switchyard green border · Embed status spinners · Embed compaction progress |
 | Top Left Segment Group | Pi symbol · Model · Provider · Thinking level · Path · Git · PR |
 | Top Right Segment Group | Token rate · Session name |
 | Bottom Right Segment Group | Feeds · Token rate · Pi stats · Context bar · Context stats |
 | Bottom Left Segment Group | Scroll hint · Feeds · Token rate |
 | Feeds | One subscription per row: type · field · prefix · format, plus add/remove |
-| Defaults | Transparent on · Separator `powerline-thin` · Symbols `nerdfont` · Border style `rounded` · Rainbow border on · Animate rainbow border on · NVIDIA-green when using Switchyard on · Animate Switchyard green border on · Embed status spinners off |
+| Defaults | Transparent on · Separator `powerline-thin` · Symbols `nerdfont` · Border style `rounded` · Rainbow border on · Animate rainbow border on · NVIDIA-green when using Switchyard on · Animate Switchyard green border on · Embed status spinners off · Embed compaction progress on |
 
 With **Rainbow border on max thinking** on (the default), cycling the thinking level to `max`
 replaces the border's fixed theme color with a rainbow: a full hue cycle distributed around the
@@ -101,10 +102,15 @@ to restore the normal theme or rainbow border.
 **Embed status spinners** (off by default) moves pi's status indicators out of their own row
 and into the top-left group, right after the Pi symbol and its chevron. On pi 0.86 and later
 this covers the working, retry, compaction, and branch-summary spinners; pi 0.85 embeds only
-the working indicator. The remaining left segments (model, path, git, PR) step aside while a
-status is visible, and the Pi symbol never moves. A cleared status is held briefly so handoffs
-between spinners do not flash the left segments. Only the end of a working spinner then
-cross-fades back over 750ms; the message-style spinners cut after the hold.
+the working indicator. The configured model, provider, and thinking details remain visible after
+the status; path, git, and PR step aside while a status is visible, and the Pi symbol never moves.
+An appearing status slides out from behind the Pi symbol's chevron over 300ms, pushing the model
+details right; one that replaces a status still on screen swaps in place without sliding.
+A cleared status is held briefly so handoffs between spinners do not flash the left segments.
+Only the working status cross-fades over 750ms; stable model details remain solid, and the
+message-style spinners cut after the hold. While the bar hosts the working status, it announces
+that on pi's extension event bus, and pi-topping's loader slides its response model out the same
+way; anywhere else that model appears at once.
 
 A status too long for the bar is truncated. The working spinner keeps pi's bare cut, while the
 message-style spinners use an ellipsis. Focusing the embed row in the settings preview shows
@@ -113,6 +119,22 @@ editor through pi, so it applies immediately, even mid-response. Only the status
 editor opts in: when another extension owns the editor slot and is wrapped, pi keeps its
 standalone status row.
 
+**Embed compaction progress** (on by default) hosts
+[pi-topping-compact](https://github.com/underactive/pi-topping-compact)'s compaction progress in
+the box's bottom border while a compaction runs. Its phosphor bar stands in for the context
+graph, followed by the tokens being compacted over the window and as a share of it
+(`86K/131K (66%)`), and `57% summarized · 16.3s` — how much has been summarized so far, and the
+time taken — stands in for pi's stats. The bar and its label follow the Context bar and Context
+stats toggles. The moment the compaction ends, pi's stats and the context graph return, the
+graph sizing the compacted context as an estimate until the next response (see Segments), and
+pi-topping-compact shows its completion result above the editor as it always has. Nothing
+changes without pi-topping-compact installed: the two talk over pi's extension event bus, this
+bar announcing whether it hosts the progress and pi-topping-compact broadcasting it only while
+it does, otherwise keeping its own above-editor widget. With the setting off, with Pi stats,
+Context bar, and Context stats all off, or with the terminal too narrow for the stand-ins, that
+widget is used instead. Focusing the setting's row in the settings preview shows the bottom bar
+mid-compaction.
+
 ## Segments
 
 Ported with pi data: `pi`, `model` (model · provider · thinking level), `path`
@@ -122,10 +144,18 @@ fs-watch), `pr` (via `gh`, hidden if missing), `session_name`, `token_rate` (liv
 accent while active, held 1.5s, faded 0.5s, then a dim `--- tok/s` placeholder; estimate
 pipelined from pi-topping's word-count EMA; available in the top-right, bottom-left, and
 bottom-right groups), `pi_stats`, `context_graph` (bar + stats), `scroll_hint`, plus `feeds`
-(documented below). On pi 0.86 and later, `pi_stats` includes cache-warming refreshes folded
+(documented below), with `compaction_info` and `compaction_graph` standing in for `pi_stats` and
+`context_graph` while pi-topping-compact's progress is hosted. On pi 0.86 and later, `pi_stats`
+includes cache-warming refreshes folded
 into pi's own footer totals, so cache R/W and cost can increase while idle; this segment matches
 the host footer by construction.
 
+Between a compaction and the next response, pi reports context usage as unknown. Rather than
+vanish for that stretch, `context_graph` shows pi's own estimate of the compacted context, the
+summary plus the kept messages sized by pi's estimator, marked with `~` (`~9.2%/131K`). It is
+the same figure pi-topping-compact reports in its result. pi's measured figure replaces it after
+the next response.
+
 When the terminal narrows: right segments drop first, then the path shrinks (to ~8 cells),
 then left segments drop end-first — the path is always the last to go.
 

package/index.ts

@@ -26,6 +26,13 @@ import {
 } from "@earendil-works/pi-coding-agent";
 import type { Component, TUI } from "@earendil-works/pi-tui";
 import { makeBoxPainters, renderBoxRow, renderBoxRowIfVisible } from "./src/box.js";
+import {
+	COMPACTION_EMBED_CHANNEL,
+	COMPACTION_FIT_PROBE,
+	COMPACTION_PROGRESS_CHANNEL,
+	hostsCompactionProgress,
+	parseCompactionProgress,
+} from "./src/compaction-embed.js";
 import { SegmentContextBuilder } from "./src/context.js";
 import {
 	collapseFooterLayoutSlot,
@@ -38,13 +45,20 @@ import { buildStatusLine } from "./src/layout.js";
 import { NvidiaGreenBorder, isSwitchyardProvider } from "./src/nvidia-green.js";
 import { RAINBOW_DEG_PER_FRAME, RAINBOW_FRAME_MS, RainbowBorder, type BorderColorizer } from "./src/rainbow.js";
 import { registerSettingsCommand } from "./src/settings-menu.js";
-import { createSettingsState, topLeftSegments } from "./src/settings.js";
+import { bottomRightSegments, COMPACTION_STAND_INS, createSettingsState, topLeftSegments } from "./src/settings.js";
 import { theme } from "./src/theme.js";
 import { TokenRateMonitor } from "./src/token-rate.js";
+import type {
+	CompactionProgressView,
+	EffectiveStatusLineSettings,
+	SegmentContext,
+	StatusLineSegmentId,
+} from "./src/types.js";
 import { isMessageKind, type StatusIndicatorKind, StatusTransition } from "./src/working-status.js";
+import { hostsWorkingStatus, WORKING_STATUS_EMBED_CHANNEL } from "./src/working-status-embed.js";
 type EditorFactory = NonNullable<ReturnType<ExtensionContext["ui"]["getEditorComponent"]>>;
 
-const WORKING_FADE_FRAME_MS = 30;
+const STATUS_ANIMATION_FRAME_MS = 30;
 
 export default function (pi: ExtensionAPI) {
 	const state = createSettingsState();
@@ -65,10 +79,10 @@ export default function (pi: ExtensionAPI) {
 	let embeddedWorkingStatus: ((width: number) => string) | undefined;
 	let embeddedStatusKind: StatusIndicatorKind | undefined;
 	const statusTransition = new StatusTransition();
-	let workingFadeTimer: ReturnType<typeof setInterval> | undefined;
-	const stopWorkingFadeTimer = (): void => {
-		if (workingFadeTimer) clearInterval(workingFadeTimer);
-		workingFadeTimer = undefined;
+	let statusAnimationTimer: ReturnType<typeof setInterval> | undefined;
+	const stopStatusAnimationTimer = (): void => {
+		if (statusAnimationTimer) clearInterval(statusAnimationTimer);
+		statusAnimationTimer = undefined;
 	};
 
 	const syncEmbed = (): void => {
@@ -80,15 +94,69 @@ export default function (pi: ExtensionAPI) {
 		ctx.ui.setEditorComponent(factory);
 	};
 
+	// pi-topping slides its loader's response model out only while this bar hosts the loader.
+	const announceEmbed = (embedded: boolean): void => pi.events.emit(WORKING_STATUS_EMBED_CHANNEL, { embedded });
+
 	const requestRender = () => activeTui?.requestRender();
 	builder.setRequestRender(requestRender);
-	const startWorkingFadeTimer = (): void => {
-		if (workingFadeTimer) return;
-		workingFadeTimer = setInterval(() => {
+
+	// pi-topping-compact's latest progress broadcast, while one is active.
+	let compaction: CompactionProgressView | undefined;
+	// The boxed render failed and the plain editor is showing instead.
+	let boxRenderFailed = false;
+	// A COMPACTION_PROGRESS_CHANNEL payload with active: true that parseCompactionProgress
+	// could not parse: pi-topping-compact and this bar have drifted out of sync. Latched, not
+	// reset, since the mismatch persists until the extensions reload.
+	let compactionPayloadRejected = false;
+	const hostingCompaction = (): boolean =>
+		activeCtx !== undefined && !boxRenderFailed && !compactionPayloadRejected && hostsCompactionProgress(state.effective);
+	// The last verdict sent on COMPACTION_EMBED_CHANNEL, so the channel only fires on change.
+	let announcedCompactionEmbed: boolean | undefined;
+	const announceCompactionEmbed = (hosts: boolean): void => {
+		if (hosts === announcedCompactionEmbed) return;
+		announcedCompactionEmbed = hosts;
+		pi.events.emit(COMPACTION_EMBED_CHANNEL, { embedded: hosts });
+	};
+	// Whether the compaction stand-ins would have room, cached by (innerWidth, effective) since
+	// it only changes on a resize or a settings change, not every frame: measured against a
+	// representative view rather than a fixed cell count, so it tracks the border/symbol/
+	// transparency settings and which segments are toggled on instead of assuming defaults.
+	const noGapColor = (s: string) => s;
+	let compactionFitCache: { innerWidth: number; effective: EffectiveStatusLineSettings; fits: boolean } | undefined;
+	const compactionWouldFit = (innerWidth: number, ctx: SegmentContext, effective: EffectiveStatusLineSettings): boolean => {
+		if (compactionFitCache && compactionFitCache.innerWidth === innerWidth && compactionFitCache.effective === effective) {
+			return compactionFitCache.fits;
+		}
+		const compactionRightIds = bottomRightSegments(effective, true);
+		let fitRight: readonly StatusLineSegmentId[] = compactionRightIds;
+		buildStatusLine(
+			innerWidth,
+			{ ...ctx, compaction: COMPACTION_FIT_PROBE },
+			effective,
+			noGapColor,
+			{ left: effective.bottomLeftSegments, right: compactionRightIds },
+			{ col: 3, row: 0 },
+			{ onFit: fit => { fitRight = fit.right; } },
+		);
+		const fits = Object.values(COMPACTION_STAND_INS).some(id => fitRight.includes(id));
+		compactionFitCache = { innerWidth, effective, fits };
+		return fits;
+	};
+	pi.events.on(COMPACTION_PROGRESS_CHANNEL, data => {
+		compaction = parseCompactionProgress(data);
+		if (compaction === undefined && typeof data === "object" && data !== null && (data as { active?: unknown }).active === true) {
+			compactionPayloadRejected = true;
+			announceCompactionEmbed(false);
+		}
+		requestRender();
+	});
+	const startStatusAnimationTimer = (): void => {
+		if (statusAnimationTimer) return;
+		statusAnimationTimer = setInterval(() => {
 			requestRender();
-			if (!statusTransition.pending(Date.now())) stopWorkingFadeTimer();
-		}, WORKING_FADE_FRAME_MS);
-		workingFadeTimer.unref?.();
+			if (!statusTransition.pending(Date.now())) stopStatusAnimationTimer();
+		}, STATUS_ANIMATION_FRAME_MS);
+		statusAnimationTimer.unref?.();
 	};
 
 	const rateMonitor = new TokenRateMonitor(requestRender);
@@ -144,7 +212,10 @@ export default function (pi: ExtensionAPI) {
 		editor: { borderColor?: (str: string) => string },
 	): string[] => {
 		const ctx = activeCtx;
-		if (!ctx || width < MIN_BOXED_WIDTH) return innerRender(width);
+		if (!ctx || width < MIN_BOXED_WIDTH) {
+			announceCompactionEmbed(false);
+			return innerRender(width);
+		}
 
 		// Chrome totals 6 cells on every row, so the bar and the inner text rows
 		// share one width budget. Border rows split it 3/3 (╭── … ──╮); text rows
@@ -159,11 +230,20 @@ export default function (pi: ExtensionAPI) {
 		if ((editor as unknown as { autocompleteState?: unknown }).autocompleteState) {
 			while (bottomIdx > 0 && !isBorderRow(lines[bottomIdx] ?? "")) bottomIdx--;
 		}
-		if (lines.length < 3 || bottomIdx < 2) return innerRender(width);
+		if (lines.length < 3 || bottomIdx < 2) {
+			announceCompactionEmbed(false);
+			return innerRender(width);
+		}
 
 		const hint = stripAnsi(lines[bottomIdx] ?? "").match(/[↑↓] \d+ more/)?.[0] ?? "";
 		const effective = state.effective;
-		const include = effective.includes;
+		// The layout truncates the status to fit, so it is rendered at full width here.
+		const live = effective.embedWorkingStatus ? embeddedWorkingStatus?.(innerWidth) || undefined : undefined;
+		const frame = statusTransition.resolve(live, embeddedStatusKind, Date.now());
+		if (frame.pending) startStatusAnimationTimer();
+		const compactionCandidate = hostingCompaction();
+		let include = effective.includes;
+		if (frame.status !== undefined) include = { ...include, git: false, pr: false };
 		const segCtx = builder.build(innerWidth, effective.segmentOptions, include, hint || undefined);
 		// borderColor is assigned by the host after the factory returns — read late.
 		const border = editor.borderColor ?? ((s: string) => s);
@@ -177,10 +257,6 @@ export default function (pi: ExtensionAPI) {
 			bottomIdx,
 			flat: border,
 		});
-		// The layout truncates the status to fit, so it is rendered at full width here.
-		const live = effective.embedWorkingStatus ? embeddedWorkingStatus?.(innerWidth) || undefined : undefined;
-		const frame = statusTransition.resolve(live, embeddedStatusKind, Date.now());
-		if (frame.pending) startWorkingFadeTimer();
 		const bar = buildStatusLine(
 			innerWidth,
 			{ ...segCtx, workingStatus: frame.status },
@@ -193,6 +269,7 @@ export default function (pi: ExtensionAPI) {
 			{ col: 3, row: 0 },
 			{
 				leftFade: frame.leftFade,
+				workingReveal: frame.reveal,
 				workingEllipsis: isMessageKind(frame.kind) ? "…" : "",
 			},
 		);
@@ -203,17 +280,43 @@ export default function (pi: ExtensionAPI) {
 				painters.paint(i, 0, box.vertical) + " " + (lines[i] ?? "") + "   " + painters.paint(i, width - 1, box.vertical),
 			);
 		}
-		const bottomBar = buildStatusLine(
-			innerWidth,
-			segCtx,
-			effective,
-			painters.gapColor,
-			{
-				left: effective.bottomLeftSegments,
-				right: effective.bottomRightSegments,
-			},
-			{ col: 3, row: bottomIdx },
-		);
+		// Swap in the stand-ins only once there is live progress to show, and only once they
+		// actually fit; otherwise pi's own stats and the context graph stay put, same as when
+		// the setting is off. Fit is checked against the real bar while a compaction is running,
+		// so the fallback below never trims further than that render already decided; before one
+		// starts, the cached probe stands in so the handshake doesn't wait on real progress.
+		const plainBottomBar = (): string =>
+			buildStatusLine(
+				innerWidth,
+				segCtx,
+				effective,
+				painters.gapColor,
+				{ left: effective.bottomLeftSegments, right: effective.bottomRightSegments },
+				{ col: 3, row: bottomIdx },
+			);
+		const activeCompaction = compactionCandidate ? compaction : undefined;
+		let compactionHostable: boolean;
+		let bottomBar: string;
+		if (activeCompaction === undefined) {
+			compactionHostable = compactionCandidate && compactionWouldFit(innerWidth, segCtx, effective);
+			bottomBar = plainBottomBar();
+		} else {
+			const compactionRightIds = bottomRightSegments(effective, true);
+			let fitRight: readonly StatusLineSegmentId[] = compactionRightIds;
+			const hostedBar = buildStatusLine(
+				innerWidth,
+				{ ...segCtx, compaction: activeCompaction },
+				effective,
+				painters.gapColor,
+				{ left: effective.bottomLeftSegments, right: compactionRightIds },
+				{ col: 3, row: bottomIdx },
+				{ onFit: fit => { fitRight = fit.right; } },
+			);
+			const shown = Object.values(COMPACTION_STAND_INS).some(id => fitRight.includes(id));
+			compactionHostable = shown;
+			bottomBar = shown ? hostedBar : plainBottomBar();
+		}
+		announceCompactionEmbed(compactionHostable);
 		out.push(...renderBoxRowIfVisible(painters, bottomBar, bottomIdx, width, box.bottomLeft, box.bottomRight));
 		for (let i = bottomIdx + 1; i < lines.length; i++) {
 			out.push(`  ${lines[i]}`);
@@ -251,20 +354,21 @@ export default function (pi: ExtensionAPI) {
 				activeEditor = own;
 				editor = own;
 			}
+			announceEmbed(hostsWorkingStatus(activeEditor));
+			// A fresh editor retries the boxed path.
+			boxRenderFailed = false;
 			const innerRender = editor.render.bind(editor);
-			let boxRenderFailed = false;
 			editor.render = width => {
 				if (boxRenderFailed) return innerRender(width);
 				try {
 					return renderBoxed(innerRender, width, editor);
 				} catch (err) {
-					if (!boxRenderFailed) {
-						boxRenderFailed = true;
-						activeCtx?.ui.notify(
-							`Statusline render failed, using plain editor: ${err instanceof Error ? err.message : String(err)}`,
-							"error",
-						);
-					}
+					boxRenderFailed = true;
+					announceCompactionEmbed(false);
+					activeCtx?.ui.notify(
+						`Statusline render failed, using plain editor: ${err instanceof Error ? err.message : String(err)}`,
+						"error",
+					);
 					return innerRender(width);
 				}
 			};
@@ -393,9 +497,12 @@ export default function (pi: ExtensionAPI) {
 		activeEditor = undefined;
 		embeddedWorkingStatus = undefined;
 		embeddedStatusKind = undefined;
-		stopWorkingFadeTimer();
+		announceEmbed(false);
+		stopStatusAnimationTimer();
 		statusTransition.reset();
+		compaction = undefined;
 		activeTui = undefined;
 		activeCtx = undefined;
+		announceCompactionEmbed(false);
 	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@underactive/pi-topping-statusline",
-	"version": "0.2.1",
+	"version": "0.2.2",
 	"description": "oh-my-pi's powerline statusline as a pi extension with some customizations",
 	"keywords": [
 		"pi-package",

package/src/compaction-embed.ts

@@ -0,0 +1,62 @@
+/**
+ * pi-topping-compact's compaction progress, hosted in the bottom bar.
+ *
+ * The two extensions talk over pi's extension event bus. This extension
+ * announces on COMPACTION_EMBED_CHANNEL whether its bottom bar has room for the
+ * progress; pi-topping-compact broadcasts snapshots on COMPACTION_PROGRESS_CHANNEL
+ * only while it does, and ends with `{ active: false }` so pi's stats and the
+ * context graph return the moment the compaction finishes. Its completion
+ * result still appears above the editor, in pi-topping-compact's own widget.
+ */
+import { COMPACTION_STAND_INS } from "./settings.js";
+import { hexToFgAnsi } from "./theme.js";
+import type { CompactionProgressView, EffectiveStatusLineSettings } from "./types.js";
+
+/** Announced as `{ embedded: boolean }`. Shared with pi-topping-compact. */
+export const COMPACTION_EMBED_CHANNEL = "pi-topping-statusline:compaction-progress-embedded";
+
+/** Carries a CompactionProgressView plus `active: true`, or `{ active: false }`. Shared with pi-topping-compact. */
+export const COMPACTION_PROGRESS_CHANNEL = "pi-topping-compact:compaction-progress";
+
+const isFiniteNumber = (value: unknown): value is number => typeof value === "number" && Number.isFinite(value);
+
+/** The view in a broadcast, or undefined when it reports no active compaction or is malformed. */
+export function parseCompactionProgress(data: unknown): CompactionProgressView | undefined {
+	if (typeof data !== "object" || data === null || Array.isArray(data)) return undefined;
+	const { active, bar, percent, tokensBefore, contextWindow, elapsedMs } = data as Record<string, unknown>;
+	if (active !== true || typeof bar !== "string") return undefined;
+	if (
+		!isFiniteNumber(percent) ||
+		!isFiniteNumber(tokensBefore) ||
+		!isFiniteNumber(contextWindow) ||
+		!isFiniteNumber(elapsedMs)
+	) {
+		return undefined;
+	}
+	return { bar, percent, tokensBefore, contextWindow, elapsedMs };
+}
+
+/** Whether the bottom bar has somewhere to put the progress: the setting is on and a segment it stands in for is shown. */
+export function hostsCompactionProgress(effective: EffectiveStatusLineSettings): boolean {
+	return (
+		effective.embedCompactionProgress &&
+		effective.bottomRightSegments.some((id) => COMPACTION_STAND_INS[id] !== undefined)
+	);
+}
+
+/** pi-topping-compact's phosphor bar as it looks with a third of the context left to compact. */
+const FIT_PROBE_BAR = `${hexToFgAnsi("#72f1b8")}${"\u258b".repeat(7)}\x1b[39m\x1b[2m${hexToFgAnsi("#266446")}${"\u2591".repeat(13)}\x1b[22m\x1b[39m`;
+
+/**
+ * A representative hosted compaction (66% usage, 35% still to go, so 47% summarized), used to
+ * measure whether the stand-in segments have room before any real progress has broadcast, and
+ * shown in the settings preview. Real figures vary in digit count, but this stands in for a
+ * typical session without committing to a worst case that would starve the rest of the bar.
+ */
+export const COMPACTION_FIT_PROBE: CompactionProgressView = {
+	bar: FIT_PROBE_BAR,
+	percent: 47,
+	tokensBefore: 86_000,
+	contextWindow: 131_072,
+	elapsedMs: 16_300,
+};

package/src/context-graph.ts

@@ -17,10 +17,10 @@ const cellColor = (percent: number, contextWindow: number): string =>
 export function renderContextGraph(
 	percent: number,
 	contextWindow: number,
-	opts: { usedTokens?: number; labelColor?: string; showBar?: boolean; showStats?: boolean } = {},
+	opts: { usedTokens: number; labelColor: string; showBar: boolean; showStats: boolean; estimated: boolean },
 ): string {
 	const parts: string[] = [];
-	if (opts.showBar !== false) {
+	if (opts.showBar) {
 		const filled = Math.min(CELLS, Math.max(0, Math.round((percent * CELLS) / 100)));
 		let bar = "";
 		let prevColor = "";
@@ -38,11 +38,11 @@ export function renderContextGraph(
 		bar += "\x1b[39m";
 		parts.push(bar);
 	}
-	if (opts.showStats !== false) {
+	if (opts.showStats) {
 		// Label wears pi's own footer-stats color so it reads as part of that run;
 		// the threshold gradient still lives in the cells.
-		const text = formatContextUsage(percent, contextWindow, opts.usedTokens);
-		parts.push(opts.labelColor ? `${opts.labelColor}${text}\x1b[39m` : theme.fg("muted", text));
+		const text = formatContextUsage(percent, contextWindow, opts.usedTokens, opts.estimated);
+		parts.push(`${opts.labelColor}${text}\x1b[39m`);
 	}
 	return parts.join(" ");
 }

package/src/context-thresholds.ts

@@ -1,4 +1,4 @@
-/** Ported verbatim from oh-my-pi status-line/context-thresholds.ts. */
+/** Ported from oh-my-pi status-line/context-thresholds.ts; formatContextUsage adds the `~` estimate marker. */
 import type { StatusColor } from "./theme.js";
 import { formatNumber } from "./utils.js";
 
@@ -62,11 +62,15 @@ export function formatContextUsage(
 	contextPercent: number | null | undefined,
 	contextWindow: number,
 	usedTokens?: number,
+	estimated = false,
 ): string {
+	// An estimate wears "~" so it reads as one until pi's own figure arrives.
+	const about = estimated ? "~" : "";
 	if (!Number.isFinite(contextWindow) || contextWindow <= 0) {
-		return `${formatNumber(usedTokens ?? 0)}/?`;
+		return `${about}${formatNumber(usedTokens ?? 0)}/?`;
 	}
-	const pct = contextPercent === null || contextPercent === undefined ? "?" : `${contextPercent.toFixed(1)}%`;
+	const pct =
+		contextPercent === null || contextPercent === undefined ? "?" : `${about}${contextPercent.toFixed(1)}%`;
 	return `${pct}/${formatNumber(contextWindow)}`;
 }
 

package/src/context.ts

@@ -8,7 +8,12 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { isDeepStrictEqual } from "node:util";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import {
+	buildSessionContext,
+	estimateTokens,
+	type ExtensionAPI,
+	type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
 import { FADE_SHADE_COUNT } from "./theme.js";
 import type { FeedDisplayState, SegmentContext, SegmentIncludes, StatusLineSegmentOptions, TokenRateDisplay } from "./types.js";
 import { feedKey } from "./utils.js";
@@ -55,16 +60,32 @@ export function getFeedDisplayState(changedAt: number, now: number): FeedDisplay
 	};
 }
 
-function deriveContextUsage(ctx: ExtensionContext | undefined): {
+interface ContextUsageFigures {
 	contextWindow: number;
-	tokens: number | undefined;
+	tokens: number;
 	percent: number | null;
-} {
-	const usage = ctx?.getContextUsage();
-	const contextWindow = usage?.contextWindow ?? ctx?.model?.contextWindow ?? 0;
-	const tokens = usage?.tokens ?? undefined;
-	const percent = usage ? usage.percent : null;
-	return { contextWindow, tokens, percent };
+	/** The figures are pi's estimate of a freshly compacted context, not a measurement. */
+	estimated: boolean;
+}
+
+/** One post-compaction estimate, keyed by session and leaf so it is rebuilt only when the branch grows. */
+interface ContextEstimate {
+	key: string;
+	tokens: number | undefined;
+}
+
+/**
+ * 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.
+ */
+export function estimateCompactedContextTokens(sessionManager: ExtensionContext["sessionManager"]): number {
+	let tokens = 0;
+	for (const message of buildSessionContext(sessionManager.getBranch(), sessionManager.getLeafId()).messages) {
+		tokens += estimateTokens(message);
+	}
+	return tokens;
 }
 
 function parseGitStatus(porcelain: string): GitStatusCounts {
@@ -119,6 +140,8 @@ export class SegmentContextBuilder {
 	#feedTimer: ReturnType<typeof setTimeout> | undefined;
 	#feedTimerAt: number | undefined;
 
+	#contextEstimate: ContextEstimate | undefined;
+
 	constructor(pi: ExtensionAPI) {
 		this.#pi = pi;
 	}
@@ -146,6 +169,7 @@ export class SegmentContextBuilder {
 		this.#feedsScannedAt = 0;
 		this.#feedsScannedRef = undefined;
 		this.#clearFeedLifecycle();
+		this.#contextEstimate = undefined;
 		if (this.#repoCwd !== ctx.cwd) {
 			this.#resetGitState();
 			this.#repoCwd = ctx.cwd;
@@ -307,7 +331,7 @@ export class SegmentContextBuilder {
 	#refreshFeeds(customTypes: readonly string[], now: number): void {
 		this.#feedsScannedAt = now;
 		this.#feedData = emptyFeedData();
-		const entries = this.#ctx?.sessionManager?.getEntries();
+		const entries = this.#ctx?.sessionManager.getEntries();
 		if (!entries) return;
 		const pending = new Set(customTypes);
 		for (let i = entries.length - 1; i >= 0 && pending.size > 0; i--) {
@@ -414,6 +438,40 @@ export class SegmentContextBuilder {
 		}
 	}
 
+	// ── context usage ────────────────────────────────────────────────────────
+
+	/**
+	 * pi reports usage as unknown between a compaction and the next assistant
+	 * response. Rather than let the graph vanish for that stretch, this fills it
+	 * with pi's own estimate of the compacted context, flagged as such, until
+	 * pi's measured figure arrives.
+	 */
+	#deriveContextUsage(ctx: ExtensionContext | undefined): ContextUsageFigures {
+		const usage = ctx?.getContextUsage();
+		const contextWindow = usage?.contextWindow ?? ctx?.model?.contextWindow ?? 0;
+		if (!ctx || !usage || usage.tokens !== null || contextWindow <= 0) {
+			return { contextWindow, tokens: usage?.tokens ?? 0, percent: usage ? usage.percent : null, estimated: false };
+		}
+		const tokens = this.#estimateContextTokens(ctx);
+		if (tokens === undefined) return { contextWindow, tokens: 0, percent: null, estimated: false };
+		return { contextWindow, tokens, percent: (tokens / contextWindow) * 100, estimated: true };
+	}
+
+	#estimateContextTokens(ctx: ExtensionContext): number | undefined {
+		const sessionManager = ctx.sessionManager;
+		try {
+			const key = `${sessionManager.getSessionId()}\0${sessionManager.getLeafId() ?? ""}`;
+			if (this.#contextEstimate?.key !== key) {
+				this.#contextEstimate = { key, tokens: undefined };
+				this.#contextEstimate.tokens = estimateCompactedContextTokens(sessionManager);
+			}
+			return this.#contextEstimate.tokens;
+		} catch {
+			// The session plumbing is pi's; a surprise there costs the estimate, not the frame.
+			return undefined;
+		}
+	}
+
 	// ── snapshot ─────────────────────────────────────────────────────────────
 
 	build(
@@ -455,17 +513,18 @@ export class SegmentContextBuilder {
 				}
 			: undefined;
 
-		const { contextWindow, tokens, percent: contextPercent } = deriveContextUsage(ctx);
+		const { contextWindow, tokens, percent: contextPercent, estimated } = this.#deriveContextUsage(ctx);
 
 		return {
 			options,
 			model,
 			thinkingLevel: this.#pi.getThinkingLevel(),
 			cwd: ctx?.cwd ?? process.cwd(),
-			sessionName: ctx?.sessionManager?.getSessionName(),
+			sessionName: ctx?.sessionManager.getSessionName(),
 			contextPercent,
-			contextTokens: tokens ?? 0,
+			contextTokens: tokens,
 			contextWindow,
+			contextEstimated: estimated,
 			git: {
 				branch: include.git || include.pr ? this.#branch : null,
 				status: include.git ? this.#gitStatus : null,