import { stripVTControlCharacters } from "node:util";
import type { Theme } from "@earendil-works/pi-coding-agent";
import { Loader, visibleWidth } from "@earendil-works/pi-tui";
import { beforeEach, describe, expect, it, vi } from "vitest";

const stripTerminalSequences = stripVTControlCharacters;

const runtime = vi.hoisted(() => ({
	enabled: true,
	custom: true,
	message: "Stable",
	spinner: "star-bloom" as "star-bloom" | "pulse",
	spinnerIntervalMs: 100,
	textIntervalMs: 60,
}));

vi.mock("../extensions/zentui/config", async (importOriginal) => {
	const actual = await importOriginal<typeof import("../extensions/zentui/config")>();
	return {
		...actual,
		ensureConfigExists() {},
		loadConfig: () => {
			const config = structuredClone(actual.defaultConfig);
			config.projectRefreshIntervalMs = 0;
			config.components.editor.enabled = false;
			config.components.userMessages.enabled = false;
			config.components.selectorBorders.enabled = false;
			config.components.footer.style = "native";
			config.components.workingLine.enabled = runtime.enabled;
			config.components.workingLine.spinner = runtime.spinner;
			config.components.workingLine.spinnerIntervalMs = runtime.spinnerIntervalMs;
			config.components.workingLine.textIntervalMs = runtime.textIntervalMs;
			config.components.workingLine.messages = {
				custom: runtime.custom,
				values: [runtime.message],
			};
			return config;
		},
	};
});

import zentui from "../extensions/zentui/index";

type Handler = (event: unknown, ctx: unknown) => unknown | Promise<unknown>;

function theme(): Theme {
	return {
		fg(color: string, text: string) {
			const codes: Record<string, number> = { dim: 90, muted: 36, accent: 96 };
			return `\x1b[${codes[color] ?? 37}m${text}\x1b[0m`;
		},
		bold: (text: string) => `\x1b[1m${text}\x1b[0m`,
	} as Theme;
}

