@underactive/pi-topping-statusline 0.2.6 → 0.2.7

package/README.md

@@ -111,9 +111,9 @@ An appearing status slides out from behind the Pi symbol's chevron over 300ms, p
 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.
+message-style spinners cut after the hold. While the bar hosts the working status, it notifies
+pi-topping. Pi-topping's loader slides its response model out the same way; elsewhere, 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
@@ -122,20 +122,24 @@ 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
+**Embed compaction progress** (on by default) tracks pi's built-in summarizer for `/compact`,
+threshold, overflow, and extension-triggered compactions that use it. Pi runs
+`session_before_compact` handlers in sequence, so if an earlier-loaded extension computes the
+summary in its own handler, the bar appears only after that handler returns. In the bottom-right
+group, a green progress bar takes the place of the context graph, followed
+by the tokens being compacted against the context window, `86K/131K (66%)`. The bar starts just
+below that usage and drains as the summary progresses. In place of pi's stats, `47% summarized ·
+16.3s` shows the share summarized so far and the time elapsed. The bar and its label follow the
+Context bar and Context stats toggles. The summarized share is a time-based estimate: pi does not
+expose the summarizer's progress, so it starts at 10%, eases up to 86%, and reaches 100% only
+when pi completes. At completion, the empty bar and `100% summarized` hold for a moment. Then pi's stats and the
+context graph return, and the graph shows the compacted context as a `~` estimate until the next
+response. If the compaction fails or is cancelled, the usual segments return at once on pi 0.84.3
+and later; earlier hosts keep the bar until the next prompt. The bottom bar does not change when
+the setting is off, when Pi stats, Context bar, and Context
+stats are all off, or when the terminal is too narrow for the stand-ins. In every case pi's own
+compaction indicator still shows, in its own row or, with Embed status spinners on, in the top
+bar. While the setting is on, focusing its row in the settings preview shows the bottom bar
 mid-compaction.
 
 ## Segments
@@ -148,19 +152,19 @@ accent while active, held 1.5s, faded 0.5s, then a dim `--- tok/s` placeholder;
 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), 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`
+`context_graph` while a compaction 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.
+summary plus the kept messages sized by pi's estimator, marked with `~` (`~9.2%/131K`). 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.
+When the terminal narrows: right segments drop first, then an embedded status is truncated
+(the model details after it drop only if the status would otherwise vanish), then the path
+shrinks (to ~8 cells), then left segments drop end-first — the path is always the last to go.
 
 ## Feeds
 
@@ -257,6 +261,7 @@ settings TUI.
 
 - Other editor-replacing extensions are wrapped rather than raced — their editor renders inside this box — but ones that draw their own bar or chrome will clash visually.
 - The palette is OMP's **dark** theme; light terminal themes will look off.
+- pi-topping-compact is no longer needed: the bar tracks compactions from pi's own events. If it is still installed, its above-editor widget shows alongside the bar, so uninstall it.
 
 ## Development
 

package/index.ts

@@ -5,9 +5,10 @@
  * packages/coding-agent/src/modes/components/status-line/, MIT). OMP mounts
  * the bar via its editor's setTopBorderProvider. Upstream pi's editor draws
  * plain ─── rows with no corners or sides, so the wrapper re-renders the inner
- * editor 6 columns narrower and rebuilds a full rounded box around its rows:
- * the bar in ╭─ … ─╮, │ sides on every text row, and a dedicated ╰─ … ─╯
- * bottom border carrying configurable left/right segment groups. Upstream's
+ * editor 6 columns narrower and rebuilds a full box around its rows in the
+ * configured border style (╭─ … ─╮ when rounded): the bar in the top border, side
+ * glyphs on every text row, and a dedicated bottom border carrying configurable
+ * left/right segment groups. Upstream's
  * own bottom border row is dropped.
  *
  * ctx.ui.setEditorComponent is a single last-writer-wins slot that other
