@underactive/pi-topping-statusline 0.2.1 → 0.2.3

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

@@ -1,21 +1,56 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { STATUS_HOLD_MS, StatusTransition, WORKING_FADE_MS } from "../working-status.ts";
-
-test("a live status is returned verbatim without scheduling repaints", () => {
+import {
+	STATUS_HOLD_MS,
+	STATUS_SLIDE_MS,
+	type StatusIndicatorKind,
+	StatusTransition,
+	WORKING_FADE_MS,
+} from "../working-status.ts";
+
+/** Show a status early enough that its slide-out has finished by `at`. */
+function settle(transition: StatusTransition, status: string, kind: StatusIndicatorKind | undefined, at: number): void {
+	transition.resolve(status, kind, at - STATUS_SLIDE_MS);
+	transition.resolve(status, kind, at);
+}
+
+test("a status appearing over the user's segments slides out, then settles verbatim", () => {
 	const transition = new StatusTransition();
 
 	assert.deepEqual(transition.resolve("⠙ Working", "working", 1_000), {
 		status: "⠙ Working",
 		kind: "working",
+		reveal: 0,
+		pending: true,
+	});
+	// Spinner frames change the text mid-slide without restarting it.
+	const early = transition.resolve("⠹ Working", "working", 1_000 + STATUS_SLIDE_MS / 4).reveal ?? -1;
+	const late = transition.resolve("⠸ Working", "working", 1_000 + (STATUS_SLIDE_MS * 3) / 4).reveal ?? -1;
+	assert.ok(0 < early && early < late && late < 1, "reveal grows monotonically");
+	assert.equal(transition.pending(1_000 + STATUS_SLIDE_MS - 1), true);
+
+	assert.deepEqual(transition.resolve("⠼ Working", "working", 1_000 + STATUS_SLIDE_MS), {
+		status: "⠼ Working",
+		kind: "working",
 		pending: false,
 	});
-	assert.equal(transition.pending(1_000), false);
+	assert.equal(transition.pending(1_000 + STATUS_SLIDE_MS), false);
+});
+
+test("a status cleared mid-slide keeps sliding through its hold", () => {
+	const transition = new StatusTransition();
+	transition.resolve("⠙ Working", "working", 0);
+
+	const clearedAt = STATUS_SLIDE_MS / 4;
+	const cleared = transition.resolve(undefined, undefined, clearedAt);
+	const held = transition.resolve(undefined, undefined, clearedAt + STATUS_HOLD_MS / 2);
+	assert.equal(held.status, "⠙ Working");
+	assert.ok(0 < (cleared.reveal ?? 1) && (cleared.reveal ?? 1) < (held.reveal ?? 1), "the slide continues");
 });
 
 test("clearing a working status holds it, cross-fades both halves, then settles", () => {
 	const transition = new StatusTransition();
-	transition.resolve("⠙ Working", "working", 1_000);
+	settle(transition, "⠙ Working", "working", 1_000);
 
 	const clearedAt = 2_000;
 	const holdEndsAt = clearedAt + STATUS_HOLD_MS;
@@ -66,7 +101,7 @@ test("clearing a working status holds it, cross-fades both halves, then settles"
 test("clearing message-style statuses holds them and then cuts without a fade", () => {
 	for (const kind of ["compaction", "retry"] as const) {
 		const transition = new StatusTransition();
-		transition.resolve(`⠙ ${kind}`, kind, 100);
+		settle(transition, `⠙ ${kind}`, kind, 100);
 		assert.deepEqual(transition.resolve(undefined, undefined, 200), {
 			status: `⠙ ${kind}`,
 			kind,
@@ -87,7 +122,7 @@ test("clearing message-style statuses holds them and then cuts without a fade",
 
 test("a new status during the hold cuts in immediately and cancels the exit", () => {
 	const transition = new StatusTransition();
-	transition.resolve("⠙ Working", "working", 1_000);
+	settle(transition, "⠙ Working", "working", 1_000);
 	transition.resolve(undefined, undefined, 1_100);
 
 	assert.deepEqual(transition.resolve("⠹ Retrying", "retry", 1_200), {
@@ -100,7 +135,7 @@ test("a new status during the hold cuts in immediately and cancels the exit", ()
 
 test("a new status during the fade cuts in immediately and cancels the exit", () => {
 	const transition = new StatusTransition();
-	transition.resolve("⠙ Working", "working", 0);
+	settle(transition, "⠙ Working", "working", 0);
 	transition.resolve(undefined, undefined, 100);
 	const fading = transition.resolve(undefined, undefined, 300);
 	assert.equal(fading.status, "⠙ Working");
@@ -114,6 +149,21 @@ test("a new status during the fade cuts in immediately and cancels the exit", ()
 	assert.equal(transition.pending(1_000), false);
 });
 
+test("a status arriving after the fade's outgoing half slides out again", () => {
+	const transition = new StatusTransition();
+	settle(transition, "⠙ Working", "working", 0);
+	transition.resolve(undefined, undefined, 100);
+
+	const incomingAt = 100 + STATUS_HOLD_MS + WORKING_FADE_MS / 2;
+	assert.equal(transition.resolve(undefined, undefined, incomingAt).status, undefined);
+	assert.deepEqual(transition.resolve("⠹ Retrying", "retry", incomingAt + 1), {
+		status: "⠹ Retrying",
+		kind: "retry",
+		reveal: 0,
+		pending: true,
+	});
+});
+
 test("a working-to-compaction handoff across the hold never yields an empty status", () => {
 	const transition = new StatusTransition();
 	const frames = [
@@ -143,7 +193,7 @@ test("an undefined kind preserves the pre-0.86 working fade", () => {
 	});
 });
 
-test("reset clears live and exiting state", () => {
+test("reset clears live, exiting, and sliding state", () => {
 	const transition = new StatusTransition();
 	transition.resolve("⠙ Working", "working", 10);
 	transition.resolve(undefined, undefined, 20);
@@ -155,4 +205,5 @@ test("reset clears live and exiting state", () => {
 		pending: false,
 	});
 	assert.equal(transition.pending(21), false);
+	assert.equal(transition.resolve("⠹ Working", "working", 22).reveal, 0, "the next status slides from the start");
 });

package/src/tests/working.test.ts

@@ -1,20 +1,22 @@
 /**
  * Contracts for the opt-in embedded status indicator: the `working` segment
- * passes pi's pre-rendered status through verbatim, the top-left group swaps
- * everything but the Pi symbol for it while a stream is live, and the layout
- * truncates it before any other left segment is dropped. The caller chooses
- * whether truncated status text uses an ellipsis.
+ * passes pi's pre-rendered status through verbatim, the top-left group keeps
+ * the Pi symbol and configured model details while a stream is live, and the
+ * layout truncates it before any other left segment is dropped. The caller
+ * chooses whether truncated status text uses an ellipsis, and how far an
+ * appearing status has slid out ahead of the model details.
  */
 import assert from "node:assert/strict";
 import test from "node:test";
 import { visibleWidth } from "@earendil-works/pi-tui";
+import { stripAnsi } from "../footer.ts";
 import { buildStatusLine } from "../layout.ts";
 import { SEGMENTS } from "../segments.ts";
+import { getSeparator } from "../separators.ts";
 import { resolveEffectiveSettings, topLeftSegments } from "../settings.ts";
 import { easeFade, theme } from "../theme.ts";
 import type { SegmentContext, StatusLineSegmentId } from "../types.ts";
 
-const stripAnsi = (text: string) => text.replace(/\x1b\[[0-9;]*m/g, "");
 const noGap = (s: string) => s;
 
 const EFFECTIVE = resolveEffectiveSettings({ transparent: true });
@@ -49,15 +51,20 @@ test("working segment is invisible when idle", () => {
 	assert.equal(SEGMENTS.working.render(ctxWith("")).visible, false);
 });
 
-test("topLeftSegments keeps pi first and swaps the rest while streaming", () => {
-	assert.deepEqual(topLeftSegments(EFFECTIVE, true), ["pi", "working"]);
+test("topLeftSegments keeps pi and model details around the working status", () => {
+	assert.deepEqual(topLeftSegments(EFFECTIVE, true), ["pi", "working", "model"]);
 	assert.deepEqual(topLeftSegments(EFFECTIVE, false), EFFECTIVE.leftSegments);
-	assert.ok(EFFECTIVE.leftSegments.length > 2, "default left group has more than pi + one segment");
+	assert.ok(EFFECTIVE.leftSegments.includes("path"), "default path segment is suppressed while working");
 });
 
-test("topLeftSegments yields only working when the pi symbol is off", () => {
+test("topLeftSegments respects disabled pi and model details", () => {
 	const noPi = resolveEffectiveSettings({ segments: { pi: false } });
-	assert.deepEqual(topLeftSegments(noPi, true), ["working"]);
+	assert.deepEqual(topLeftSegments(noPi, true), ["working", "model"]);
+
+	const noModelDetails = resolveEffectiveSettings({
+		segments: { model: false, provider: false, thinking: false },
+	});
+	assert.deepEqual(topLeftSegments(noModelDetails, true), ["pi", "working"]);
 });
 
 test("embedWorkingStatus resolves off by default and on when set", () => {
@@ -65,39 +72,98 @@ test("embedWorkingStatus resolves off by default and on when set", () => {
 	assert.equal(resolveEffectiveSettings({ embedWorkingStatus: true }).embedWorkingStatus, true);
 });
 
-test("top bar renders pi symbol, separator, then the status", () => {
-	const bar = buildStatusLine(80, ctxWith("⠙ Mulling 28 tps"), EFFECTIVE, noGap, {
-		left: ["pi", "working"],
+test("top bar renders pi symbol, status, then model details", () => {
+	const ctx = ctxWith("⠙ Mulling 28 tps");
+	ctx.model = { name: "GPT-5.6 Luna", id: "gpt-5.6", provider: "openai-codex", reasoning: true };
+	ctx.thinkingLevel = "max";
+	const effective = resolveEffectiveSettings({
+		transparent: true,
+		segments: { model: true, provider: true, thinking: true },
+	});
+	ctx.options = effective.segmentOptions;
+	const bar = buildStatusLine(120, ctx, effective, noGap, {
+		left: topLeftSegments(effective, true),
 		right: [],
 	});
 	const plain = stripAnsi(bar);
 	const piAt = plain.indexOf(theme.icon.pi);
 	const statusAt = plain.indexOf("⠙ Mulling 28 tps");
+	const modelAt = plain.indexOf("GPT-5.6 Luna");
 	assert.ok(piAt >= 0, "pi symbol present");
 	assert.ok(statusAt > piAt, "status follows the pi symbol");
-	assert.equal(visibleWidth(bar), 80);
+	assert.ok(modelAt > statusAt, "model details follow the status");
+	assert.ok(plain.includes("openai-codex"), "provider remains visible");
+	assert.ok(plain.includes("max"), "thinking level remains visible");
+	assert.equal(visibleWidth(bar), 120);
 });
 
-test("narrow widths truncate the status without an ellipsis and keep the pi symbol", () => {
+test("narrow widths truncate the status before dropping model details", () => {
 	const status = "⠙ Mulling ⣾⣿⣿⣿⣿⣿⣾⣾  28 tps · 11s · ↓ 316 tokens";
-	const bar = buildStatusLine(20, ctxWith(status), EFFECTIVE, noGap, { left: ["pi", "working"], right: [] });
+	const ctx = ctxWith(status);
+	ctx.model = { name: "Luna", id: "luna", provider: "openai-codex", reasoning: false };
+	const bar = buildStatusLine(24, ctx, EFFECTIVE, noGap, {
+		left: topLeftSegments(EFFECTIVE, true),
+		right: [],
+	});
 	const plain = stripAnsi(bar);
 	assert.ok(plain.includes(theme.icon.pi), "pi symbol survives");
 	assert.ok(plain.includes("⠙ Mull"), "status head is kept");
+	assert.ok(plain.includes("Luna"), "model details survive");
 	assert.ok(!plain.includes("…"), "no ellipsis");
 	assert.ok(!plain.includes("tokens"), "status tail is cut");
-	assert.equal(visibleWidth(bar), 20);
+	assert.equal(visibleWidth(bar), 24);
+});
+
+test("opaque bars restore the group background after truncating the status", () => {
+	const status = "⠙ Mulling ⣾⣿⣿⣿⣿⣿⣾⣾  28 tps · 11s · ↓ 316 tokens";
+	const ctx = ctxWith(status);
+	ctx.model = { name: "Luna", id: "luna", provider: "openai-codex", reasoning: false };
+	const opaque = resolveEffectiveSettings({ transparent: false });
+	ctx.options = opaque.segmentOptions;
+	const bar = buildStatusLine(24, ctx, opaque, noGap, {
+		left: topLeftSegments(opaque, true),
+		right: [],
+	});
+	const plain = stripAnsi(bar);
+	assert.ok(plain.includes("⠙ Mull"), "status head is kept");
+	assert.ok(!plain.includes("tokens"), "status tail is cut");
+	const reset = theme.getBgAnsi() + theme.getFgAnsi("text");
+	const resetAt = bar.indexOf(reset);
+	const modelAt = bar.indexOf("Luna");
+	assert.ok(resetAt >= 0, "group background and text color are re-asserted after the truncated status");
+	assert.ok(resetAt < modelAt, "the reset lands before the model text");
+});
+
+test("overflow drops trailing model details before touching the live status", () => {
+	const status = "⠙ Working";
+	const ctx = ctxWith(status);
+	ctx.model = { name: "GPT-5.6 Luna", id: "gpt-5.6", provider: "openai-codex", reasoning: true };
+	ctx.thinkingLevel = "max";
+	const effective = resolveEffectiveSettings({
+		transparent: true,
+		segments: { model: true, provider: true, thinking: true },
+	});
+	ctx.options = effective.segmentOptions;
+	const bar = buildStatusLine(34, ctx, effective, noGap, {
+		left: topLeftSegments(effective, true),
+		right: [],
+	});
+	const plain = stripAnsi(bar);
+	assert.ok(plain.includes(theme.icon.pi), "pi symbol survives");
+	assert.ok(plain.includes("⠙ Working"), "the spinner status survives untruncated");
+	assert.ok(!plain.includes("GPT-5.6"), "model details are dropped to protect the live status");
+	assert.equal(visibleWidth(bar), 34);
 });
 
 test("workingEllipsis marks truncated prose without changing the bar width", () => {
 	const status = "⠙ Context overflow detected, Auto-compacting... (esc to cancel)";
-	for (const width of [12, 16, 24, 40, 60]) {
+	for (const width of [24, 40, 60]) {
 		const bar = buildStatusLine(
 			width,
 			ctxWith(status),
 			EFFECTIVE,
 			noGap,
-			{ left: ["pi", "working"], right: [] },
+			{ left: topLeftSegments(EFFECTIVE, true), right: [] },
 			{ col: 0, row: 0 },
 			{ workingEllipsis: "…" },
 		);
@@ -113,7 +179,7 @@ test("a long ANSI-styled status never exceeds the bar width", () => {
 	const status = `\x1b[38;2;10;20;30m⠙ ${"Working ".repeat(30)}\x1b[39m`;
 	for (const width of [12, 16, 24, 40, 60]) {
 		const bar = buildStatusLine(width, ctxWith(status), EFFECTIVE, noGap, {
-			left: ["pi", "working"],
+			left: topLeftSegments(EFFECTIVE, true),
 			right: [],
 		});
 		assert.equal(visibleWidth(bar), width, `width ${width}`);
@@ -122,7 +188,10 @@ test("a long ANSI-styled status never exceeds the bar width", () => {
 });
 
 test("the status drops entirely rather than the pi symbol when there is no room", () => {
-	const bar = buildStatusLine(4, ctxWith("⠙ Working"), EFFECTIVE, noGap, { left: ["pi", "working"], right: [] });
+	const bar = buildStatusLine(4, ctxWith("⠙ Working"), EFFECTIVE, noGap, {
+		left: topLeftSegments(EFFECTIVE, true),
+		right: [],
+	});
 	const plain = stripAnsi(bar);
 	assert.ok(plain.includes(theme.icon.pi));
 	assert.ok(!plain.includes("⠙"));
@@ -144,18 +213,144 @@ test("easeFade is monotonic and pinned at both ends", () => {
 	assert.ok(easeFade(0.25) < easeFade(0.5) && easeFade(0.5) < easeFade(0.75));
 });
 
-test("leftFade recolors the tail but not the pi symbol or the bar width", () => {
+test("leftFade recolors the working status but not pi or model details", () => {
 	const status = "\x1b[38;2;10;200;30m⠙ Working\x1b[39m";
-	const groups: { left: StatusLineSegmentId[]; right: StatusLineSegmentId[] } = { left: ["pi", "working"], right: [] };
+	const ctx = ctxWith(status);
+	ctx.model = { name: "Luna", id: "luna", provider: "openai-codex", reasoning: false };
+	const groups: { left: StatusLineSegmentId[]; right: StatusLineSegmentId[] } = {
+		left: topLeftSegments(EFFECTIVE, true),
+		right: [],
+	};
 	const origin = { col: 0, row: 0 };
-	const build = (fade?: number) =>
-		buildStatusLine(60, ctxWith(status), EFFECTIVE, noGap, groups, origin, { leftFade: fade });
+	const build = (fade?: number) => buildStatusLine(60, ctx, EFFECTIVE, noGap, groups, origin, { leftFade: fade });
 	const solid = build();
 	const faded = build(0.2);
+	const renderedModel = SEGMENTS.model.render(ctx);
 	assert.equal(visibleWidth(faded), 60);
 	assert.equal(stripAnsi(faded), stripAnsi(solid));
 	assert.ok(!faded.includes("10;200;30"), "status color blended");
+	assert.ok(renderedModel.visible && faded.includes(renderedModel.content), "model styling untouched");
 	const piPrefix = (bar: string) => bar.slice(0, bar.indexOf(theme.icon.pi));
 	assert.equal(piPrefix(faded), piPrefix(solid), "pi symbol styling untouched");
 	assert.equal(build(1), solid);
 });
+
+test("leftFade does not recolor the right group", () => {
+	const ctx = ctxWith("⠙ Working");
+	ctx.sessionName = "stable-session";
+	const renderedSession = SEGMENTS.session_name.render(ctx);
+	const bar = buildStatusLine(
+		80,
+		ctx,
+		EFFECTIVE,
+		noGap,
+		{ left: topLeftSegments(EFFECTIVE, true), right: ["session_name"] },
+		{ col: 0, row: 0 },
+		{ leftFade: 0.2 },
+	);
+	assert.ok(renderedSession.visible && bar.includes(renderedSession.content), "right group styling untouched");
+});
+
+/** A top bar mid-slide, with the status revealed by `reveal` and Luna as the model. */
+function slidingBar(
+	status: string,
+	reveal: number | undefined,
+	{ width = 60, effective = EFFECTIVE, leftFade }: {
+		width?: number;
+		effective?: ReturnType<typeof resolveEffectiveSettings>;
+		leftFade?: number;
+	} = {},
+): string {
+	const ctx = ctxWith(status);
+	ctx.options = effective.segmentOptions;
+	ctx.model = { name: "Luna", id: "luna", provider: "openai-codex", reasoning: false };
+	ctx.sessionName = "stable-session";
+	return buildStatusLine(
+		width,
+		ctx,
+		effective,
+		noGap,
+		{ left: topLeftSegments(effective, true), right: ["session_name"] },
+		{ col: 0, row: 0 },
+		{ leftFade, workingReveal: reveal },
+	);
+}
+
+test("workingReveal slides the status out behind the pi symbol, pushing model details right", () => {
+	const settled = slidingBar("⠙ Working...", undefined);
+	const piAt = stripAnsi(settled).indexOf(theme.icon.pi);
+	assert.equal(slidingBar("⠙ Working...", 1), settled);
+	assert.ok(!stripAnsi(slidingBar("⠙ Working...", 0)).includes("⠙"), "nothing has emerged at the start");
+
+	let modelAt = -1;
+	for (let step = 0; step <= 30; step++) {
+		const bar = slidingBar("⠙ Working...", step / 30);
+		const plain = stripAnsi(bar);
+		assert.equal(visibleWidth(bar), 60, `width at step ${step}`);
+		assert.equal(plain.indexOf(theme.icon.pi), piAt, `pi symbol stays put at step ${step}`);
+		const at = plain.indexOf("Luna");
+		assert.ok(at >= modelAt, `model details never move left at step ${step}`);
+		modelAt = at;
+	}
+	assert.equal(modelAt, stripAnsi(settled).indexOf("Luna"), "model details end where they settle");
+});
+
+test("the status's tail emerges first, led by its trailing separator", () => {
+	const status = "⠙ Working...";
+	const sep = getSeparator(EFFECTIVE.separator).left;
+	const unitWidth = visibleWidth(status) + visibleWidth(sep) + 2;
+	const frame = (shown: number) => stripAnsi(slidingBar(status, shown / unitWidth));
+	const model = `${theme.icon.model} Luna`;
+	assert.ok(frame(2).includes(`${theme.icon.pi} ${sep} ${sep} ${model}`), "separator first");
+	assert.ok(frame(7).includes(`${theme.icon.pi} ${sep} g... ${sep} ${model}`), "then the status's tail");
+	assert.ok(!frame(7).includes("Workin"), "the head is still hidden");
+});
+
+test("without model details the status slides out alone after the pi separator", () => {
+	const effective = resolveEffectiveSettings({
+		transparent: true,
+		segments: { model: false, provider: false, thinking: false },
+	});
+	const sep = getSeparator(effective.separator).left;
+	assert.ok(!stripAnsi(slidingBar("⠙ Working...", 0, { effective })).includes(sep), "no separator yet");
+	const plain = stripAnsi(slidingBar("⠙ Working...", 4 / 12, { effective }));
+	assert.ok(plain.includes(`${theme.icon.pi} ${sep} g...`), "tail follows the pi separator");
+	assert.ok(!plain.includes("Workin"), "the head is still hidden");
+});
+
+test("the slide keeps the overflow decided for the fully revealed status", () => {
+	// At 40 cells the settled status leaves no room for the session name, even
+	// though a partly revealed one would.
+	assert.ok(!stripAnsi(slidingBar("⠙ Working...", undefined, { width: 40 })).includes("stable-session"));
+	for (let step = 0; step <= 20; step++) {
+		const bar = slidingBar("⠙ Working...", step / 20, { width: 40 });
+		assert.ok(!stripAnsi(bar).includes("stable-session"), `right group stays dropped at step ${step}`);
+	}
+});
+
+test("sliding frames keep the bar width with opaque caps, wide glyphs, and truncation", () => {
+	const opaque = resolveEffectiveSettings({ transparent: false });
+	const statuses = ["⠙ Working...", "🌑 Working", `\x1b[38;2;10;20;30m⠙ ${"Working ".repeat(10)}\x1b[39m`];
+	for (const effective of [EFFECTIVE, opaque]) {
+		for (const status of statuses) {
+			for (const width of [24, 60]) {
+				for (let step = 0; step <= 20; step++) {
+					const bar = slidingBar(status, step / 20, { width, effective });
+					assert.equal(visibleWidth(bar), width, `${JSON.stringify(status)} at width ${width}, step ${step}`);
+				}
+			}
+		}
+	}
+});
+
+test("a status fading mid-slide blends its emerged tail but not model details", () => {
+	const status = "\x1b[38;2;10;200;30m⠙ Working...\x1b[39m";
+	const bar = slidingBar(status, 0.5, { leftFade: 0.2 });
+	const ctx = ctxWith(status);
+	ctx.model = { name: "Luna", id: "luna", provider: "openai-codex", reasoning: false };
+	const renderedModel = SEGMENTS.model.render(ctx);
+	assert.ok(stripAnsi(bar).includes("..."), "part of the status has emerged");
+	assert.ok(!bar.includes("10;200;30"), "emerged status blended");
+	assert.ok(renderedModel.visible && bar.includes(renderedModel.content), "model styling untouched");
+	assert.equal(visibleWidth(bar), 60);
+});

package/src/token-rate.ts

@@ -29,7 +29,7 @@ const EMA_ALPHA = 0.4;
 class StreamingWordCounter {
 	#inWordByStream = new Map<string, boolean>();
 
-	count(text: string, stream = "default"): number {
+	count(text: string, stream: string): number {
 		let inWord = this.#inWordByStream.get(stream) ?? false;
 		let count = 0;
 		for (let i = 0; i < text.length; i++) {

package/src/types.ts

@@ -19,7 +19,9 @@ export type StatusLineSegmentId =
 	| "feeds"
 	| "context_graph"
 	| "scroll_hint"
-	| "working";
+	| "working"
+	| "compaction_info"
+	| "compaction_graph";
 
 /**
  * A feed the statusline subscribes to: custom session entries published by
@@ -80,6 +82,8 @@ export interface StatusLineSettings {
 	nvidiaGreenAnimation?: boolean;
 	/** Render pi's status spinners in the top bar instead of their own row. */
 	embedWorkingStatus?: boolean;
+	/** Host pi-topping-compact's compaction progress in the bottom bar while a compaction runs. */
+	embedCompactionProgress?: boolean;
 }
 
 /** Resolved per-segment render options; resolveEffectiveSettings always fills them. */
@@ -115,6 +119,7 @@ export interface EffectiveStatusLineSettings {
 	nvidiaGreenBorder: boolean;
 	nvidiaGreenAnimation: boolean;
 	embedWorkingStatus: boolean;
+	embedCompactionProgress: boolean;
 	includes: SegmentIncludes;
 }
 
@@ -128,10 +133,15 @@ export interface SegmentContext {
 	thinkingLevel: string;
 	cwd: string;
 	sessionName: string | undefined;
-	/** Context usage percent, or null when unknown (e.g. right after compaction). */
+	/** Context usage percent, or null when unknown (no model, or a session pi cannot size). */
 	contextPercent: number | null;
 	contextTokens: number;
 	contextWindow: number;
+	/**
+	 * True while contextPercent and contextTokens are pi's estimate of a freshly
+	 * compacted context, shown until pi measures the next response.
+	 */
+	contextEstimated?: boolean;
 	git: {
 		branch: string | null;
 		status: { staged: number; unstaged: number; untracked: number } | null;
@@ -148,6 +158,11 @@ export interface SegmentContext {
 	 * this frame. Absent while no status indicator is active.
 	 */
 	workingStatus?: string;
+	/**
+	 * pi-topping-compact's live compaction progress, while its bar and figures
+	 * stand in for the context graph and pi's stats in the bottom-right group.
+	 */
+	compaction?: CompactionProgressView;
 	/** Live tok/s display state, when this frame needs it. */
 	tokenRate: TokenRateDisplay | undefined;
 	/**
@@ -164,6 +179,17 @@ export interface SegmentContext {
 	feedDisplayState?: Record<string, FeedDisplayState>;
 }
 
+/** One broadcast from pi-topping-compact: its bar, pre-rendered, plus the snapshot it was drawn from. */
+export interface CompactionProgressView {
+	/** The 20-cell bar, pre-rendered and pre-colored by pi-topping-compact with fg-only resets. */
+	bar: string;
+	/** How much of the context has been summarized so far, 0..100. */
+	percent: number;
+	tokensBefore: number;
+	contextWindow: number;
+	elapsedMs: number;
+}
+
 export type FeedPhase = "active" | "fading" | "hidden";
 
 export interface FeedDisplayState {

package/src/working-status-embed.ts

@@ -0,0 +1,15 @@
+import type { CustomEditor } from "@earendil-works/pi-coding-agent";
+
+/**
+ * Event-bus channel on which this extension announces, as `{ embedded: boolean }`,
+ * whether its bar hosts Pi's working status. pi-topping slides its loader's response
+ * model out only while it does. Shared with pi-topping.
+ */
+export const WORKING_STATUS_EMBED_CHANNEL = "pi-topping-statusline:working-status-embedded";
+
+type EmbeddingEditor = Partial<Pick<CustomEditor, "embedWorkingStatus" | "setWorkingStatusIndicator">>;
+
+/** Whether an editor this extension built draws the host's working status in its bar. */
+export function hostsWorkingStatus(editor: EmbeddingEditor | undefined): boolean {
+	return editor?.embedWorkingStatus === true && typeof editor.setWorkingStatusIndicator === "function";
+}