@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/pi-zentui/test/live-metadata-lifecycle.integration.test.ts

@@ -0,0 +1,963 @@
+import { stripVTControlCharacters } from "node:util";
+import { type EventBus, SessionManager, type Theme } from "@earendil-works/pi-coding-agent";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const runtime = vi.hoisted(() => ({
+	config: undefined as import("../extensions/zentui/config").PolishedTuiConfig | undefined,
+	hooks: undefined as Record<string, (...args: never[]) => unknown> | undefined,
+}));
+vi.mock("../extensions/zentui/config", async (importOriginal) => {
+	const actual = await importOriginal<typeof import("../extensions/zentui/config")>();
+	return {
+		...actual,
+		loadConfig() {
+			return runtime.config;
+		},
+		saveEditorComponentPatch(patch: object) {
+			Object.assign(runtime.config?.components.editor ?? {}, patch);
+			return runtime.config;
+		},
+		saveFooterComponentPatch(patch: object) {
+			Object.assign(runtime.config?.components.footer ?? {}, patch);
+			return runtime.config;
+		},
+		saveWorkingLineComponentPatch(patch: object) {
+			Object.assign(runtime.config?.components.workingLine ?? {}, patch);
+			return runtime.config;
+		},
+		savePolishedEditorStylePatch(patch: object) {
+			Object.assign(runtime.config?.components.editor.styles.opencode ?? {}, patch);
+			return runtime.config;
+		},
+		saveMinimalistEditorStylePatch(patch: object) {
+			Object.assign(runtime.config?.components.editor.styles.minimalist ?? {}, patch);
+			return runtime.config;
+		},
+	};
+});
+vi.mock("../extensions/zentui/settings-command", () => ({
+	registerZentuiSettingsCommand(_pi: unknown, hooks: typeof runtime.hooks) {
+		runtime.hooks = hooks;
+	},
+}));
+
+import { mergeConfig } from "../extensions/zentui/config";
+import {
+	ZENTUI_VARIABLE_CAPABILITY_EVENT,
+	ZENTUI_VARIABLE_EVENT,
+} from "../extensions/zentui/custom-variables";
+import zentui, { type ZentuiHost } from "../extensions/zentui/index";
+import { createOmpUiAdapter } from "../extensions/zentui/omp-ui";
+
+type Editor = {
+	render(width: number): string[];
+	getText(): string;
+	setText(text: string): void;
+	getExpandedText(): string;
+};
+type Factory = (...args: never[]) => Editor;
+type Handler = (event: unknown, ctx: unknown) => unknown;
+const head = "a".repeat(40);
+function harness(mode = "tui", omp = false, host: ZentuiHost = {}) {
+	const exec = vi.fn(async (command: string, args: string[]) => {
+		const result = (stdout: string) => ({ code: 0, stdout });
+		if (command === "git") {
+			if (args[1] === "--show-toplevel") return result("/project\n/project/.git\n");
+			if (args[0] === "symbolic-ref") return result("feature\n");
+			if (args[0] === "remote") return result("origin\tgit@github.com:owner/project.git (fetch)\n");
+			if (args[1] === "--verify") return result(head);
+		}
+		if (command === "gh" && args[0] === "repo")
+			return result(
+				JSON.stringify({
+					nameWithOwner: "owner/project",
+					url: "https://github.com/owner/project",
+					defaultBranchRef: { name: "main" },
+				}),
+			);
+		if (command === "gh" && args[0] === "pr")
+			return result(
+				JSON.stringify({
+					number: 42,
+					url: "https://github.com/owner/project/pull/42",
+					headRefOid: head,
+					state: "OPEN",
+					statusCheckRollup: [{ status: "COMPLETED", conclusion: "SUCCESS" }],
+				}),
+			);
+		throw new Error("unexpected fixture command");
+	});
+	const handlers = new Map<string, Handler[]>();
+	const listeners = new Map<string, Set<(value: unknown) => void>>();
+	const events: EventBus = {
+		emit(name, value) {
+			for (const listener of listeners.get(name) ?? []) listener(value);
+		},
+		on(name, listener) {
+			const list = listeners.get(name) ?? new Set();
+			list.add(listener);
+			listeners.set(name, list);
+			return () => list.delete(listener);
+		},
+	};
+	let factory: Factory | undefined;
+	let editor: Editor | undefined;
+	let footer: { render(width: number): string[]; dispose?(): void } | undefined;
+	let text = "retained draft";
+	const requestRender = vi.fn();
+	const theme = {
+		fg: (_color: string, value: string) => value,
+		bold: (value: string) => value,
+		italic: (value: string) => value,
+		getThinkingBorderColor: () => (value: string) => value,
+	} as unknown as Theme;
+	const ui = {
+		theme,
+		getEditorComponent: () => factory,
+		setEditorComponent(value?: Factory) {
+			// The real public Pi setter transfers the current editor text to its replacement.
+			const draft = editor?.getText() ?? text;
+			factory = value;
+			editor = value?.(
+				{ requestRender, terminal: { rows: 40, columns: 140 } } as never,
+				{
+					borderColor: (value: string) => value,
+					selectList: {
+						selectedPrefix: (value: string) => value,
+						selectedText: (value: string) => value,
+						description: (value: string) => value,
+						scrollInfo: (value: string) => value,
+						noMatch: (value: string) => value,
+					},
+				} as never,
+				{} as never,
+			);
+			editor?.setText(draft);
+			text = draft;
+		},
+		getEditorText: () => editor?.getText() ?? text,
+		getExpandedEditorText: () => editor?.getExpandedText() ?? text,
+		setEditorText(value: string) {
+			text = value;
+			editor?.setText(value);
+		},
+		setFooter(value?: (...args: never[]) => NonNullable<typeof footer>) {
+			footer?.dispose?.();
+			footer = value?.(
+				{ requestRender } as never,
+				theme as never,
+				{ getExtensionStatuses: () => new Map(), onBranchChange: () => () => {} } as never,
+			);
+		},
+		setStatus: vi.fn(),
+		setWorkingIndicator: vi.fn(),
+		setWorkingMessage: vi.fn(),
+		setWorkingVisible: vi.fn(),
+	};
+	const adapter = omp ? createOmpUiAdapter(ui as never) : undefined;
+	const ctx = {
+		mode,
+		hasUI: mode === "tui",
+		cwd: "/tmp/zentui-variable-test",
+		ui: adapter?.ui ?? ui,
+		sessionManager: SessionManager.inMemory("/tmp/zentui-variable-test"),
+		model: { id: "test-model", provider: "test", contextWindow: 100_000 },
+		getContextUsage: () => ({ tokens: 1000, contextWindow: 100_000, percent: 1 }),
+		isIdle: () => true,
+	};
+	zentui(
+		{
+			events,
+			registerCommand() {},
+			registerEntryRenderer() {},
+			on(name: string, handler: Handler) {
+				handlers.set(name, [...(handlers.get(name) ?? []), handler]);
+			},
+			getThinkingLevel: () => "off",
+			exec,
+		} as never,
+		host,
+	);
+	return {
+		ctx,
+		ui,
+		exec,
+		events,
+		requestRender,
+		registeredEvents: () => new Set(handlers.keys()),
+		render: (width = 140) => editor?.render(width).join("\n") ?? "",
+		editorText: () => editor?.getText() ?? text,
+		renderFooter: () => footer?.render(100).join("\n") ?? "",
+		async emit(name: string, payload: unknown = {}) {
+			for (const handler of handlers.get(name) ?? []) await handler(payload, ctx);
+			if (name === "session_shutdown") adapter?.dispose();
+		},
+		capability(key = "@scope/usage:quota") {
+			const probe = { supported: false, active: false, key };
+			events.emit(ZENTUI_VARIABLE_CAPABILITY_EVENT, probe);
+			return probe;
+		},
+		publish(value?: string) {
+			events.emit(ZENTUI_VARIABLE_EVENT, { key: "@scope/usage:quota", text: value });
+		},
+		hook(name: string, patch: object) {
+			runtime.hooks?.[name]?.(patch as never, ctx as never);
+		},
+	};
+}
+
+const emptyFormats = {
+	topLeft: "",
+	topMiddle: "",
+	topRight: "",
+	bottomLeft: "",
+	bottomMiddle: "",
+	bottomRight: "",
+};
+beforeEach(() => {
+	vi.useFakeTimers();
+	runtime.config = mergeConfig({
+		projectRefreshIntervalMs: 0,
+		components: {
+			editor: {
+				style: "minimalist",
+				styles: { minimalist: { formats: { ...emptyFormats, topLeft: "$ci $token_rate" } } },
+			},
+			footer: {
+				style: "starship",
+				styles: { starship: { format: "$pr_number $ci $token_rate", responsive: false } },
+			},
+			userMessages: { enabled: false },
+			selectorBorders: { enabled: false },
+			workingLine: { enabled: false },
+		},
+	});
+});
+afterEach(() => {
+	expect(vi.getTimerCount()).toBe(0);
+	vi.useRealTimers();
+	runtime.hooks = undefined;
+});
+async function settle() {
+	for (let i = 0; i < 100; i++) await Promise.resolve();
+}
+async function streaming(h: ReturnType<typeof harness>) {
+	await h.emit("agent_start");
+	await h.emit("turn_start");
+	await h.emit("message_update", {
+		message: { role: "assistant", responseId: "one", usage: { input: 10, output: 10 } },
+	});
+	await vi.advanceTimersByTimeAsync(600);
+	await h.emit("message_update", {
+		message: { role: "assistant", responseId: "one", usage: { input: 10, output: 40 } },
+	});
+}
+describe("live metadata event wiring and owned consumers", () => {
+	it("shares one demanded collector across editor/footer and keeps reads passive", async () => {
+		const h = harness();
+		try {
+			await h.emit("session_start");
+			h.render();
+			await settle();
+			expect(h.render()).toContain("CI passing");
+			expect(h.renderFooter()).toContain("42 CI passing");
+			const calls = h.exec.mock.calls.length;
+			for (let i = 0; i < 5; i++) {
+				h.render();
+				h.renderFooter();
+			}
+			expect(h.exec).toHaveBeenCalledTimes(calls);
+			h.hook("setEditorComponent", { enabled: false });
+			expect(h.renderFooter()).toContain("CI passing");
+			h.ui.setFooter(undefined);
+			await vi.advanceTimersByTimeAsync(0);
+			await settle();
+			expect(vi.getTimerCount()).toBe(0);
+			await vi.advanceTimersByTimeAsync(60_000);
+			expect(h.exec).toHaveBeenCalledTimes(calls);
+		} finally {
+			await h.emit("session_shutdown");
+		}
+	});
+	it.each([
+		"model_select",
+		"session_before_compact",
+		"session_compact",
+		"session_before_switch",
+		"session_tree",
+		"session_start",
+	])("clears Pi retained rate on %s", async (event) => {
+		if (!runtime.config) throw new Error("missing config");
+		runtime.config.components.workingLine.enabled = true;
+		runtime.config.components.workingLine.segments.tokenRate = true;
+		const h = harness();
+		try {
+			await h.emit("session_start");
+			h.render();
+			await streaming(h);
+			await h.emit("message_end", {
+				message: {
+					role: "assistant",
+					responseId: "one",
+					usage: { input: 10, output: 120 },
+					stopReason: "stop",
+				},
+			});
+			expect(h.render()).toContain("200 tok/s avg");
+			expect(h.renderFooter()).toContain("200 tok/s avg");
+			const row = () =>
+				stripVTControlCharacters(
+					(h.ui.setWorkingIndicator.mock.calls.at(-1)?.[0] as { frames?: string[] } | undefined)
+						?.frames?.[0] ?? "",
+				);
+			expect(row()).toContain("50 tok/s");
+			await h.emit(event, { toolCallId: "tool", toolName: "bash" });
+			await vi.advanceTimersByTimeAsync(100);
+			expect(row()).not.toContain("tok/s");
+			expect(h.render()).not.toContain("tok/s");
+			expect(h.renderFooter()).not.toContain("tok/s");
+		} finally {
+			await h.emit("session_shutdown");
+		}
+	});
+	it("averages completed calls including initial wait, excludes tools, and resets only new interactions", async () => {
+		const h = harness();
+		try {
+			await h.emit("session_start");
+			h.render();
+			await h.emit("agent_start");
+			await h.emit("turn_start");
+			expect(h.render()).toContain("— tok/s avg");
+			await vi.advanceTimersByTimeAsync(2000);
+			await h.emit("message_update", {
+				message: { role: "assistant", responseId: "one", usage: { input: 10, output: 10 } },
+			});
+			await vi.advanceTimersByTimeAsync(2000);
+			await h.emit("message_update", {
+				message: { role: "assistant", responseId: "one", usage: { input: 10, output: 40 } },
+			});
+			expect(h.renderFooter()).toContain("— tok/s avg");
+			await h.emit("message_end", {
+				message: {
+					role: "assistant",
+					responseId: "one",
+					usage: { input: 10, output: 120 },
+					stopReason: "toolUse",
+				},
+			});
+			expect(h.render()).toContain("30 tok/s avg");
+			await h.emit("tool_execution_start", { toolCallId: "tool", toolName: "bash" });
+			await vi.advanceTimersByTimeAsync(10000);
+			expect(h.renderFooter()).toContain("30 tok/s avg");
+			await h.emit("tool_execution_end", { toolCallId: "tool" });
+			await h.emit("agent_end");
+			await h.emit("agent_start"); // continuation, not settled
+			await h.emit("turn_start");
+			expect(h.render()).toContain("30 tok/s avg");
+			await vi.advanceTimersByTimeAsync(2000);
+			await h.emit("message_end", {
+				message: {
+					role: "assistant",
+					responseId: "two",
+					usage: { input: 10, output: 180 },
+					stopReason: "stop",
+				},
+			});
+			expect(h.render()).toContain("50 tok/s avg");
+			await h.emit("agent_end");
+			await h.emit("agent_settled");
+			expect(h.renderFooter()).toContain("50 tok/s avg");
+			await h.emit("agent_start");
+			expect(h.render()).toContain("— tok/s avg");
+		} finally {
+			await h.emit("session_shutdown");
+		}
+	});
+	it.each(["completed", "in-flight", "completed-plus-open"])(
+		"partitions metadata average without settled A or lost surviving work (%s)",
+		async (state) => {
+			const h = harness();
+			const expectAverage = (label: string) => {
+				expect(h.render()).toContain(`${label} tok/s avg`);
+				expect(h.renderFooter()).toContain(`${label} tok/s avg`);
+			};
+			const final = (responseId: string, output: number) =>
+				h.emit("message_end", {
+					message: {
+						role: "assistant",
+						responseId,
+						usage: { input: 10, output },
+						stopReason: "stop",
+					},
+				});
+			try {
+				await h.emit("session_start");
+				h.render();
+				await h.emit("agent_start");
+				await h.emit("turn_start");
+				await vi.advanceTimersByTimeAsync(4000);
+				await final("one", 120);
+				await h.emit("agent_end");
+				await h.emit("agent_start");
+				await vi.advanceTimersByTimeAsync(10000);
+				await h.emit("turn_start"); // B starts at 14s
+				if (state === "in-flight") {
+					await vi.advanceTimersByTimeAsync(1000);
+					expectAverage("30");
+				} else {
+					await vi.advanceTimersByTimeAsync(2000);
+					await final("two", 180);
+					expectAverage("50"); // A120/4 + B180/2
+					if (state === "completed-plus-open") {
+						await vi.advanceTimersByTimeAsync(2000);
+						await h.emit("turn_start"); // B's second call starts at 18s
+						await vi.advanceTimersByTimeAsync(1000);
+					}
+				}
+				h.ctx.isIdle = () => false;
+				await h.emit("agent_settled");
+				expectAverage(state === "in-flight" ? "—" : "90");
+				await h.emit("agent_settled"); // no accepted duplicate partition
+				expectAverage(state === "in-flight" ? "—" : "90");
+				if (state === "in-flight") {
+					await vi.advanceTimersByTimeAsync(1000);
+					await final("two", 180);
+					expectAverage("90"); // original 14s turn_start survived the 15s partition
+				} else if (state === "completed-plus-open") {
+					await vi.advanceTimersByTimeAsync(3000);
+					await final("three", 120);
+					expectAverage("50"); // B300/6, not A+B420/10
+				}
+				await h.emit("agent_end");
+				h.ctx.isIdle = () => true;
+				await h.emit("agent_settled");
+				expectAverage(state === "completed-plus-open" ? "50" : "90");
+				await h.emit("agent_settled");
+				expectAverage(state === "completed-plus-open" ? "50" : "90");
+			} finally {
+				await h.emit("session_shutdown");
+			}
+		},
+	);
+	it.each(["prior", "surviving"])(
+		"partitions unknown metadata coverage by its %s run",
+		async (unknownRun) => {
+			const h = harness();
+			const final = (responseId: string, output?: number) =>
+				h.emit("message_end", {
+					message: {
+						role: "assistant",
+						responseId,
+						stopReason: "stop",
+						...(output === undefined ? {} : { usage: { input: 10, output } }),
+					},
+				});
+			try {
+				await h.emit("session_start");
+				h.render();
+				await h.emit("agent_start");
+				await h.emit("turn_start");
+				await vi.advanceTimersByTimeAsync(4000);
+				await final("one", unknownRun === "prior" ? undefined : 120);
+				await h.emit("agent_end");
+				await h.emit("agent_start");
+				await h.emit("turn_start");
+				await vi.advanceTimersByTimeAsync(2000);
+				await final("two", unknownRun === "surviving" ? undefined : 180);
+				expect(h.render()).toContain("— tok/s avg");
+				h.ctx.isIdle = () => false;
+				await h.emit("agent_settled");
+				const expected = unknownRun === "prior" ? "90" : "—";
+				expect(h.render()).toContain(`${expected} tok/s avg`);
+				expect(h.renderFooter()).toContain(`${expected} tok/s avg`);
+				await h.emit("turn_start");
+				await vi.advanceTimersByTimeAsync(2000);
+				await final("three", 120);
+				const next = unknownRun === "prior" ? "75" : "—";
+				expect(h.render()).toContain(`${next} tok/s avg`);
+				expect(h.renderFooter()).toContain(`${next} tok/s avg`);
+			} finally {
+				await h.emit("session_shutdown");
+			}
+		},
+	);
+	it("keeps a short response as a placeholder, clears on session replacement, and does not retain disabled demand", async () => {
+		const h = harness();
+		try {
+			await h.emit("session_start");
+			h.render();
+			await h.emit("agent_start");
+			await h.emit("turn_start");
+			expect(h.render()).toContain("— tok/s avg");
+			await h.emit("message_end", {
+				message: {
+					role: "assistant",
+					responseId: "short",
+					usage: { input: 10, output: 999 },
+					stopReason: "stop",
+				},
+			});
+			await h.emit("agent_end");
+			expect(h.renderFooter()).toContain("— tok/s avg");
+			await h.emit("session_start");
+			expect(h.renderFooter()).not.toContain("tok/s");
+			h.render();
+			await streaming(h);
+			h.hook("setEditorComponent", { enabled: false });
+			expect(h.renderFooter()).toContain("— tok/s avg");
+			h.hook("setFooterComponent", { style: "native" });
+			await h.emit("agent_end");
+			h.hook("setFooterComponent", { style: "starship" });
+			expect(h.renderFooter()).not.toContain("tok/s");
+		} finally {
+			await h.emit("session_shutdown");
+		}
+	});
+	it.each(["editor", "footer"] as const)(
+		"measures for the sole %s owner and clears completed averages on demand loss",
+		async (owner) => {
+			if (!runtime.config) throw new Error("missing config");
+			runtime.config.components.editor.enabled = owner === "editor";
+			runtime.config.components.footer.style = owner === "footer" ? "starship" : "native";
+			const h = harness();
+			const rendered = () => (owner === "editor" ? h.render() : h.renderFooter());
+			try {
+				await h.emit("session_start");
+				h.render();
+				await h.emit("agent_start");
+				await h.emit("turn_start");
+				await vi.advanceTimersByTimeAsync(4000);
+				await h.emit("message_end", {
+					message: { role: "assistant", usage: { input: 10, output: 120 }, stopReason: "stop" },
+				});
+				expect(rendered()).toContain("30 tok/s avg");
+				if (owner === "editor") h.hook("setEditorComponent", { enabled: false });
+				else h.hook("setFooterComponent", { style: "native" });
+				await h.emit("agent_end");
+				if (owner === "editor") h.hook("setEditorComponent", { enabled: true });
+				else h.hook("setFooterComponent", { style: "starship" });
+				expect(rendered()).not.toContain("tok/s");
+			} finally {
+				await h.emit("session_shutdown");
+			}
+		},
+	);
+	it("honors alias-only ci without GitHub I/O on either owner", async () => {
+		if (!runtime.config) throw new Error("missing config");
+		Object.assign(runtime.config.components.editor.styles.minimalist, {
+			formats: { ...emptyFormats, topLeft: "$ci" },
+			variables: { ci: "@scope/usage:quota" },
+		});
+		Object.assign(runtime.config.components.footer.styles.starship, {
+			format: "$ci",
+			variables: { ci: "@scope/usage:quota" },
+		});
+		const h = harness();
+		try {
+			await h.emit("session_start");
+			h.render();
+			h.publish("publisher CI");
+			await settle();
+			expect(h.render()).toContain("publisher CI");
+			expect(h.renderFooter()).toContain("publisher CI");
+			expect(h.exec).not.toHaveBeenCalled();
+		} finally {
+			await h.emit("session_shutdown");
+		}
+	});
+	it("leaves native and headless consumers unused, aborts old session work and drops old snapshots", async () => {
+		if (!runtime.config) throw new Error("missing config");
+		runtime.config.components.editor.enabled = false;
+		runtime.config.components.footer.style = "native";
+		const h = harness();
+		await h.emit("session_start");
+		await settle();
+		expect(h.exec).not.toHaveBeenCalled();
+		await h.emit("session_shutdown");
+		runtime.config.components.editor.enabled = true;
+		runtime.config.components.footer.style = "starship";
+		const headless = harness("json");
+		await headless.emit("session_start");
+		await settle();
+		expect(headless.exec).not.toHaveBeenCalled();
+		await headless.emit("session_shutdown");
+		const tui = harness();
+		await tui.emit("session_start");
+		tui.render();
+		await settle();
+		expect(tui.renderFooter()).toContain("CI passing");
+		await tui.emit("session_start");
+		expect(tui.renderFooter()).not.toContain("CI passing");
+		await settle();
+		expect(tui.renderFooter()).toContain("CI passing");
+		await tui.emit("session_shutdown");
+	});
+	it.each([undefined, 50, 100])(
+		"partitions held Working TPS by run on accepted non-idle settlement (surviving rate %s)",
+		async (survivingRate) => {
+			if (!runtime.config) throw new Error("missing config");
+			runtime.config.components.editor.enabled = false;
+			runtime.config.components.footer.style = "native";
+			runtime.config.components.workingLine.enabled = true;
+			runtime.config.components.workingLine.segments.tokenRate = true;
+			const h = harness();
+			const row = () =>
+				stripVTControlCharacters(
+					(h.ui.setWorkingIndicator.mock.calls.at(-1)?.[0] as { frames?: string[] } | undefined)
+						?.frames?.[0] ?? "",
+				);
+			const update = (responseId: string, output: number) =>
+				h.emit("message_update", {
+					message: { role: "assistant", responseId, usage: { input: 10, output } },
+				});
+			try {
+				await h.emit("session_start");
+				await streaming(h); // run A observes 50 tok/s
+				await h.emit("message_end", {
+					message: {
+						role: "assistant",
+						responseId: "one",
+						usage: { input: 10, output: 120 },
+						stopReason: "stop",
+					},
+				});
+				await h.emit("agent_end");
+				await h.emit("agent_start"); // B starts before A's settlement
+				await h.emit("turn_start");
+				await update("two", 10);
+				if (survivingRate !== undefined) {
+					await vi.advanceTimersByTimeAsync(600);
+					await update("two", 10 + survivingRate * 0.6);
+					// Retain B's observation while its sampling window is suspended by a tool.
+					await h.emit("tool_execution_start", { toolCallId: "tool", toolName: "read" });
+				}
+				expect(row()).toContain(`${survivingRate ?? 50} tok/s`);
+				h.ctx.isIdle = () => false;
+				await h.emit("agent_settled");
+				const expected = survivingRate === undefined ? "— tok/s" : `${survivingRate} tok/s`;
+				expect(row()).toContain(expected);
+				await h.emit("agent_settled"); // no additional settled run: no new boundary
+				expect(row()).toContain(expected);
+				if (survivingRate === undefined) {
+					// B's first anchor/authorization survives; its second anchor replaces the dash.
+					await vi.advanceTimersByTimeAsync(600);
+					await update("two", 40);
+					await vi.advanceTimersByTimeAsync(100);
+					expect(row()).toContain("50 tok/s");
+				} else {
+					await h.emit("tool_execution_end", { toolCallId: "tool" });
+					expect(row()).toContain(expected);
+				}
+				// Another response in surviving B remains authorized without an agent_start.
+				await h.emit("turn_start");
+				await update("three", 10);
+				await vi.advanceTimersByTimeAsync(600);
+				await update("three", 100);
+				await vi.advanceTimersByTimeAsync(100);
+				expect(row()).toContain("150 tok/s");
+				await h.emit("agent_end");
+				h.ctx.isIdle = () => true;
+				await h.emit("agent_settled");
+				expect(row()).not.toContain("tok/s");
+				// The fork schedules one delayed authoritative-cost refresh per settlement.
+				await vi.advanceTimersByTimeAsync(12_000);
+				expect(vi.getTimerCount()).toBe(0);
+			} finally {
+				await h.emit("session_shutdown");
+			}
+		},
+	);
+	it("clears Working-only observation on disable/demand loss instead of resurrecting it on re-enable", async () => {
+		if (!runtime.config) throw new Error("missing config");
+		runtime.config.components.editor.enabled = false;
+		runtime.config.components.footer.style = "native";
+		runtime.config.components.workingLine.enabled = true;
+		runtime.config.components.workingLine.segments.tokenRate = true;
+		const h = harness();
+		const row = () =>
+			stripVTControlCharacters(
+				(h.ui.setWorkingIndicator.mock.calls.at(-1)?.[0] as { frames?: string[] } | undefined)
+					?.frames?.[0] ?? "",
+			);
+		try {
+			await h.emit("session_start");
+			await streaming(h);
+			await vi.advanceTimersByTimeAsync(100);
+			expect(row()).toContain("50 tok/s");
+			h.hook("setWorkingLineComponent", { enabled: false });
+			expect(row()).not.toContain("tok/s");
+			h.hook("setWorkingLineComponent", { enabled: true });
+			expect(row()).not.toContain("50 tok/s");
+			await h.emit("turn_start");
+			expect(row()).toContain("— tok/s");
+		} finally {
+			await h.emit("session_shutdown");
+		}
+	});
+	it("holds Working-only live rate through finals, tools, turns and continuation without idle timers", async () => {
+		if (!runtime.config) throw new Error("missing config");
+		runtime.config.components.editor.enabled = false;
+		runtime.config.components.footer.style = "native";
+		runtime.config.components.workingLine.enabled = true;
+		runtime.config.components.workingLine.segments.tokenRate = true;
+		const h = harness();
+		const row = () =>
+			stripVTControlCharacters(
+				(h.ui.setWorkingIndicator.mock.calls.at(-1)?.[0] as { frames?: string[] } | undefined)
+					?.frames?.[0] ?? "",
+			);
+		try {
+			await h.emit("session_start");
+			await h.emit("agent_start");
+			await h.emit("turn_start");
+			await vi.advanceTimersByTimeAsync(100);
+			expect(row()).toContain("— tok/s");
+			await streaming(h);
+			await vi.advanceTimersByTimeAsync(100);
+			expect(row()).toContain("50 tok/s");
+			expect(h.exec).not.toHaveBeenCalled();
+			await vi.advanceTimersByTimeAsync(4250);
+			expect(row()).toContain("50 tok/s");
+			await h.emit("message_end", {
+				message: {
+					role: "assistant",
+					responseId: "one",
+					usage: { input: 10, output: 120 },
+					stopReason: "toolUse",
+				},
+			});
+			expect(row()).toContain("50 tok/s");
+			await h.emit("tool_execution_start", { toolCallId: "tool", toolName: "bash" });
+			expect(row()).toContain("bash");
+			expect(row()).toContain("50 tok/s");
+			await vi.advanceTimersByTimeAsync(10_000);
+			expect(row()).toContain("50 tok/s");
+			await h.emit("tool_execution_end", { toolCallId: "tool" });
+			expect(row()).toContain("50 tok/s");
+			await h.emit("turn_start");
+			expect(row()).toContain("50 tok/s");
+			await h.emit("message_update", {
+				message: {
+					role: "assistant",
+					responseId: "two",
+					usage: { input: 10, output: 10 },
+				},
+			});
+			expect(row()).toContain("50 tok/s");
+			await vi.advanceTimersByTimeAsync(600);
+			await h.emit("message_update", {
+				message: {
+					role: "assistant",
+					responseId: "two",
+					usage: { input: 10, output: 70 },
+				},
+			});
+			await vi.advanceTimersByTimeAsync(100);
+			expect(row()).toContain("100 tok/s");
+			await h.emit("agent_end");
+			expect(row()).not.toContain("tok/s");
+			await h.emit("agent_start"); // continuation/retry before settlement
+			expect(row()).toContain("100 tok/s");
+			await h.emit("turn_start");
+			expect(row()).toContain("100 tok/s");
+			await h.emit("agent_end");
+			await h.emit("agent_settled");
+			expect(row()).not.toContain("tok/s");
+			await vi.advanceTimersByTimeAsync(12_000);
+			expect(vi.getTimerCount()).toBe(0);
+			await h.emit("agent_start"); // genuinely new interaction
+			expect(row()).toContain("— tok/s");
+		} finally {
+			await h.emit("session_shutdown");
+		}
+	});
+});
+
+it("retains the live estimate marker through tools/turns without changing the completed average", async () => {
+	if (!runtime.config) throw new Error("missing config");
+	runtime.config.components.workingLine.enabled = true;
+	runtime.config.components.workingLine.segments.tokenRate = true;
+	const h = harness();
+	const row = () =>
+		stripVTControlCharacters(
+			(h.ui.setWorkingIndicator.mock.calls.at(-1)?.[0] as { frames?: string[] } | undefined)
+				?.frames?.[0] ?? "",
+		);
+	try {
+		await h.emit("session_start");
+		h.render();
+		await h.emit("agent_start");
+		await h.emit("turn_start");
+		const update = (text: string, delta: string) => ({
+			message: { role: "assistant", responseId: "estimate", content: [{ type: "text", text }] },
+			assistantMessageEvent: {
+				type: "text_delta",
+				contentIndex: 0,
+				delta,
+				partial: { content: [{ type: "text", text }] },
+			},
+		});
+		await h.emit("message_update", update("a".repeat(40), "a".repeat(40)));
+		await vi.advanceTimersByTimeAsync(600);
+		await h.emit("message_update", update("a".repeat(120), "a".repeat(80)));
+		expect(h.render()).toContain("— tok/s avg");
+		expect(h.renderFooter()).toContain("— tok/s avg");
+		await vi.advanceTimersByTimeAsync(100);
+		const retained = row().match(/~[1-9]\d* tok\/s/)?.[0];
+		expect(retained).toBeDefined();
+		await h.emit("message_end", {
+			message: {
+				role: "assistant",
+				responseId: "estimate",
+				usage: { input: 10, output: 999 },
+				stopReason: "stop",
+			},
+		});
+		expect(row()).toContain(retained);
+		await h.emit("tool_execution_start", { toolCallId: "tool", toolName: "read" });
+		expect(row()).toContain(retained);
+		await h.emit("tool_execution_end", { toolCallId: "tool" });
+		await h.emit("turn_start");
+		expect(row()).toContain(retained);
+		expect(h.render()).toContain("1427 tok/s avg");
+		expect(h.renderFooter()).toContain("1427 tok/s avg");
+		await h.emit("agent_end");
+		expect(h.renderFooter()).toContain("— tok/s avg"); // the second call was never closed
+	} finally {
+		await h.emit("session_shutdown");
+	}
+});
+
+it("generation-guards stale host subscriptions and aborts queued invalidation on shutdown", async () => {
+	const callbacks: Array<() => void> = [];
+	const unsubscribed = vi.fn();
+	const h = harness("tui", false, {
+		subscribeProjectChanges(callback) {
+			callbacks.push(callback);
+			return unsubscribed;
+		},
+	});
+	try {
+		await h.emit("session_start");
+		h.render();
+		await settle();
+		callbacks[0]();
+		expect(h.renderFooter()).not.toContain("CI passing");
+		await settle();
+		expect(h.renderFooter()).toContain("CI passing");
+		await h.emit("session_start");
+		h.render();
+		await settle();
+		callbacks[0]();
+		expect(h.renderFooter()).toContain("CI passing");
+		expect(unsubscribed).toHaveBeenCalledOnce();
+		const calls = h.exec.mock.calls.length;
+		callbacks[1]();
+		expect(h.renderFooter()).not.toContain("CI passing");
+		await h.emit("session_shutdown");
+		await settle();
+		callbacks[1]();
+		await settle();
+		expect(h.exec).toHaveBeenCalledTimes(calls);
+		expect(unsubscribed).toHaveBeenCalledTimes(2);
+	} finally {
+		await h.emit("session_shutdown");
+	}
+});
+
+it.each(["minimalist", "opencode", "opencode-copy-friendly"] as const)(
+	"requires actual supported %s decoration and defers render-discovered demand",
+	async (style) => {
+		if (!runtime.config) throw new Error("missing config");
+		runtime.config.components.editor.style = style;
+		runtime.config.components.footer.style = "native";
+		if (style !== "minimalist")
+			runtime.config.components.editor.styles[style].metadataFormat = "$ci";
+		const h = harness();
+		try {
+			await h.emit("session_start");
+			await settle();
+			expect(h.exec).not.toHaveBeenCalled();
+			h.render(1);
+			await settle();
+			expect(h.exec).not.toHaveBeenCalled();
+			h.render();
+			expect(h.exec).not.toHaveBeenCalled();
+			await settle();
+			expect(h.render()).toContain("CI passing");
+			const calls = h.exec.mock.calls.length;
+			h.ui.setEditorComponent(undefined);
+			await vi.advanceTimersByTimeAsync(30_000);
+			expect(h.exec).toHaveBeenCalledTimes(calls);
+		} finally {
+			await h.emit("session_shutdown");
+		}
+	},
+);
+
+it.each([false, true])(
+	"does not register Pi-only pre-boundary rate hooks in OMP with metadata enabled=%s",
+	(enabled) => {
+		if (!runtime.config) throw new Error("missing config");
+		runtime.config.components.editor.enabled = enabled;
+		runtime.config.components.footer.style = enabled ? "starship" : "native";
+		const omp = harness("tui", false, { skinOnly: true });
+		expect(omp.registeredEvents().has("session_before_compact")).toBe(false);
+		expect(omp.registeredEvents().has("session_before_switch")).toBe(false);
+		const pi = harness();
+		expect(pi.registeredEvents().has("session_before_compact")).toBe(true);
+		expect(pi.registeredEvents().has("session_before_switch")).toBe(true);
+	},
+);
+
+it("recovers rate after a mid-run model change and tool loop without another agent_start", async () => {
+	if (!runtime.config) throw new Error("missing config");
+	runtime.config.components.workingLine.enabled = true;
+	runtime.config.components.workingLine.segments.tokenRate = true;
+	const h = harness();
+	try {
+		await h.emit("session_start");
+		h.render();
+		await streaming(h);
+		expect(h.render()).toContain("— tok/s avg");
+		await h.emit("model_select");
+		expect(h.render()).not.toContain("tok/s");
+		await vi.advanceTimersByTimeAsync(100);
+		const row = () =>
+			stripVTControlCharacters(
+				(h.ui.setWorkingIndicator.mock.calls.at(-1)?.[0] as { frames?: string[] } | undefined)
+					?.frames?.[0] ?? "",
+			);
+		expect(row()).not.toContain("tok/s");
+		await h.emit("tool_execution_start", { toolCallId: "tool", toolName: "bash" });
+		await h.emit("tool_execution_end", { toolCallId: "tool" });
+		await h.emit("turn_start");
+		expect(row()).toContain("— tok/s");
+		await h.emit("message_update", {
+			message: { role: "assistant", responseId: "new-model", usage: { input: 10, output: 10 } },
+		});
+		expect(h.render()).toContain("— tok/s avg");
+		await vi.advanceTimersByTimeAsync(600);
+		await h.emit("message_update", {
+			message: { role: "assistant", responseId: "new-model", usage: { input: 10, output: 40 } },
+		});
+		expect(h.render()).toContain("— tok/s avg");
+		expect(h.renderFooter()).toContain("— tok/s avg");
+		await vi.advanceTimersByTimeAsync(100);
+		const live = h.ui.setWorkingIndicator.mock.calls.at(-1)?.[0] as
+			| { frames?: string[] }
+			| undefined;
+		expect(live?.frames?.some((frame) => frame.includes("50 tok/s"))).toBe(true);
+		await h.emit("message_end", {
+			message: {
+				role: "assistant",
+				responseId: "new-model",
+				usage: { input: 10, output: 120 },
+				stopReason: "stop",
+			},
+		});
+		expect(h.renderFooter()).toContain("171 tok/s avg");
+	} finally {
+		await h.emit("session_shutdown");
+	}
+});