function loaderPhase(rendered: string): [string, number | undefined] {
	const stripped = stripTerminalSequences(rendered);
	const plain = stripped.trimStart();
	const separatorIndex = plain.indexOf(" ");
	if (separatorIndex < 0) throw new Error("Expected a spinner separator in the working row");
	const spinner = plain.slice(0, separatorIndex);
	const textOffset =
		visibleWidth(stripped) - visibleWidth(plain) + visibleWidth(plain.slice(0, separatorIndex + 1));
	const marker = [...rendered.matchAll(/\x1b\[96m\x1b\[1m/g)].find((match) => {
		if (match.index === undefined) return false;
		return visibleWidth(stripTerminalSequences(rendered.slice(0, match.index))) >= textOffset;
	});
	return [
		spinner,
		marker?.index === undefined
			? undefined
			: visibleWidth(stripTerminalSequences(rendered.slice(0, marker.index))) - textOffset,
	];
}

function loadExtension() {
	const handlers = new Map<string, Handler[]>();
	zentui({
		registerEntryRenderer() {},
		appendEntry() {},
		on(name: string, handler: Handler) {
			handlers.set(name, [...(handlers.get(name) ?? []), handler]);
		},
		registerCommand() {},
		getThinkingLevel: () => "off",
	} as never);
	return handlers;
}

async function emit(
	handlers: Map<string, Handler[]>,
	name: string,
	ctx: unknown,
	event: unknown = {},
) {
	for (const handler of handlers.get(name) ?? []) await handler(event, ctx);
}

function harness() {
	const calls: Array<[string, unknown?]> = [];
	const forbidden = vi.fn();
	let indicator: { frames?: string[]; intervalMs?: number } | undefined;
	let message = "";
	let loader: Loader | undefined;
	const ui = {
		theme: theme(),
		getEditorComponent: () => undefined,
		setEditorComponent: forbidden,
		setFooter: forbidden,
		setWidget: forbidden,
		setWorkingVisible: forbidden,
		setWorkingMessage(value?: string) {
			calls.push(["message", value]);
			message = value ?? "Working...";
			loader?.setMessage(message);
		},
		setWorkingIndicator(value?: unknown) {
			calls.push(["indicator", value]);
			indicator = value as typeof indicator;
			loader?.setIndicator(indicator);
		},
	};
	return {
		calls,
		forbidden,
		activateLoader() {
			loader = new Loader(
				{ requestRender() {} } as never,
				(text) => text,
				(text) => text,
				message,
				indicator,
			);
			return loader;
		},
		ctx: {
			hasUI: true,
			mode: "tui",
			cwd: process.cwd(),
			model: undefined,
			getContextUsage: () => null,
			sessionManager: { getBranch: () => [], getSessionName: () => undefined },
			ui,
		},
	};
}

beforeEach(() => {
	runtime.enabled = true;
	runtime.custom = true;
	runtime.message = "Stable";
	runtime.spinner = "star-bloom";
	runtime.spinnerIntervalMs = 100;
	runtime.textIntervalMs = 60;
});

describe("working-line extension lifecycle integration", () => {
	it("wires full-row rebuilds, authoritative usage, parallel tools, and isolated cleanup", async () => {
		const handlers = loadExtension();
		const current = harness();
		const row = () => {
			const indicator = current.calls.at(-1)?.[1] as { frames?: string[] } | undefined;
			return stripTerminalSequences(indicator?.frames?.[0] ?? "");
		};
		await emit(handlers, "session_start", current.ctx);
		expect(current.calls.slice(0, 2).map(([name, value]) => [name, value])).toEqual([
			["message", ""],
			["indicator", expect.any(Object)],
		]);
		await emit(handlers, "agent_start", current.ctx);
		await emit(handlers, "turn_start", current.ctx, { turnIndex: 0, timestamp: Date.now() });
		const partialAssistant = {
			role: "assistant",
			usage: { input: 100, output: 4 },
			content: [],
			api: "google-generative-ai",
			provider: "google",
			model: "test",
			stopReason: "toolUse",
			timestamp: Date.now(),
		};
		const laterPartialAssistant = { ...partialAssistant, usage: { input: 120, output: 7 } };
		const finalAssistant = { ...partialAssistant, usage: { input: 150, output: 9 } };
		await emit(handlers, "message_update", current.ctx, { message: partialAssistant });
		expect(row()).toMatch(/Stable · \d+s · ↑100 ↓4/);
		const beforeDuplicate = current.calls.length;
		await emit(handlers, "message_update", current.ctx, { message: partialAssistant });
		expect(current.calls).toHaveLength(beforeDuplicate);
		await emit(handlers, "message_update", current.ctx, { message: laterPartialAssistant });
		expect(row()).toMatch(/Stable · \d+s · ↑120 ↓7/);
		await emit(handlers, "message_end", current.ctx, { message: finalAssistant });
		expect(row()).toMatch(/Stable · \d+s · ↑150 ↓9/);
		await emit(handlers, "tool_execution_start", current.ctx, {
			toolCallId: "one",
			toolName: "read",
		});
		expect(row()).toMatch(/Stable · read · \d+s · ↑150 ↓9/);
		await emit(handlers, "tool_execution_start", current.ctx, {
			toolCallId: "two",
			toolName: "bash",
		});
		expect(row()).toMatch(/Stable · bash · \d+s · ↑150 ↓9/);
		await emit(handlers, "tool_execution_end", current.ctx, { toolCallId: "two" });
		expect(row()).toMatch(/Stable · read · \d+s · ↑150 ↓9/);
		await emit(handlers, "tool_execution_end", current.ctx, { toolCallId: "one" });
		expect(row()).toMatch(/Stable · \d+s · ↑150 ↓9/);
		await emit(handlers, "turn_start", current.ctx, {
			turnIndex: 1,
			timestamp: Date.now(),
		});
		expect(row()).toContain("↑150 ↓9");
		await emit(handlers, "agent_end", current.ctx);
		expect(current.calls.filter(([name]) => name === "message")).toEqual([["message", ""]]);
		expect(current.forbidden).not.toHaveBeenCalled();
		const beforeLateEnds = current.calls.length;
		await emit(handlers, "message_end", current.ctx, {
			message: { role: "user", usage: { input: 99, output: 99 } },
		});
		await emit(handlers, "message_end", current.ctx, {
			message: { ...finalAssistant, responseId: "late-after-agent" },
		});
		expect(current.calls).toHaveLength(beforeLateEnds);
		await emit(handlers, "session_shutdown", current.ctx);
		expect(current.calls.slice(-2).map(([name, value]) => [name, value])).toEqual([
			["indicator", undefined],
			["message", undefined],
		]);
		expect(current.forbidden).not.toHaveBeenCalled();
	});

	it("compacts live provider usage", async () => {
		const handlers = loadExtension();
		const current = harness();
		const row = () => {
			const indicator = current.calls.at(-1)?.[1] as { frames?: string[] } | undefined;
			return stripTerminalSequences(indicator?.frames?.[0] ?? "");
		};
		const message = (input: number, output: number) => ({
			role: "assistant",
			usage: { input, output },
			content: [],
			responseId: "reported",
		});

		await emit(handlers, "session_start", current.ctx);
		await emit(handlers, "agent_start", current.ctx);
		await emit(handlers, "turn_start", current.ctx);
		await emit(handlers, "message_update", current.ctx, { message: message(27_000, 1_400) });
		expect(row()).toContain("↑27k ↓1.4k");
		await emit(handlers, "message_end", current.ctx, { message: message(27_000, 1_400) });
		expect(row()).toContain("↑27k ↓1.4k");
	});

	it("visibly reconciles an estimated 1.0k output to exact 999", async () => {
		const handlers = loadExtension();
		const current = harness();
		const row = () => {
			const indicator = current.calls.at(-1)?.[1] as { frames?: string[] } | undefined;
			return stripTerminalSequences(indicator?.frames?.[0] ?? "");
		};
		const message = (output: number) => ({
			role: "assistant",
			usage: { input: 0, output },
			content: [],
			responseId: "estimated-boundary",
		});

		await emit(handlers, "session_start", current.ctx);
		await emit(handlers, "agent_start", current.ctx);
		await emit(handlers, "turn_start", current.ctx);
		const partial = message(998);
		await emit(handlers, "message_update", current.ctx, { message: partial });
		await emit(handlers, "message_update", current.ctx, {
			message: partial,
			assistantMessageEvent: {
				type: "text_delta",
				contentIndex: 0,
				delta: "abcdefgh",
				partial: { content: [{ type: "text", text: "abcdefgh" }] },
			},
		});
		expect(row()).toContain("↑0 ↓1.0k");
		await emit(handlers, "message_end", current.ctx, { message: message(999) });
		expect(row()).toContain("↑0 ↓999");
	});

	it("keeps cumulative billion-scale totals compact across continuations", async () => {
		runtime.message = "Response usage stays visible here";
		const handlers = loadExtension();
		const current = harness();
		const row = () => {
			const indicator = current.calls.at(-1)?.[1] as { frames?: string[] } | undefined;
			return stripTerminalSequences(indicator?.frames?.[0] ?? "");
		};
		const assistant = (input: number, output: number, responseId: string) => ({
			role: "assistant",
			usage: { input, output },
			content: [],
			api: "openai-completions",
			provider: "openai-compatible",
			model: "test",
			stopReason: "toolUse",
			timestamp: Date.now(),
			responseId,
		});

		await emit(handlers, "session_start", current.ctx);
		await emit(handlers, "agent_start", current.ctx);
		await emit(handlers, "turn_start", current.ctx);
		await emit(handlers, "message_end", current.ctx, {
			message: assistant(1_000_000_000, 1_000_000_000, "first"),
		});
		expect(row()).toContain("↑1000M ↓1000M");

		await emit(handlers, "turn_start", current.ctx);
		expect(row()).toContain("↑1000M ↓1000M");
		await emit(handlers, "tool_execution_start", current.ctx, {
			toolCallId: "wide",
			toolName: "123456789012345678",
		});
		const writesBeforeLiveUsage = current.calls.length;
		await emit(handlers, "message_update", current.ctx, {
			message: assistant(12, 3, "second"),
		});
		expect(row()).toContain("↑1000M ↓1000M");
		expect(current.calls).toHaveLength(writesBeforeLiveUsage);

		await emit(handlers, "tool_execution_end", current.ctx, { toolCallId: "wide" });
		await emit(handlers, "message_end", current.ctx, {
			message: assistant(14, 5, "second"),
		});
		expect(row()).toContain("↑1000M ↓1000M");

		await emit(handlers, "turn_start", current.ctx);
		await emit(handlers, "message_end", current.ctx, {
			message: assistant(499_986, 499_995, "third"),
		});
		expect(row()).toContain("↑1001M ↓1001M");
	});

	it("keeps committed tokens through retry lifecycle and initial zero usage, then accumulates final usage", async () => {
		const handlers = loadExtension();
		const current = harness();
		const row = () => {
			const indicator = current.calls.at(-1)?.[1] as { frames?: string[] } | undefined;
			return stripTerminalSequences(indicator?.frames?.[0] ?? "");
		};
		const assistant = (input: number, output: number, responseId: string) => ({
			role: "assistant",
			usage: { input, output },
			provider: "mistral",
			responseId,
		});

		await emit(handlers, "session_start", current.ctx);
		await emit(handlers, "agent_start", current.ctx);
		await emit(handlers, "turn_start", current.ctx);
		await emit(handlers, "message_end", current.ctx, {
			message: assistant(20, 4, "committed"),
		});
		expect(row()).toContain("↑20 ↓4");

		await emit(handlers, "agent_end", current.ctx);
		expect(row()).toContain("↑20 ↓4");
		await emit(handlers, "agent_start", current.ctx);
		expect(row()).toContain("↑20 ↓4");
		await emit(handlers, "turn_start", current.ctx);
		expect(row()).toContain("↑20 ↓4");
		await emit(handlers, "message_update", current.ctx, {
			message: assistant(0, 0, "retry"),
		});
		expect(row()).toContain("↑20 ↓4");
		await emit(handlers, "message_end", current.ctx, {
			message: assistant(5, 2, "retry"),
		});
		expect(row()).toContain("↑25 ↓6");
	});

	it("shows OpenAI Codex Responses placeholder usage as a zero estimate until exact final usage", async () => {
		const handlers = loadExtension();
		const current = harness();
		const row = () => {
			const indicator = current.calls.at(-1)?.[1] as { frames?: string[] } | undefined;
			return stripTerminalSequences(indicator?.frames?.[0] ?? "");
		};
		const partial = {
			role: "assistant",
			content: [{ type: "text", text: "streaming" }],
			// Codex Responses reports exact usage only on terminal response.completed.
			usage: { input: 0, output: 0 },
			provider: "openai-codex",
			model: "gpt-5.4",
			responseId: "terminal-only",
		};
		await emit(handlers, "session_start", current.ctx);
		await emit(handlers, "agent_start", current.ctx);
		await emit(handlers, "turn_start", current.ctx);
		const writesBeforeUpdates = current.calls.length;
		await emit(handlers, "message_update", current.ctx, { message: partial });
		await emit(handlers, "message_update", current.ctx, { message: partial });
		await emit(handlers, "message_update", current.ctx, {
			message: { role: "assistant", usage: { input: 2.5, output: 1 } },
		});
		await emit(handlers, "message_update", current.ctx, {
			message: { role: "user", usage: { input: 99, output: 99 } },
		});
		expect(current.calls).toHaveLength(writesBeforeUpdates + 1);
		expect(row()).toContain("↑0 ↓0");
		await emit(handlers, "message_end", current.ctx, {
			message: { ...partial, usage: { input: 42, output: 6 } },
		});
		expect(row()).toContain("↑42 ↓6");
	});

	it("preserves approximation across rejected finals and ignores late messages", async () => {
		const handlers = loadExtension();
		const current = harness();
		const row = () => {
			const indicator = current.calls.at(-1)?.[1] as { frames?: string[] } | undefined;
			return stripTerminalSequences(indicator?.frames?.[0] ?? "");
		};
		const assistantMessage = (input: number, output: number, responseId: string) => ({
			role: "assistant",
			usage: { input, output },
			content: [],
			responseId,
		});
		const partial = assistantMessage(0, 0, "active");
		await emit(handlers, "session_start", current.ctx);
		await emit(handlers, "agent_start", current.ctx);
		await emit(handlers, "turn_start", current.ctx);
		await emit(handlers, "message_end", current.ctx, {
			message: assistantMessage(1, 1, "already-committed"),
		});
		await emit(handlers, "turn_start", current.ctx);
		await emit(handlers, "message_update", current.ctx, { message: partial });
		expect(row()).toContain("↑1 ↓1");
		const beforeRejected = current.calls.length;
		await emit(handlers, "message_end", current.ctx, {
			message: assistantMessage(90, 9, "mismatched"),
		});
		expect(current.calls).toHaveLength(beforeRejected);
		expect(row()).toContain("↑1 ↓1");
		await emit(handlers, "message_end", current.ctx, {
			message: assistantMessage(90, 9, "already-committed"),
		});
		expect(current.calls).toHaveLength(beforeRejected);
		expect(row()).toContain("↑1 ↓1");
		const beforeLateMessages = current.calls.length;
		await emit(handlers, "message_end", current.ctx, {
			message: { role: "user", usage: { input: 99, output: 99 } },
		});
		await emit(handlers, "message_end", current.ctx, {
			message: assistantMessage(99, 99, "late-unmatched"),
		});
		expect(current.calls).toHaveLength(beforeLateMessages);
		expect(row()).toContain("↑1 ↓1");
		await emit(handlers, "message_end", current.ctx, {
			message: assistantMessage(7, 2, "active"),
		});
		expect(row()).toContain("↑8 ↓3");
		const beforeDuplicate = current.calls.length;
		await emit(handlers, "message_end", current.ctx, {
			message: assistantMessage(99, 99, "active"),
		});
		expect(current.calls).toHaveLength(beforeDuplicate);
		expect(row()).toContain("↑8 ↓3");
	});

	it("streams OpenCode tool-call arguments immediately and reconciles whole-interaction totals", async () => {
		const handlers = loadExtension();
		const current = harness();
		const rows = () =>
			current.calls
				.filter(([name, value]) => name === "indicator" && value !== undefined)
				.map(([, value]) =>
					stripTerminalSequences((value as { frames?: string[] }).frames?.[0] ?? ""),
				);
		const message = (
			input: number,
			output: number,
			responseId: string,
			content: unknown[] = [],
		) => ({
			role: "assistant",
			usage: { input, output },
			content,
			api: "openai-completions",
			provider: "opencode",
			model: "openai/gpt-5",
			stopReason: "toolUse",
			timestamp: Date.now(),
			responseId,
		});
		const toolCall = { type: "toolCall", id: "call-1", name: "bash", arguments: {} };

		await emit(handlers, "session_start", current.ctx);
		await emit(handlers, "agent_start", current.ctx);
		await emit(handlers, "turn_start", current.ctx);
		await emit(handlers, "message_end", current.ctx, { message: message(10, 2, "first") });
		await emit(handlers, "turn_start", current.ctx);
		const partial = message(0, 0, "tool-response", [toolCall]);
		await emit(handlers, "message_update", current.ctx, {
			message: partial,
			assistantMessageEvent: {
				type: "toolcall_start",
				contentIndex: 0,
				partial,
			},
		});
		const beforeDeltas = current.calls.length;
		await emit(handlers, "message_update", current.ctx, {
			message: partial,
			assistantMessageEvent: {
				type: "toolcall_delta",
				contentIndex: 0,
				delta: '{"command":',
				partial,
			},
		});
		await emit(handlers, "message_update", current.ctx, {
			message: partial,
			assistantMessageEvent: {
				type: "toolcall_delta",
				contentIndex: 0,
				delta: '{"command":',
				partial,
			},
		});
		expect(current.calls).toHaveLength(beforeDeltas + 2);
		expect(rows().some((row) => row.includes("↑10 ↓5"))).toBe(true);
		expect(rows().at(-1)).toContain("↑10 ↓8");
		expect(rows().at(-1)).not.toMatch(/thinking|thought for/);
		const beforeEnd = current.calls.length;
		await emit(handlers, "message_update", current.ctx, {
			message: partial,
			assistantMessageEvent: {
				type: "toolcall_end",
				contentIndex: 0,
				toolCall,
				partial,
			},
		});
		expect(current.calls).toHaveLength(beforeEnd);
		await emit(handlers, "message_end", current.ctx, {
			message: message(15, 4, "tool-response", [toolCall]),
		});
		expect(rows().at(-1)).toContain("↑25 ↓6");
		expect(rows().at(-1)).not.toMatch(/thinking|thought for/);
	});

	it("preserves estimated values on malformed finals and reconciles exact finals", async () => {
		const handlers = loadExtension();
		const current = harness();
		const row = () => {
			const indicator = current.calls.at(-1)?.[1] as { frames?: string[] } | undefined;
			return stripTerminalSequences(indicator?.frames?.[0] ?? "");
		};
		const message = (input: number, output: number, responseId: string) => ({
			role: "assistant",
			usage: { input, output },
			content: [],
			responseId,
		});

		await emit(handlers, "session_start", current.ctx);
		await emit(handlers, "agent_start", current.ctx);
		await emit(handlers, "turn_start", current.ctx);
		await emit(handlers, "message_update", current.ctx, {
			message: message(0, 0, "malformed"),
			assistantMessageEvent: {
				type: "text_delta",
				contentIndex: 0,
				delta: "abcdefghijkl",
				partial: { content: [{ type: "text", text: "abcdefghijkl" }] },
			},
		});
		expect(row()).toContain("↑0 ↓3");
		await emit(handlers, "message_end", current.ctx, {
			message: message(-1, 9, "malformed"),
		});
		expect(row()).toContain("↑0 ↓3");

		await emit(handlers, "turn_start", current.ctx);
		await emit(handlers, "message_update", current.ctx, {
			message: message(0, 0, "exact"),
			assistantMessageEvent: {
				type: "text_delta",
				contentIndex: 0,
				delta: "abcdefgh",
				partial: { content: [{ type: "text", text: "abcdefgh" }] },
			},
		});
		expect(row()).toContain("↑0 ↓2");
		await emit(handlers, "message_end", current.ctx, {
			message: message(4, 1, "exact"),
		});
		expect(row()).toContain("↑4 ↓1");
	});

	it("ignores an all-zero placeholder after nonzero live usage", async () => {
		const handlers = loadExtension();
		const current = harness();
		const row = () => {
			const indicator = current.calls.at(-1)?.[1] as { frames?: string[] } | undefined;
			return stripTerminalSequences(indicator?.frames?.[0] ?? "");
		};
		const message = (input: number, output: number) => ({
			role: "assistant",
			usage: { input, output },
			provider: "mistral",
			responseId: "zero-snapshot",
		});
		await emit(handlers, "session_start", current.ctx);
		await emit(handlers, "agent_start", current.ctx);
		await emit(handlers, "turn_start", current.ctx);
		await emit(handlers, "message_update", current.ctx, { message: message(20, 4) });
		expect(row()).toContain("↑20 ↓4");
		await emit(handlers, "message_update", current.ctx, { message: message(0, 0) });
		expect(row()).toContain("↑20 ↓4");
		await emit(handlers, "message_end", current.ctx, { message: message(25, 7) });
		expect(row()).toContain("↑25 ↓7");
	});

	it.each(["star-bloom", "pulse"] as const)(
		"rebases the %s spinner and animated text on delayed Loader activation and later rebuilds",
		async (spinner) => {
			runtime.spinner = spinner;
			vi.useFakeTimers();
			vi.setSystemTime(0);
			const handlers = loadExtension();
			const current = harness();
			let loader: Loader | undefined;
			try {
				await emit(handlers, "session_start", current.ctx);
				vi.advanceTimersByTime(5000);
				loader = current.activateLoader();
				const activatedAtFrameZero = loader.render(80)[1] ?? "";
				await emit(handlers, "agent_start", current.ctx);
				await emit(handlers, "turn_start", current.ctx, { turnIndex: 0, timestamp: Date.now() });
				expect(current.calls.filter(([name]) => name === "indicator")).toHaveLength(2);
				expect(loaderPhase(loader.render(80)[1] ?? "")).toEqual(loaderPhase(activatedAtFrameZero));

				vi.advanceTimersByTime(900);
				const beforeRebuild = loader.render(80)[1] ?? "";
				const beforePhase = loaderPhase(beforeRebuild);
				expect(beforePhase[1], "expected animated-text high tier before rebuild").toBeDefined();
				const assistant = {
					role: "assistant",
					usage: { input: 12, output: 3 },
					content: [],
					api: "google-generative-ai",
					provider: "google",
					model: "test",
					stopReason: "toolUse",
					timestamp: Date.now(),
				};
				await emit(handlers, "message_update", current.ctx, { message: assistant });
				const afterRebuild = loader.render(80)[1] ?? "";
				expect(stripTerminalSequences(afterRebuild)).toContain("↑12 ↓3");
				const afterPhase = loaderPhase(afterRebuild);
				expect(afterPhase[1], "expected animated-text high tier after rebuild").toBeDefined();
				expect(afterPhase).toEqual(beforePhase);
				const writesAfterRebuild = current.calls.length;
				await emit(handlers, "message_update", current.ctx, { message: assistant });
				expect(current.calls).toHaveLength(writesAfterRebuild);
			} finally {
				loader?.stop();
				await emit(handlers, "session_shutdown", current.ctx);
				vi.useRealTimers();
			}
		},
	);

	it("regenerates repeated meaningful streaming rows within the worst bounded scheduler budget", async () => {
		runtime.message = "m".repeat(43);
		runtime.spinnerIntervalMs = 997;
		runtime.textIntervalMs = 900;
		const handlers = loadExtension();
		const current = harness();
		await emit(handlers, "session_start", current.ctx);
		await emit(handlers, "agent_start", current.ctx);
		await emit(handlers, "turn_start", current.ctx);
		const callsBeforeStreaming = current.calls.length;
		const started = performance.now();
		for (let output = 1; output <= 20; output++) {
			await emit(handlers, "message_update", current.ctx, {
				message: {
					role: "assistant",
					usage: { input: 999_999_999, output },
					responseId: "performance-stream",
				},
			});
		}
		const elapsedMs = performance.now() - started;
		expect(current.calls).toHaveLength(callsBeforeStreaming + 20);
		expect(elapsedMs).toBeLessThan(10_000);
		await emit(handlers, "session_shutdown", current.ctx);
	});

	it("owns the full fallback row while custom messages are off and releases both APIs", async () => {
		runtime.custom = false;
		const handlers = loadExtension();
		const current = harness();
		await emit(handlers, "session_start", current.ctx);
		await emit(handlers, "agent_start", current.ctx);
		await emit(handlers, "turn_start", current.ctx, { turnIndex: 0, timestamp: Date.now() });
		await emit(handlers, "agent_end", current.ctx);
		expect(current.calls[0]).toEqual(["message", ""]);
		const indicator = current.calls.at(-1)?.[1] as { frames?: string[] };
		expect(stripTerminalSequences(indicator.frames?.[0] ?? "")).toContain("Working…");
		await emit(handlers, "session_shutdown", current.ctx);
		expect(current.calls.slice(-2)).toEqual([
			["indicator", undefined],
			["message", undefined],
		]);
	});

	it("makes zero working-row calls when startup is disabled", async () => {
		runtime.enabled = false;
		const handlers = loadExtension();
		const current = harness();
		await emit(handlers, "session_start", current.ctx);
		await emit(handlers, "agent_start", current.ctx);
		await emit(handlers, "agent_end", current.ctx);
		await emit(handlers, "session_shutdown", current.ctx);
		expect(current.calls).toEqual([]);
		expect(current.forbidden).not.toHaveBeenCalled();
	});
});