@@ -26,13 +27,8 @@ 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 { hostsCompactionProgress } from "./src/compaction-embed.js";
+import { CompactionMonitor } from "./src/compaction-progress.js";
 import { SegmentContextBuilder } from "./src/context.js";
 import {
 	collapseFooterLayoutSlot,
@@ -48,12 +44,7 @@ import { registerSettingsCommand } from "./src/settings-menu.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 type { 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"]>>;
@@ -100,56 +91,10 @@ export default function (pi: ExtensionAPI) {
 	const requestRender = () => activeTui?.requestRender();
 	builder.setRequestRender(requestRender);
 
-	// 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();
-	});
+		activeCtx !== undefined && !boxRenderFailed && hostsCompactionProgress(state.effective);
 	const startStatusAnimationTimer = (): void => {
 		if (statusAnimationTimer) return;
 		statusAnimationTimer = setInterval(() => {
@@ -163,6 +108,11 @@ export default function (pi: ExtensionAPI) {
 	rateMonitor.attach(pi);
 	builder.setTokenRateProvider(() => rateMonitor.getDisplay());
 
+	const compactionMonitor = new CompactionMonitor(() => {
+		if (hostingCompaction()) requestRender();
+	});
+	compactionMonitor.attach(pi);
+
 	// The active border colorizer is visible independently of whether its phase
 	// is animated. Stopping the timer preserves the current live phase.
 	const rainbow = new RainbowBorder();
@@ -213,7 +163,6 @@ export default function (pi: ExtensionAPI) {
 	): string[] => {
 		const ctx = activeCtx;
 		if (!ctx || width < MIN_BOXED_WIDTH) {
-			announceCompactionEmbed(false);
 			return innerRender(width);
 		}
 
@@ -231,7 +180,6 @@ export default function (pi: ExtensionAPI) {
 			while (bottomIdx > 0 && !isBorderRow(lines[bottomIdx] ?? "")) bottomIdx--;
 		}
 		if (lines.length < 3 || bottomIdx < 2) {
-			announceCompactionEmbed(false);
 			return innerRender(width);
 		}
 
@@ -241,7 +189,6 @@ export default function (pi: ExtensionAPI) {
 		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);
@@ -280,11 +227,8 @@ export default function (pi: ExtensionAPI) {
 				painters.paint(i, 0, box.vertical) + " " + (lines[i] ?? "") + "   " + painters.paint(i, width - 1, box.vertical),
 			);
 		}
-		// 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.
+		// Swap in the stand-ins only while a compaction runs, and only when they actually fit;
+		// otherwise pi's own stats and the context graph stay put, same as when the setting is off.
 		const plainBottomBar = (): string =>
 			buildStatusLine(
 				innerWidth,
@@ -294,11 +238,9 @@ export default function (pi: ExtensionAPI) {
 				{ left: effective.bottomLeftSegments, right: effective.bottomRightSegments },
 				{ col: 3, row: bottomIdx },
 			);
-		const activeCompaction = compactionCandidate ? compaction : undefined;
-		let compactionHostable: boolean;
+		const activeCompaction = hostingCompaction() ? compactionMonitor.view() : undefined;
 		let bottomBar: string;
 		if (activeCompaction === undefined) {
-			compactionHostable = compactionCandidate && compactionWouldFit(innerWidth, segCtx, effective);
 			bottomBar = plainBottomBar();
 		} else {
 			const compactionRightIds = bottomRightSegments(effective, true);
@@ -313,10 +255,8 @@ export default function (pi: ExtensionAPI) {
 				{ 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]}`);
@@ -364,7 +304,6 @@ export default function (pi: ExtensionAPI) {
 					return renderBoxed(innerRender, width, editor);
 				} catch (err) {
 					boxRenderFailed = true;
-					announceCompactionEmbed(false);
 					activeCtx?.ui.notify(
 						`Statusline render failed, using plain editor: ${err instanceof Error ? err.message : String(err)}`,
 						"error",
@@ -457,6 +396,7 @@ export default function (pi: ExtensionAPI) {
 		activeCtx = ctx;
 		builder.attach(ctx);
 		rateMonitor.enable();
+		compactionMonitor.enable();
 		syncBorderAnimation();
 		ensureInstalled();
 		syncEmbed();
@@ -473,6 +413,7 @@ export default function (pi: ExtensionAPI) {
 
 	pi.on("session_shutdown", () => {
 		rateMonitor.disable();
+		compactionMonitor.disable();
 		builder.dispose();
 		if (borderTimer) {
 			clearInterval(borderTimer);
@@ -500,9 +441,7 @@ export default function (pi: ExtensionAPI) {
 		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.6",
+	"version": "0.2.7",
 	"description": "oh-my-pi's powerline statusline as a pi extension with some customizations",
 	"keywords": [
 		"pi-package",
@@ -45,9 +45,9 @@
 		"@earendil-works/pi-tui": "*"
 	},
 	"devDependencies": {
-		"@earendil-works/pi-ai": "1.0.3",
-		"@earendil-works/pi-coding-agent": "1.0.3",
-		"@earendil-works/pi-tui": "1.0.3",
+		"@earendil-works/pi-ai": "1.1.0",
+		"@earendil-works/pi-coding-agent": "1.1.0",
+		"@earendil-works/pi-tui": "1.1.0",
 		"@types/node": "^22.0.0",
 		"typescript": "^5.7.0"
 	}

package/src/box.ts

@@ -1,6 +1,7 @@
 /**
  * Shared box-chrome painting for the live editor box (index.ts) and the
- * settings-menu preview, so the 3/2/+2 row geometry has one definition.
+ * settings-menu preview, so the 6-cell border-row chrome (corner + 2-cell run,
+ * bar, pad + 2-cell run + corner) has one definition.
  *
  * Gradient mode colors each glyph by its perimeter-walk position; otherwise
  * the caller's flat painter wraps whole runs in one escape sequence, which
@@ -33,23 +34,6 @@ export function makeBoxPainters(opts: {
 	const perimeter = perimeterLength(width, bottomIdx);
 	const paint = (row: number, col: number, ch: string): string =>
 		colorizerOn ? colorizer.colorChar(ch, perimeterPosition(row, col, width, bottomIdx), perimeter) : flat(ch);
-	const horizRun = (row: number, startCol: number, count: number): string => {
-		if (!colorizerOn) return flat(box.horizontal.repeat(count));
-		let out = "";
-		let runPrefix: string | undefined;
-		let runChars = "";
-		for (let k = 0; k < count; k++) {
-			const prefix = colorizer.prefix(perimeterPosition(row, startCol + k, width, bottomIdx), perimeter);
-			if (runPrefix !== undefined && prefix !== runPrefix) {
-				out += `${runPrefix}${runChars}\x1b[39m`;
-				runChars = "";
-			}
-			runPrefix = prefix;
-			runChars += box.horizontal;
-		}
-		if (runPrefix !== undefined) out += `${runPrefix}${runChars}\x1b[39m`;
-		return out;
-	};
 	const gapColor = (str: string, startCol: number, row: number): string => {
 		if (!colorizerOn) return flat(str);
 		let out = "";
@@ -68,6 +52,8 @@ export function makeBoxPainters(opts: {
 		if (runPrefix !== undefined) out += `${runPrefix}${runChars}\x1b[39m`;
 		return out;
 	};
+	const horizRun = (row: number, startCol: number, count: number): string =>
+		gapColor(box.horizontal.repeat(count), startCol, row);
 	return { paint, horizRun, gapColor };
 }
 

package/src/compaction-bar.ts

@@ -0,0 +1,58 @@
+/**
+ * The compaction bar, drawn with the same cells and trough glyphs as the context graph.
+ */
+import { CELLS, FILLED, TROUGH } from "./context-graph.js";
+import { detectColorMode, mixRgb, rgbToFgAnsi } from "./theme.js";
+import type { ColorMode } from "./theme.js";
+
+const COMET_SWEEP_MS = 2_000;
+const COMET_START_PADDING_CELLS = 2;
+const COMET_END_PADDING_CELLS = 6;
+const COMET_HALF_WIDTH_CELLS = 1.5;
+const COMET_TRAIL_DECAY_CELLS = 3.2;
+
+const DEEP_GREEN: readonly [number, number, number] = [11, 61, 32];
+const BASE_GREEN: readonly [number, number, number] = [114, 241, 184];
+const LIGHT_GREEN: readonly [number, number, number] = [185, 248, 217];
+const TROUGH_GREEN: readonly [number, number, number] = [38, 100, 70];
+
+function cosineFalloff(distance: number, halfWidth: number): number {
+	if (distance >= halfWidth) return 0;
+	return 0.5 * (1 + Math.cos((Math.PI * distance) / halfWidth));
+}
+
+function normalizeElapsedMs(elapsedMs: number | undefined): number {
+	return Number.isFinite(elapsedMs) && elapsedMs !== undefined && elapsedMs > 0 ? elapsedMs : 0;
+}
+
+function renderCometCell(position: number, filled: number, elapsedMs: number, mode: ColorMode): string {
+	const phase = (elapsedMs % COMET_SWEEP_MS) / COMET_SWEEP_MS;
+	const head = filled + COMET_START_PADDING_CELLS - phase * (filled + COMET_END_PADDING_CELLS);
+	const behind = position - head;
+	const trail = behind >= 0 ? Math.exp(-behind / COMET_TRAIL_DECAY_CELLS) : 0;
+	const crest = cosineFalloff(Math.abs(position - head), COMET_HALF_WIDTH_CELLS);
+	const intensity = Math.min(1, Math.max(trail * 0.82, crest));
+	const trailBase = mixRgb(DEEP_GREEN, BASE_GREEN, 0.62 + 0.38 * trail);
+	const color = mixRgb(trailBase, LIGHT_GREEN, intensity * 0.9);
+	const emphasized = crest > 0.25;
+	return `${emphasized ? "\x1b[1m" : ""}${rgbToFgAnsi(...color, mode)}${FILLED}${emphasized ? "\x1b[22m" : ""}`;
+}
+
+export function renderCompactionBar(
+	percent: number,
+	opts: { mode?: ColorMode; shimmerElapsedMs?: number } = {},
+): string {
+	const mode = opts.mode ?? detectColorMode();
+	const clamped = Number.isFinite(percent) ? Math.min(100, Math.max(0, percent)) : 0;
+	const filled = Math.min(CELLS, Math.max(0, Math.round((clamped * CELLS) / 100)));
+	const elapsedMs = normalizeElapsedMs(opts.shimmerElapsedMs);
+	let bar = "";
+	for (let i = 0; i < filled; i++) {
+		bar += renderCometCell(i, filled, elapsedMs, mode);
+	}
+	if (filled < CELLS) {
+		bar += `\x1b[39m\x1b[2m${rgbToFgAnsi(...TROUGH_GREEN, mode)}${TROUGH.repeat(CELLS - filled)}\x1b[22m`;
+	}
+	bar += "\x1b[39m";
+	return bar;
+}

package/src/compaction-embed.ts

@@ -1,41 +1,10 @@
 /**
- * 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.
+ * Whether the bottom bar can host compaction progress, and the sample view the settings preview shows.
  */
+import { renderCompactionBar } from "./compaction-bar.js";
 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 (
@@ -44,19 +13,19 @@ export function hostsCompactionProgress(effective: EffectiveStatusLineSettings):
 	);
 }
 
-/** 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.
+ * A representative hosted compaction (86K of a 131K window is 66% usage; at 47% summarized the
+ * bar still holds 35% of the window), 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.
+ * The bar renders when this function is called, so it uses pi's current color depth.
  */
-export const COMPACTION_FIT_PROBE: CompactionProgressView = {
-	bar: FIT_PROBE_BAR,
-	percent: 47,
-	tokensBefore: 86_000,
-	contextWindow: 131_072,
-	elapsedMs: 16_300,
-};
+export function compactionPreviewView(): CompactionProgressView {
+	return {
+		bar: renderCompactionBar(35),
+		percent: 47,
+		tokensBefore: 86_000,
+		contextWindow: 131_072,
+		elapsedMs: 16_300,
+	};
+}

package/src/compaction-progress.ts

@@ -0,0 +1,129 @@
+/**
+ * Tracks pi's built-in summarizer from pi's session events. The percent is a time-based estimate,
+ * because pi does not expose the summarizer's stream.
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { renderCompactionBar } from "./compaction-bar.js";
+import type { CompactionProgressView } from "./types.js";
+
+const COMPACTION_TICK_MS = 100;
+const COMPACTION_COMPLETE_HOLD_MS = 900;
+const SUMMARIZING_START_PERCENT = 10;
+const SUMMARIZING_SPAN_PERCENT = 80;
+const SUMMARIZING_TAU_MS = 25_000;
+const SUMMARIZING_RATIO_CAP = 0.95;
+
+/**
+ * Starts at 10% and eases toward 90%, capped at 86% (START + SPAN × RATIO_CAP)
+ * after about 75s; README.md and CHANGELOG.md quote the 10% and 86% figures.
+ */
+export function estimateCompactionPercent(elapsedMs: number): number {
+	const elapsed = Number.isFinite(elapsedMs) && elapsedMs >= 0 ? elapsedMs : 0;
+	const ratio = Math.min(SUMMARIZING_RATIO_CAP, 1 - Math.exp(-elapsed / SUMMARIZING_TAU_MS));
+	return SUMMARIZING_START_PERCENT + SUMMARIZING_SPAN_PERCENT * ratio;
+}
+
+type CompactionRun = {
+	startedAt: number;
+	tokensBefore: number;
+	contextWindow: number;
+	completedAt: number | undefined;
+};
+
+export class CompactionMonitor {
+	#requestRender: () => void;
+	#now: () => number;
+	#holdMs: number;
+	#enabled = false;
+	#run: CompactionRun | undefined;
+	#tickTimer: ReturnType<typeof setInterval> | undefined;
+	#holdTimer: ReturnType<typeof setTimeout> | undefined;
+
+	constructor(requestRender: () => void, options: { now?: () => number; holdMs?: number } = {}) {
+		this.#requestRender = requestRender;
+		this.#now = options.now ?? (() => performance.now());
+		this.#holdMs = options.holdMs ?? COMPACTION_COMPLETE_HOLD_MS;
+	}
+
+	attach(pi: ExtensionAPI): void {
+		pi.on("session_before_compact", (event, ctx) => {
+			if (!this.#enabled) return;
+			this.#clearTimers();
+			this.#run = {
+				startedAt: this.#now(),
+				tokensBefore: event.preparation.tokensBefore,
+				contextWindow: ctx.getContextUsage()?.contextWindow ?? ctx.model?.contextWindow ?? 0,
+				completedAt: undefined,
+			};
+			this.#tickTimer = setInterval(this.#requestRender, COMPACTION_TICK_MS);
+			this.#tickTimer.unref?.();
+			this.#requestRender();
+		});
+		pi.on("session_compact", () => {
+			if (!this.#run || this.#run.completedAt !== undefined) return;
+			this.#run.completedAt = this.#now();
+			this.#stopTickTimer();
+			this.#holdTimer = setTimeout(() => this.#endRun(), this.#holdMs);
+			this.#holdTimer.unref?.();
+			this.#requestRender();
+		});
+		pi.on("session_compact_failed", () => this.#endRun());
+		// pi < 0.84.3 has no session_compact_failed; the next agent run is the only sign a run died.
+		pi.on("agent_start", () => {
+			if (this.#run && this.#run.completedAt === undefined) this.#endRun();
+		});
+	}
+
+	enable(): void {
+		this.#enabled = true;
+	}
+
+	disable(): void {
+		this.#enabled = false;
+		this.#endRun();
+	}
+
+	view(): CompactionProgressView | undefined {
+		const run = this.#run;
+		if (!run) return undefined;
+		const elapsed = (run.completedAt ?? this.#now()) - run.startedAt;
+		const percent = run.completedAt !== undefined ? 100 : estimateCompactionPercent(elapsed);
+		const usage =
+			Number.isFinite(run.tokensBefore) && run.tokensBefore > 0 &&
+			Number.isFinite(run.contextWindow) && run.contextWindow > 0
+				? Math.min(100, Math.max(0, (run.tokensBefore / run.contextWindow) * 100))
+				: 0;
+		const remaining = usage * (1 - percent / 100);
+		return {
+			bar: renderCompactionBar(remaining, {
+				shimmerElapsedMs: run.completedAt === undefined ? elapsed : undefined,
+			}),
+			percent,
+			tokensBefore: run.tokensBefore,
+			contextWindow: run.contextWindow,
+			elapsedMs: elapsed,
+		};
+	}
+
+	#endRun(): void {
+		this.#clearTimers();
+		if (!this.#run) return;
+		this.#run = undefined;
+		this.#requestRender();
+	}
+
+	#clearTimers(): void {
+		this.#stopTickTimer();
+		if (this.#holdTimer) {
+			clearTimeout(this.#holdTimer);
+			this.#holdTimer = undefined;
+		}
+	}
+
+	#stopTickTimer(): void {
+		if (this.#tickTimer) {
+			clearInterval(this.#tickTimer);
+			this.#tickTimer = undefined;
+		}
+	}
+}

package/src/context-graph.ts

@@ -7,9 +7,9 @@
 import { formatContextUsage, getContextUsageLevel, getContextUsageThemeColor } from "./context-thresholds.js";
 import { theme } from "./theme.js";
 
-const CELLS = 20;
-const FILLED = "\u258b";
-const TROUGH = "\u2591";
+export const CELLS = 20;
+export const FILLED = "\u258b";
+export const TROUGH = "\u2591";
 
 const cellColor = (percent: number, contextWindow: number): string =>
 	theme.getFgAnsi(getContextUsageThemeColor(getContextUsageLevel(percent, contextWindow)));