import { readFileSync } from "node:fs";
import { stripVTControlCharacters } from "node:util";
import type { Theme } from "@earendil-works/pi-coding-agent";
import { Loader, visibleWidth } from "@earendil-works/pi-tui";
import { describe, expect, it, vi } from "vitest";
import { defaultConfig, type PolishedTuiConfig } from "../extensions/zentui/config";
import {
	AgentDurationClock,
	BUILT_IN_WORKING_LINE_MESSAGES,
	buildWorkingLineFrames,
	buildWorkingLinePreviewFrames,
	buildWorkingLineSpinnerFrames,
	composeWorkingLineRow,
	effectiveWorkingLineMessages,
	formatWorkingLineThought,
	formatWorkingLineTokens,
	MAX_WORKING_LINE_ENTRIES_EXAMINED,
	MAX_WORKING_LINE_FRAME_CELLS,
	MAX_WORKING_LINE_FRAME_CODE_UNITS,
	MAX_WORKING_LINE_FRAMES,
	MAX_WORKING_LINE_MESSAGE_CELLS,
	MAX_WORKING_LINE_NORMALIZED_CODE_UNITS,
	MAX_WORKING_LINE_RAW_CODE_UNITS,
	MAX_WORKING_LINE_ROW_CELLS,
	MAX_WORKING_LINE_STYLE_CODE_UNITS,
	MAX_WORKING_LINE_STYLE_TOKENS,
	normalizeWorkingLineMessage,
	normalizeWorkingLineMessages,
	normalizeWorkingLineStyleSpec,
	normalizeWorkingLineToolLabel,
	remapWorkingLineTextTick,
	selectWorkingLineMessage,
	snapshotWorkingLineHighStyle,
	WORKING_LINE_SPINNERS,
	WorkingLineController,
	workingLineSpinnerWidth,
} from "../extensions/zentui/working-line";

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) {
			return `\x1b[1m${text}\x1b[0m`;
		},
	} as Theme;
}

function config(): PolishedTuiConfig {
	return structuredClone(defaultConfig);
}

const stripTerminalSequences = stripVTControlCharacters;

function strippedFrames(frames: string[]): string[] {
	return frames.map((frame) => stripTerminalSequences(frame));
}

function highTierStart(frame: string): number | undefined {
	const marker = [...frame.matchAll(/\x1b\[96m\x1b\[1m/g)][1];
	if (marker?.index === undefined) return undefined;
	const stripped = stripTerminalSequences(frame);
	const separatorIndex = stripped.indexOf(" ");
	const rowOffset = visibleWidth(stripped.slice(0, separatorIndex + 1));
	return visibleWidth(stripTerminalSequences(frame.slice(0, marker.index))) - rowOffset;
}

function phaseSignature(frame: string): [string, number | undefined] {
	return [stripTerminalSequences(frame).split(" ", 1)[0] ?? "", highTierStart(frame)];
}

function phaseMotionSignature(frames: string[], index: number) {
	const current = phaseSignature(frames[index % frames.length] ?? "");
	const next = phaseSignature(frames[(index + 1) % frames.length] ?? "");
	return {
		spinnerGlyph: current[0],
		textPosition: current[1],
		textDirection:
			current[1] === undefined || next[1] === undefined
				? undefined
				: Math.sign(next[1] - current[1]),
	};
}

function gcdForTest(left: number, right: number): number {
	let a = left;
	let b = right;
	while (b !== 0) [a, b] = [b, a % b];
	return a;
}

describe("working-line token formatting", () => {
	it("formats approximate and exact output identically while validating metadata", () => {
		expect(
			formatWorkingLineTokens({ input: 27_000, output: 1_400, outputApproximate: false }),
		).toBe("↑27k ↓1.4k");
		expect(formatWorkingLineTokens({ input: 27_000, output: 1_400, outputApproximate: true })).toBe(
			"↑27k ↓1.4k",
		);
		expect(
			formatWorkingLineTokens({ input: 1, output: 2, outputApproximate: "yes" } as never),
		).toBeUndefined();
	});

	it("reserves compact maximum-safe tokens within the complete 80-cell row", () => {
		const current = config();
		const composed = composeWorkingLineRow(current.components.workingLine, "x".repeat(43), {
			tokens: {
				input: Number.MAX_SAFE_INTEGER,
				output: Number.MAX_SAFE_INTEGER,
				outputApproximate: true,
			},
		});
		expect(composed.row).toContain("↑9007199255M ↓9007199255M");
		expect(visibleWidth(composed.row)).toBeLessThanOrEqual(MAX_WORKING_LINE_FRAME_CELLS - 2);
	});
});

describe("working-line presets and frame generation", () => {
	it("ships pinned Funky UI Pulse provenance and the required MIT notices", () => {
		const source = readFileSync(
			new URL("../extensions/zentui/working-line-spinners.ts", import.meta.url),
			"utf8",
		);
		expect(source).toContain(
			"https://github.com/pi-zza/funky-ui/blob/e9aed319a4de61c2b2a5e99009821efa7b67b178/packages/funky-ui/extensions/funky-ui/animations.ts",
		);
		expect(source).toContain("37d82d565c1f5a9aa9b31d4b1711fa5604eb04a1");
		expect(source).toContain("Copyright (c) FammasMaz/pi-cc-tools contributors");
		expect(source).toContain("Copyright (c) 2026 Marko Nakic");
		expect(source).toContain("Permission is hereby granted, free of charge");
	});

	it("defines the exact fixed-width spinner frames without preset-owned cadences", () => {
		expect(WORKING_LINE_SPINNERS).toEqual({
			braille: {
				frames: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
			},
			"star-bloom": {
				frames: ["·", "✦", "✧", "✶", "✧", "✦"],
			},
			pinwheel: { frames: ["-", "\\", "|", "/"] },
			"claude-inspired": { frames: ["·", "✢", "✳", "✶", "✻", "✽"] },
			pulse: { frames: ["⠀⠶⠀", "⠰⣿⠆", "⢾⣉⡷", "⣏⠀⣹", "⡁⠀⢈"] },
		});
		for (const [id, preset] of Object.entries(WORKING_LINE_SPINNERS)) {
			const widths = new Set(preset.frames.map((frame) => visibleWidth(frame)));
			expect(widths).toEqual(new Set([id === "pulse" ? 3 : 1]));
			expect(workingLineSpinnerWidth(id as keyof typeof WORKING_LINE_SPINNERS)).toBe(
				id === "pulse" ? 3 : 1,
			);
		}
	});

	it("rejects zero-width and inconsistent spinner definitions defensively", () => {
		const mutable = WORKING_LINE_SPINNERS as unknown as { pulse: { frames: string[] } };
		const original = mutable.pulse.frames;
		try {
			mutable.pulse.frames = ["", ""];
			expect(() => workingLineSpinnerWidth("pulse")).toThrow(/positive fixed width/);
			mutable.pulse.frames = ["⠶", "⠰⣿⠆"];
			expect(() => workingLineSpinnerWidth("pulse")).toThrow(/positive fixed width/);
		} finally {
			mutable.pulse.frames = original;
		}
	});

	it("builds standalone spinner frames for preset validation", () => {
		const current = config();
		current.components.workingLine.messages.custom = false;
		const generated = buildWorkingLineSpinnerFrames(
			current.components.workingLine,
			current.colors,
			theme(),
		);
		expect(strippedFrames(generated.frames)).toEqual(["·", "✦", "✧", "✶", "✧", "✦"]);
		const offset = buildWorkingLineSpinnerFrames(
			current.components.workingLine,
			current.colors,
			theme(),
			7,
		);
		expect(strippedFrames(offset.frames)).toEqual(["✦", "✧", "✶", "✧", "✦", "·"]);
		expect(generated.frames.some((frame) => frame.includes("Working"))).toBe(false);
	});

	it("renders exact owned Pulse frames in preset order", () => {
		const current = config();
		current.components.workingLine.spinner = "pulse";
		current.components.workingLine.spinnerIntervalMs = 180;
		current.components.workingLine.textAnimation = "disabled";
		const expected = ["⠀⠶⠀", "⠰⣿⠆", "⢾⣉⡷", "⣏⠀⣹", "⡁⠀⢈"];
		const generated = buildWorkingLineFrames(
			current.components.workingLine,
			current.colors,
			theme(),
			"Ready",
		);
		expect(strippedFrames(generated.frames)).toEqual(expected.map((frame) => `${frame} Ready`));
		expect(generated.intervalMs).toBe(180);
	});

	it.each([
		["classic", "braille"],
		["classic", "pulse"],
		["kitt", "braille"],
		["kitt", "pulse"],
	] as const)("keeps the %s %s spinner fixed while text tiers move", (textAnimation, spinner) => {
		const current = config();
		current.components.workingLine.spinner = spinner;
		current.components.workingLine.messages.custom = true;
		current.components.workingLine.textAnimation = textAnimation;
		current.components.workingLine.colorSource = "terminal";
		current.colors.workingLineLow = "bright-black";
		current.colors.workingLineMid = "cyan";
		current.colors.workingLineHigh = "bold green";
		const generated = buildWorkingLineFrames(
			current.components.workingLine,
			current.colors,
			theme(),
			"Ready",
			{ tool: "read", elapsedMs: 1000, tokens: { input: 12, output: 3 } },
		);
		const preset = WORKING_LINE_SPINNERS[spinner];
		const observedGlyphs = new Set<string>();
		const textHighPositions = new Set<number>();
		for (const [index, frame] of generated.frames.entries()) {
			const state = generated.frameStates[index];
			const glyph = preset.frames[(state?.spinnerTick ?? 0) % preset.frames.length] ?? "";
			const spinnerPrefix = `\x1b[1;32m${glyph}\x1b[0m `;
			expect(frame.startsWith(spinnerPrefix)).toBe(true);
			observedGlyphs.add(glyph);
			const text = frame.slice(spinnerPrefix.length);
			for (const match of text.matchAll(/\x1b\[1;32m/g)) {
				textHighPositions.add(visibleWidth(stripTerminalSequences(text.slice(0, match.index))));
			}
		}
		expect(observedGlyphs).toEqual(new Set(preset.frames));
		expect(generated.frames.some((frame) => frame.includes("\x1b[90m"))).toBe(true);
		expect(generated.frames.some((frame) => frame.includes("\x1b[36m"))).toBe(true);
		expect(textHighPositions.size).toBeGreaterThan(1);
		expect(generated.textWidth).toBe(visibleWidth(generated.row));
		expect(generated.textOrigin).toBe(workingLineSpinnerWidth(spinner) + 1);
	});

	it.each([
		["classic", "braille"],
		["classic", "pulse"],
		["kitt", "braille"],
		["kitt", "pulse"],
	] as const)(
		"includes the %s %s spinner and separator in the color sweep",
		(animation, spinner) => {
			const current = config();
			current.components.workingLine.spinner = spinner;
			current.components.workingLine.textAnimation = animation;
			current.components.workingLine.animateSpinnerColor = true;
			current.components.workingLine.colorSource = "terminal";
			current.colors.workingLineLow = "bright-black";
			current.colors.workingLineMid = "cyan";
			current.colors.workingLineHigh = "bold green";
			const generated = buildWorkingLineFrames(
				current.components.workingLine,
				current.colors,
				theme(),
				"Ready",
			);
			expect(generated.textOrigin).toBe(0);
			expect(generated.textWidth).toBe(
				workingLineSpinnerWidth(spinner) + 1 + visibleWidth(generated.row),
			);
			expect(generated.frames.some((frame) => frame.startsWith("\x1b[90m"))).toBe(true);
			expect(generated.frames.some((frame) => frame.startsWith("\x1b[1;32m"))).toBe(true);
		},
	);

	it("keeps Static rendering identical when spinner-color participation changes", () => {
		const current = config();
		current.components.workingLine.spinner = "pulse";
		current.components.workingLine.textAnimation = "disabled";
		const fixed = buildWorkingLineFrames(
			current.components.workingLine,
			current.colors,
			theme(),
			"Ready",
		);
		current.components.workingLine.animateSpinnerColor = true;
		const ignored = buildWorkingLineFrames(
			current.components.workingLine,
			current.colors,
			theme(),
			"Ready",
		);
		expect(ignored.frames).toEqual(fixed.frames);
		expect(ignored.frameStates).toEqual(fixed.frameStates);
	});

	it.each([30, 100, 180, 1000] as const)(
		"keeps the canonical configured %s ms cadence for Pulse",
		(intervalMs) => {
			const current = config();
			current.components.workingLine.spinner = "pulse";
			current.components.workingLine.spinnerIntervalMs = intervalMs;
			const owned = buildWorkingLineFrames(
				{ ...current.components.workingLine, messages: { custom: true, values: [] } },
				current.colors,
				theme(),
				"Ready",
			);
			expect(owned.intervalMs).toBeGreaterThanOrEqual(30);
			expect(owned.scheduler.effectiveSpinnerIntervalMs).toBeCloseTo(intervalMs, 8);
		},
	);

	it.each([
		["classic", 160, 30],
		["kitt", 40, 30],
		["disabled", 6, 100],
	] as const)("generates deterministic %s full-row frames", (textAnimation, count, intervalMs) => {
		const current = config();
		current.components.workingLine.textAnimation = textAnimation;
		const result = buildWorkingLineFrames(
			current.components.workingLine,
			current.colors,
			theme(),
			"Working…",
		);
		expect(result.frames).toHaveLength(count);
		expect(result.intervalMs).toBe(intervalMs);
		expect(result.frames.every((frame) => frame.endsWith("\x1b[0m"))).toBe(true);
		expect(new Set(strippedFrames(result.frames))).toEqual(
			new Set(["· Working…", "✦ Working…", "✧ Working…", "✶ Working…"]),
		);
		expect(result.frames.some((frame) => frame.includes("\x1b[1m"))).toBe(
			textAnimation !== "disabled",
		);
	});

	it.each([
		[100, 60],
		[60, 40],
		[160, 100],
	] as const)("schedules exact independent %s/%s ms cadences", (spinnerMs, textMs) => {
		const current = config();
		current.components.workingLine.spinnerIntervalMs = spinnerMs;
		current.components.workingLine.textIntervalMs = textMs;
		const generated = buildWorkingLineFrames(
			current.components.workingLine,
			current.colors,
			theme(),
			"Working…",
		);
		expect(generated.scheduler).toMatchObject({
			effectiveSpinnerIntervalMs: spinnerMs,
			effectiveTextIntervalMs: textMs,
			exact: true,
			spinnerSeamless: true,
			textSeamless: true,
		});
		expect(generated.intervalMs).toBe(Math.max(30, gcdForTest(spinnerMs, textMs)));
	});

	it("regenerates repeated worst-case streaming rows within a bounded budget", () => {
		const current = config();
		const component = current.components.workingLine;
		component.spinner = "star-bloom";
		component.spinnerIntervalMs = 997;
		component.textIntervalMs = 900;
		component.textAnimation = "classic";
		component.animateSpinnerColor = false;
		const started = performance.now();
		let generatedFrames = 0;
		for (let output = 1; output <= 20; output++) {
			const generated = buildWorkingLineFrames(
				component,
				current.colors,
				theme(),
				"m".repeat(MAX_WORKING_LINE_MESSAGE_CELLS),
				{
					tool: "t".repeat(18),
					elapsedMs: 99_999_999,
					thought: { durationMs: 9_999_999, active: true },
					tokens: { input: 999_999_999, output, outputApproximate: true },
				},
			);
			generatedFrames += generated.frames.length;
			expect(generated.frames.length).toBeLessThanOrEqual(MAX_WORKING_LINE_FRAMES);
			expect(generated.frames.reduce((sum, frame) => sum + frame.length, 0)).toBeLessThanOrEqual(
				MAX_WORKING_LINE_FRAME_CODE_UNITS,
			);
		}
		expect(generatedFrames).toBe(19_940);
		expect(performance.now() - started).toBeLessThan(10_000);
	});

	it("permits one Classic text reset per bounded fallback array cycle", () => {
		const current = config();
		current.components.workingLine.spinner = "star-bloom";
		current.components.workingLine.textAnimation = "classic";
		current.components.workingLine.spinnerIntervalMs = 997;
		current.components.workingLine.textIntervalMs = 900;
		current.components.workingLine.animateSpinnerColor = false;
		const started = performance.now();
		const generated = buildWorkingLineFrames(
			current.components.workingLine,
			current.colors,
			theme(),
			"1234567",
		);
		expect(generated.frames).toHaveLength(997);
		expect(generated.frames.length).toBeLessThanOrEqual(MAX_WORKING_LINE_FRAMES);
		expect(generated.frames.reduce((sum, frame) => sum + frame.length, 0)).toBeLessThanOrEqual(
			MAX_WORKING_LINE_FRAME_CODE_UNITS,
		);
		expect(generated.scheduler).toMatchObject({
			quantumMs: 30,
			effectiveSpinnerIntervalMs: 997,
			exact: false,
			spinnerSeamless: true,
			textSeamless: false,
			spinnerAdvances: 30,
			textAdvances: 33,
		});
		expect(generated.textWidth).toBe(7);
		const textCycle = 15;
		expect(new Set(generated.frameStates.map(({ textTick }) => textTick)).size).toBe(textCycle);
		expect(generated.scheduler.textAdvances % textCycle).toBe(3);
		expect(generated.scheduler.effectiveTextIntervalMs).toBeCloseTo(29910 / 33, 8);
		expect(performance.now() - started).toBeLessThan(2000);
	});

	it.each([
		["braille", 10],
		["star-bloom", 6],
		["pinwheel", 4],
		["claude-inspired", 6],
		["pulse", 5],
	] as const)("uses configured cadence with the %s static frames", (spinner, frameCount) => {
		const current = config();
		current.components.workingLine.spinner = spinner;
		current.components.workingLine.spinnerIntervalMs = 160;
		current.components.workingLine.textAnimation = "disabled";
		const result = buildWorkingLineFrames(
			current.components.workingLine,
			current.colors,
			theme(),
			"Ready",
		);
		expect(result.intervalMs).toBe(160);
		expect(result.frames).toHaveLength(frameCount);
	});

	it.each([
		[
			"classic",
			{ braille: 170, "star-bloom": 510, pinwheel: 340, "claude-inspired": 510, pulse: 85 },
		],
		[
			"kitt",
			{ braille: 790, "star-bloom": 474, pinwheel: 316, "claude-inspired": 474, pulse: 790 },
		],
	] as const)(
		"keeps every maximum-width %s spinner animated within hard caps",
		(animation, _counts) => {
			const current = config();
			current.components.workingLine.messages.custom = true;
			current.components.workingLine.textAnimation = animation;
			const runtime = {
				tool: "y".repeat(18),
				elapsedMs: 3_600_000,
				tokens: { input: 12, output: 2 },
			};
			for (const spinner of Object.keys(WORKING_LINE_SPINNERS) as Array<
				keyof typeof WORKING_LINE_SPINNERS
			>) {
				current.components.workingLine.spinner = spinner;
				const generated = buildWorkingLineFrames(
					current.components.workingLine,
					current.colors,
					theme(),
					"x".repeat(MAX_WORKING_LINE_MESSAGE_CELLS),
					runtime,
				);
				expect(visibleWidth(stripTerminalSequences(generated.frames[0] ?? ""))).toBe(
					MAX_WORKING_LINE_FRAME_CELLS,
				);
				expect(generated.frames.length).toBeGreaterThan(
					WORKING_LINE_SPINNERS[spinner].frames.length,
				);
				expect(generated.textAnimation).toBe(animation);
				expect(generated.frames.length).toBeLessThanOrEqual(MAX_WORKING_LINE_FRAMES);
				expect(generated.frames.reduce((sum, frame) => sum + frame.length, 0)).toBeLessThanOrEqual(
					MAX_WORKING_LINE_FRAME_CODE_UNITS,
				);
			}
		},
	);

	it.each([
		["classic", 170],
		["kitt", 790],
	] as const)(
		"keeps maximum-code-unit Braille %s rows grapheme-complete and under the memory cap",
		(animation, _count) => {
			const combiningMessage = `x${"x".repeat(41)}y${"\u0338".repeat(213)}`;
			const zwjMessage = `${"x".repeat(41)}${"👩‍".repeat(71)}💻`;
			for (const message of [combiningMessage, zwjMessage]) {
				expect(message).toHaveLength(MAX_WORKING_LINE_NORMALIZED_CODE_UNITS);
				expect(visibleWidth(message)).toBe(MAX_WORKING_LINE_MESSAGE_CELLS);
				expect(normalizeWorkingLineMessage(`${message}z`)).toBe(message);

				const current = config();
				current.components.workingLine.spinner = "braille";
				current.components.workingLine.messages.custom = true;
				current.components.workingLine.textAnimation = animation;
				current.components.workingLine.colorSource = "terminal";
				const maximumStyle = "underline fg:#ffffff bg:#ffffff";
				current.colors.workingLineLow = maximumStyle;
				current.colors.workingLineMid = maximumStyle;
				current.colors.workingLineHigh = maximumStyle;
				const generated = buildWorkingLineFrames(
					current.components.workingLine,
					current.colors,
					theme(),
					`${message}z`,
					{
						tool: "y".repeat(18),
						elapsedMs: 3_600_000,
						tokens: { input: 1, output: 2 },
					},
				);
				expect(generated.message).toBe(message);
				expect(generated.frames.length).toBeGreaterThan(
					WORKING_LINE_SPINNERS.braille.frames.length,
				);
				expect(generated.textAnimation).toBe(animation);
				expect(visibleWidth(stripTerminalSequences(generated.frames[0] ?? ""))).toBe(
					MAX_WORKING_LINE_FRAME_CELLS,
				);
				expect(generated.frames.reduce((sum, frame) => sum + frame.length, 0)).toBeLessThanOrEqual(
					MAX_WORKING_LINE_FRAME_CODE_UNITS,
				);
				for (const frame of strippedFrames(generated.frames))
					expect(frame.slice(2)).toBe(generated.row);
			}
		},
	);

	it.each(["classic", "kitt"] as const)(
		"deduplicates adversarial repeated palette tokens without disabling %s animation",
		(animation) => {
			const current = config();
			current.components.workingLine.spinner = "braille";
			current.components.workingLine.messages.custom = true;
			current.components.workingLine.textAnimation = animation;
			current.components.workingLine.colorSource = "terminal";
			current.colors.workingLineLow = "dim ".repeat(1000);
			current.colors.workingLineMid = "cyan ".repeat(1000);
			current.colors.workingLineHigh = "bold ".repeat(1000);
			const generated = buildWorkingLineFrames(
				current.components.workingLine,
				current.colors,
				theme(),
				"x".repeat(MAX_WORKING_LINE_MESSAGE_CELLS),
				{ tool: "y".repeat(18), elapsedMs: 3_600_000, tokens: { input: 1, output: 2 } },
			);
			expect(generated.textAnimation).toBe(animation);
			expect(generated.frames.length).toBeGreaterThan(WORKING_LINE_SPINNERS.braille.frames.length);
			expect(generated.frames.reduce((sum, frame) => sum + frame.length, 0)).toBeLessThanOrEqual(
				MAX_WORKING_LINE_FRAME_CODE_UNITS,
			);
			expect(generated.frames.some((frame) => frame.includes("\x1b[1m"))).toBe(true);
		},
	);

	it("bounds and canonicalizes Working-line-only palette specs", () => {
		expect(normalizeWorkingLineStyleSpec("bold ".repeat(1000))).toBe("bold");
		expect(normalizeWorkingLineStyleSpec("DIMMED dim fg:202 FG:202 bold bold")).toBe(
			"dim fg:202 bold",
		);
		expect(normalizeWorkingLineStyleSpec("bold italic underline red")).toBe(
			"bold italic underline red",
		);
		expect(normalizeWorkingLineStyleSpec("bold italic underline red dim")).toBeUndefined();
		expect(MAX_WORKING_LINE_STYLE_TOKENS).toBe(4);
		expect(MAX_WORKING_LINE_STYLE_CODE_UNITS).toBe(48);
	});

	it.each([
		["no modifier", [], "\x1b[38;5;202m"],
		["one modifier", ["bold"], "\x1b[38;5;202m\x1b[1m"],
		["two modifiers", ["bold", "italic"], "\x1b[38;5;202m\x1b[3m\x1b[1m"],
		["three modifiers", ["bold", "italic", "underline"], "\x1b[38;5;202m\x1b[4m\x1b[3m\x1b[1m"],
	] as const)("persists theme high style with %s", (_label, modifiers, expected) => {
		const current = config();
		current.components.workingLine.colorSource = "theme";
		current.colors.workingLineHigh = [...modifiers, "accent"].join(" ");
		const separateTheme = {
			fg: (_color: string, text: string) => `\x1b[38;5;202m${text}\x1b[0m`,
			bold: (text: string) => `\x1b[1m${text}\x1b[0m`,
			italic: (text: string) => `\x1b[3m${text}\x1b[0m`,
			underline: (text: string) => `\x1b[4m${text}\x1b[0m`,
		};
		expect(
			snapshotWorkingLineHighStyle(separateTheme, current.components.workingLine, current.colors),
		).toBe(expected);
	});

	it.each([
		["named", "bold italic underline cyan", "\x1b[1;3;4;36m"],
		["256-color", "bold italic underline fg:202", "\x1b[1;3;4;38;5;202m"],
		["truecolor", "bold italic underline #bf5700", "\x1b[1;3;4;38;2;191;87;0m"],
	] as const)("persists combined terminal %s high style", (_label, style, expected) => {
		const current = config();
		current.components.workingLine.colorSource = "terminal";
		current.colors.workingLineHigh = style;
		expect(
			snapshotWorkingLineHighStyle(theme(), current.components.workingLine, current.colors),
		).toBe(expected);
	});

	it("reverses full-row KITT motion without duplicating the wording endpoint", () => {
		const current = config();
		current.components.workingLine.textAnimation = "kitt";
		const { frames } = buildWorkingLineFrames(
			current.components.workingLine,
			current.colors,
			theme(),
			"abcdefgh",
		);
		const brightHead = (frame: string) => frame.match(/\x1b\[96m\x1b\[1m([a-h])/)?.[1];
		const movingHeads = frames
			.map(brightHead)
			.filter((value): value is string => value !== undefined)
			.filter((value, index, values) => index === 0 || value !== values[index - 1]);
		expect(movingHeads.slice(0, 9)).toEqual(["a", "b", "c", "d", "e", "f", "g", "h", "g"]);
	});

	it.each(["你好世界", "e\u0301lan", "👩‍💻 works", "👨‍👩‍👧‍👦 family"])(
		"keeps graphemes and visible text stable for %s",
		(message) => {
			const current = config();
			const result = buildWorkingLineFrames(
				current.components.workingLine,
				current.colors,
				theme(),
				message,
			);
			const stripped = strippedFrames(result.frames);
			const expectedWidth = visibleWidth(
				`${WORKING_LINE_SPINNERS["star-bloom"].frames[0]} ${result.message}`,
			);
			for (const frame of stripped) {
				expect(frame.slice(2)).toBe(result.message);
				expect(visibleWidth(frame)).toBe(expectedWidth);
			}
		},
	);

	it.each(["界", "😀"])("gives every occupied KITT head cell the high tier for %s", (message) => {
		const current = config();
		current.components.workingLine.textAnimation = "kitt";
		const result = buildWorkingLineFrames(
			current.components.workingLine,
			current.colors,
			theme(),
			`${message}a`,
		);
		expect(result.frames.some((frame) => frame.includes(`\x1b[96m\x1b[1m${message}`))).toBe(true);
		const expectedWidth = visibleWidth(`· ${result.message}`);
		for (const frame of strippedFrames(result.frames)) {
			expect(frame.slice(2)).toBe(result.message);
			expect(visibleWidth(frame)).toBe(expectedWidth);
		}
	});

	it.each(["star-bloom", "pulse"] as const)(
		"fits the complete maximum %s row through Pi's real Loader without a wrapped blank row",
		(spinner) => {
			const current = config();
			current.components.workingLine.spinner = spinner;
			current.components.workingLine.textAnimation = "disabled";
			current.components.workingLine.messages.custom = true;
			const generated = buildWorkingLineFrames(
				current.components.workingLine,
				current.colors,
				theme(),
				"x".repeat(MAX_WORKING_LINE_MESSAGE_CELLS),
				{
					tool: "y".repeat(18),
					elapsedMs: 3_600_000,
					tokens: { input: 12, output: 2 },
				},
			);
			const [frame] = generated.frames;
			expect(visibleWidth(stripTerminalSequences(frame))).toBe(MAX_WORKING_LINE_FRAME_CELLS);
			const loader = new Loader(
				{ requestRender() {} } as never,
				(text) => text,
				(text) => text,
				"",
				{ frames: [frame], intervalMs: generated.intervalMs },
			);
			try {
				const rendered = loader.render(MAX_WORKING_LINE_ROW_CELLS);
				expect(rendered).toHaveLength(2);
				expect(stripTerminalSequences(rendered[1] ?? "")).toBe(
					` ${stripTerminalSequences(frame)}  `,
				);
				expect(visibleWidth(rendered[1] ?? "")).toBe(MAX_WORKING_LINE_ROW_CELLS);
			} finally {
				loader.stop();
			}
		},
	);

	it("compensates for the real Loader resetting every installed indicator to frame zero", () => {
		vi.useFakeTimers();
		const loader = new Loader(
			{ requestRender() {} } as never,
			(text) => text,
			(text) => text,
			"",
			{ frames: ["zero", "one", "two"], intervalMs: 30 },
		);
		try {
			vi.advanceTimersByTime(60);
			expect(stripTerminalSequences(loader.render(20)[1] ?? "")).toContain("two");
			loader.setIndicator({ frames: ["sampled-two", "next"], intervalMs: 30 });
			expect(stripTerminalSequences(loader.render(20)[1] ?? "")).toContain("sampled-two");
		} finally {
			loader.stop();
			vi.useRealTimers();
		}
	});

	it("honors independent working-line palette overrides", () => {
		const current = config();
		current.components.workingLine.colorSource = "terminal";
		current.components.workingLine.textAnimation = "disabled";
		current.colors.workingLineMid = "bold red";
		current.colors.workingLineHigh = "bold green";
		const [frame] = buildWorkingLineFrames(
			current.components.workingLine,
			current.colors,
			theme(),
			"Ready",
		).frames;
		expect(frame).not.toContain("\x1b[1;32m");
		expect(frame).toContain("\x1b[1;31m· Ready");
	});

	it.each(["classic", "kitt"] as const)(
		"moves %s color through the complete composed row and preserves phase offsets",
		(animation) => {
			const current = config();
			current.components.workingLine.messages.custom = true;
			current.components.workingLine.textAnimation = animation;
			const runtime = { tool: "read", elapsedMs: 62_000, tokens: { input: 12, output: 3 } };
			const generated = buildWorkingLineFrames(
				current.components.workingLine,
				current.colors,
				theme(),
				"Ready",
				runtime,
			);
			expect(new Set(strippedFrames(generated.frames))).toEqual(
				new Set([
					"· Ready · read · 1m02s · ↑12 ↓3",
					"✦ Ready · read · 1m02s · ↑12 ↓3",
					"✧ Ready · read · 1m02s · ↑12 ↓3",
					"✶ Ready · read · 1m02s · ↑12 ↓3",
				]),
			);
			expect(
				generated.frames.some((frame) =>
					[...frame.matchAll(/\x1b\[96m\x1b\[1m([^\x1b]*)/g)].some((match) =>
						match[1]?.includes("↓"),
					),
				),
			).toBe(true);
			const offset = buildWorkingLineFrames(
				current.components.workingLine,
				current.colors,
				theme(),
				"Ready",
				runtime,
				7,
				7,
			);
			expect(offset.frameStates[0]).toEqual({ spinnerTick: 7, textTick: 7 });
		},
	);

	it("keeps preview mode and configured segment presence stable", () => {
		const current = config();
		current.components.workingLine.messages = { custom: true, values: ["Configured"] };
		current.components.workingLine.segments = {
			tool: true,
			elapsed: false,
			thought: false,
			tokens: true,
		};
		const generated = buildWorkingLinePreviewFrames(
			current.components.workingLine,
			current.colors,
			theme(),
		);
		for (const frame of strippedFrames(generated.frames)) {
			expect(frame).toMatch(/^[·✦✧✶] Configured · read · ↑1.2k ↓56$/);
			expect(frame).not.toContain("1m02s");
		}
		current.components.workingLine.messages.custom = false;
		const fallback = strippedFrames(
			buildWorkingLinePreviewFrames(current.components.workingLine, current.colors, theme()).frames,
		);
		expect(fallback.every((frame) => frame.includes(" Working… · read · ↑1.2k ↓56"))).toBe(true);
	});
});

describe("working-line phase mapping", () => {
	it.each([
		["classic", 5],
		["kitt", 15],
	] as const)(
		"preserves %s position and direction across spinner-color domain changes",
		(animation, tick) => {
			const included = remapWorkingLineTextTick(animation, 10, tick, animation, 12, 2, 0);
			const restored = remapWorkingLineTextTick(animation, 12, included, animation, 10, 0, 2);
			expect(restored).toBe(tick);
		},
	);
});

describe("working-line message normalization and selection", () => {
	it("strips terminal/control/bidi data, normalizes whitespace, and truncates safely", () => {
		const unsafe =
			"\x1b[31m  hello\x1b[0m\tworld\n\x1b]8;;https://bad.test\x07link\x1b]8;;\x07\u202E  ";
		expect(normalizeWorkingLineMessage(unsafe)).toBe("hello world link");
		expect(normalizeWorkingLineMessage(`${"界".repeat(30)}👩‍💻`)).toBe(
			"界".repeat(Math.floor(MAX_WORKING_LINE_MESSAGE_CELLS / 2)),
		);
		expect(visibleWidth(normalizeWorkingLineMessage("a".repeat(100)))).toBe(
			MAX_WORKING_LINE_MESSAGE_CELLS,
		);
	});

	it("removes C1 sequences and embedded invisible controls while preserving grapheme joiners", () => {
		const unsafe =
			"\u009b31mRed\u009b0m \u009d2;title\u0007Visible \u0090secret\u009c Done\u200b\u206a\u206f";
		expect(normalizeWorkingLineMessage(unsafe)).toBe("Red Visible Done");
		expect(normalizeWorkingLineMessage("\u200b\u206a\u206f\u034f")).toBe("");
		expect(normalizeWorkingLineMessage("pay\u034fpal word\u2060joiner bidi\u200emark")).toBe(
			"paypal wordjoiner bidimark",
		);
		expect(normalizeWorkingLineMessage("👩‍💻 ❤️ 👨‍👩‍👧‍👦 क्‍ष")).toBe("👩‍💻 ❤️ 👨‍👩‍👧‍👦 क्‍ष");
	});

	it("bounds raw normalization and invalid-entry examination before output caps", () => {
		expect(
			normalizeWorkingLineMessage(
				`${"\u200b".repeat(MAX_WORKING_LINE_RAW_CODE_UNITS)}Visible beyond the raw cap`,
			),
		).toBe("");
		expect(normalizeWorkingLineMessage("x".repeat(1_000_000))).toBe(
			"x".repeat(MAX_WORKING_LINE_MESSAGE_CELLS),
		);
		expect(
			normalizeWorkingLineMessage(`${"\u200b".repeat(MAX_WORKING_LINE_RAW_CODE_UNITS - 1)}👩‍💻`),
		).toBe("");
		const combiningGrapheme = `x${"\u0338".repeat(20)}`;
		const combiningOutput = normalizeWorkingLineMessage(combiningGrapheme.repeat(43));
		expect(combiningOutput).toBe(
			combiningGrapheme.repeat(
				Math.floor(MAX_WORKING_LINE_NORMALIZED_CODE_UNITS / combiningGrapheme.length),
			),
		);
		expect(combiningOutput.length).toBeLessThanOrEqual(MAX_WORKING_LINE_NORMALIZED_CODE_UNITS);
		const oversizedZwjGrapheme = `${"👩‍".repeat(100)}💻`;
		expect(normalizeWorkingLineMessage(oversizedZwjGrapheme)).toBe("");
		const fallback = buildWorkingLineFrames(
			config().components.workingLine,
			config().colors,
			theme(),
			oversizedZwjGrapheme,
		);
		expect(fallback.message).toBe("Working…");
		expect(fallback.frames.reduce((sum, frame) => sum + frame.length, 0)).toBeLessThanOrEqual(
			MAX_WORKING_LINE_FRAME_CODE_UNITS,
		);
		const values = [
			...Array.from({ length: 31 }, (_, index) => `valid-${index}`),
			...Array.from({ length: MAX_WORKING_LINE_ENTRIES_EXAMINED - 32 }, () => "\u200b"),
			"last-valid",
			"not-examined",
		];
		const normalized = normalizeWorkingLineMessages(values);
		expect(normalized).toHaveLength(32);
		expect(normalized.at(-1)).toBe("last-valid");
		expect(normalized).not.toContain("not-examined");
	});

	it("deduplicates normalized values, discards empties, and caps the pool", () => {
		const values = [
			" A ",
			"A",
			"\x1b[31mA\x1b[0m",
			"\n",
			...Array.from({ length: 60 }, (_, index) => `m${index}`),
		];
		const normalized = normalizeWorkingLineMessages(values);
		expect(normalized[0]).toBe("A");
		expect(normalized).toHaveLength(48);
		expect(new Set(normalized).size).toBe(48);
	});

	it("supports custom toggle, fallback, and uniform endpoint-safe selection", () => {
		const current = config().components.workingLine;
		expect(BUILT_IN_WORKING_LINE_MESSAGES).toHaveLength(16);
		expect(effectiveWorkingLineMessages(current)).toEqual(BUILT_IN_WORKING_LINE_MESSAGES);
		current.messages = { custom: true, values: ["Custom"] };
		expect(effectiveWorkingLineMessages(current)).toEqual(["Custom"]);
		current.messages.values = [];
		expect(effectiveWorkingLineMessages(current)).toEqual(["Working…"]);
		current.messages.values = ["\u200b\u206a"];
		expect(effectiveWorkingLineMessages(current)).toEqual(["Working…"]);
		current.messages.custom = false;
		const random = vi.fn(() => 0.9);
		expect(selectWorkingLineMessage(current, random)).toBe("Working…");
		expect(random).not.toHaveBeenCalled();
		current.messages.custom = true;
		current.messages.values = ["A", "B"];
		expect(selectWorkingLineMessage(current, () => 0)).toBe("A");
		expect(selectWorkingLineMessage(current, () => 0.999999)).toBe("B");
		expect(selectWorkingLineMessage(current, () => 1)).toBe("B");
	});
});

describe("working-line row composition", () => {
	it("sanitizes tools and applies bounded wording, tool, elapsed, token priority", () => {
		const component = config().components.workingLine;
		component.messages.custom = true;
		expect(
			normalizeWorkingLineToolLabel(
				"\x1b[31mread\x1b[0m \x1b]2;title\x07safe \u009b32mtool\u009b0m \u009dsecret\u009c",
			),
		).toBe("read safe tool");
		expect(normalizeWorkingLineToolLabel("a".repeat(30))).toBe(`${"a".repeat(17)}…`);
		const all = composeWorkingLineRow(component, "Working…", {
			tool: "read",
			elapsedMs: 62_000,
			tokens: { input: 1234, output: 56 },
		});
		expect(all.row).toBe("Working… · read · 1m02s · ↑1.2k ↓56");
		expect(2 + visibleWidth(all.row) + 1 + 2).toBeLessThanOrEqual(MAX_WORKING_LINE_ROW_CELLS);
		component.spinner = "pulse";
		const constrained = composeWorkingLineRow(component, "x".repeat(43), {
			tool: "parallel-tool-label-too-long",
			elapsedMs: 360_000_000,
			tokens: { input: Number.MAX_SAFE_INTEGER, output: Number.MAX_SAFE_INTEGER },
		});
		expect(constrained.row).toBe(`${"x".repeat(43)} · ↑9007199255M ↓9007199255M`);
		expect(workingLineSpinnerWidth("pulse") + 1 + visibleWidth(constrained.row)).toBeLessThan(
			MAX_WORKING_LINE_FRAME_CELLS,
		);
		expect(constrained.row).not.toContain("parallel");
	});

	it("reserves exact Tokens, then allocates Message, Elapsed, and truncated Tool within 80 cells", () => {
		const component = config().components.workingLine;
		const composed = composeWorkingLineRow(component, "x".repeat(43), {
			tool: "parallel-tool-label",
			elapsedMs: 62_000,
			tokens: { input: 12, output: 3 },
		});
		expect(composed.row).toBe(`${"x".repeat(43)} · parallel-to… · 1m02s · ↑12 ↓3`);
		expect(composed.row.indexOf("1m02s")).toBeLessThan(composed.row.indexOf("↑12 ↓3"));
		expect(composed.row).not.toContain("parallel-tool-label");
		expect(workingLineSpinnerWidth(component.spinner) + 1 + visibleWidth(composed.row) + 3).toBe(
			MAX_WORKING_LINE_ROW_CELLS,
		);
	});

	it("honors independent segment toggles for custom and fallback wording", () => {
		const component = config().components.workingLine;
		const runtime = { tool: "read", elapsedMs: 1_000, tokens: { input: 12, output: 3 } };
		component.segments = { tool: false, elapsed: true, thought: false, tokens: false };
		expect(composeWorkingLineRow(component, "Configured", runtime).row).toBe("Configured · 1s");
		component.messages.custom = false;
		expect(composeWorkingLineRow(component, "Working…", runtime).row).toBe("Working… · 1s");
	});
});

describe("working-line thought segment", () => {
	it("formats active zero and floors active/inactive duration consistently", () => {
		expect(formatWorkingLineThought({ durationMs: 0, active: true })).toBe("thinking 0s");
		expect(formatWorkingLineThought({ durationMs: 10_999, active: true })).toBe("thinking 10s");
		expect(formatWorkingLineThought({ durationMs: 10_999, active: false })).toBe("thought for 10s");
		expect(formatWorkingLineThought({ durationMs: 0, active: false })).toBeUndefined();
	});

	it("uses Thought before Elapsed and Tool allocation while preserving token text and row cap", () => {
		const component = config().components.workingLine;
		component.spinner = "pulse";
		const composed = composeWorkingLineRow(component, "Ready", {
			tool: "parallel-tool-label",
			elapsedMs: Number.MAX_SAFE_INTEGER,
			thought: { durationMs: 10_000, active: true },
			tokens: { input: Number.MAX_SAFE_INTEGER, output: Number.MAX_SAFE_INTEGER },
		});
		expect(composed.row).toContain("↑9007199255M ↓9007199255M");
		expect(composed.row).toContain("thinking");
		expect(composed.row).not.toContain("parallel-tool-label");
		expect(
			workingLineSpinnerWidth(component.spinner) + 1 + visibleWidth(composed.row) + 3,
		).toBeLessThanOrEqual(MAX_WORKING_LINE_ROW_CELLS);
	});
});

describe("working-line runtime ownership", () => {
	function runtime(
		enabled: boolean,
		random = () => 0.75,
		now: () => number = Date.now,
		getTheme: () => Theme = theme,
	) {
		const current = config();
		current.components.workingLine.enabled = enabled;
		current.components.workingLine.messages = { custom: true, values: ["A", "B"] };
		const clock = new AgentDurationClock();
		const calls: Array<[string, unknown?]> = [];
		const ctx = {
			hasUI: true,
			mode: "tui",
			ui: {
				setWorkingMessage(value?: string) {
					calls.push(["message", value]);
				},
				setWorkingIndicator(value?: unknown) {
					calls.push(["indicator", value]);
				},
			},
		};
		return {
			current,
			clock,
			calls,
			ctx,
			controller: new WorkingLineController(() => current, getTheme, clock, random, now),
		};
	}

	it("makes exactly zero working-row calls while disabled", () => {
		const harness = runtime(false);
		harness.controller.startSession(harness.ctx);
		harness.clock.start();
		harness.controller.startAgent(harness.ctx);
		harness.controller.startTurn(harness.ctx);
		harness.controller.finishAgent(harness.ctx);
		harness.controller.dispose(harness.ctx);
		harness.clock.reset();
		expect(harness.calls).toEqual([]);
	});

	it("fails open when either public capability is missing", () => {
		const harness = runtime(true);
		for (const ui of [{ setWorkingMessage: vi.fn() }, { setWorkingIndicator: vi.fn() }]) {
			const result = harness.controller.startSession({ hasUI: true, mode: "tui", ui });
			expect(result.applied).toBe(false);
			expect(Object.values(ui).every((fn) => !fn.mock.calls.length)).toBe(true);
		}
		expect(harness.calls).toEqual([]);
	});

	it("owns and styles the full fallback row with no RNG when custom messages are off", () => {
		const random = vi.fn(() => 0.75);
		const harness = runtime(true, random);
		harness.current.components.workingLine.spinner = "pulse";
		harness.current.components.workingLine.messages.custom = false;
		harness.controller.startSession(harness.ctx);
		harness.clock.start();
		harness.controller.startAgent(harness.ctx);
		harness.controller.startTurn(harness.ctx);
		harness.controller.updateTokens({ input: 12, output: 3 }, harness.ctx);
		expect(random).not.toHaveBeenCalled();
		expect(harness.calls[0]).toEqual(["message", ""]);
		const indicator = harness.calls.at(-1)?.[1] as { frames: string[] } | undefined;
		expect(
			strippedFrames(indicator?.frames ?? []).every((frame) =>
				frame.includes("Working… · 0s · ↑12 ↓3"),
			),
		).toBe(true);
		harness.controller.dispose(harness.ctx);
		expect(harness.calls.slice(-2)).toEqual([
			["indicator", undefined],
			["message", undefined],
		]);
	});

	it("does not rewrite Static frames for text-speed or spinner-color participation changes", () => {
		const harness = runtime(true);
		harness.current.components.workingLine.textAnimation = "disabled";
		harness.controller.startSession(harness.ctx);
		harness.calls.length = 0;
		harness.current.components.workingLine.textIntervalMs = 40;
		harness.current.components.workingLine.animateSpinnerColor = true;
		expect(harness.controller.reconcile(harness.ctx).applied).toBe(true);
		expect(harness.calls).toEqual([]);
	});

	it("selects exactly once per turn_start and keeps that message through tool activity", () => {
		const random = vi.fn(() => 0.75);
		const harness = runtime(true, random);
		harness.controller.startSession(harness.ctx);
		expect(harness.controller.currentMessage()).toBe("A");
		harness.clock.start();
		harness.controller.startAgent(harness.ctx);
		expect(random).not.toHaveBeenCalled();
		harness.controller.startTurn(harness.ctx);
		expect(random).toHaveBeenCalledTimes(1);
		expect(harness.controller.currentMessage()).toBe("B");
		harness.controller.startTool("one", "read", harness.ctx);
		harness.controller.finishTool("one", harness.ctx);
		harness.current.components.workingLine.spinner = "pinwheel";
		harness.controller.reconcile(harness.ctx);
		expect(random).toHaveBeenCalledTimes(1);
		expect(harness.controller.currentMessage()).toBe("B");
		harness.controller.startTurn(harness.ctx);
		expect(random).toHaveBeenCalledTimes(2);
	});

	it("reconciles live message edits deterministically without rerolling the turn", () => {
		const random = vi.fn(() => 0.75);
		const harness = runtime(true, random);
		harness.controller.startSession(harness.ctx);
		harness.controller.startTurn(harness.ctx);
		expect(harness.controller.currentMessage()).toBe("B");
		harness.current.components.workingLine.messages.values = ["B", "C"];
		harness.controller.reconcile(harness.ctx);
		expect(harness.controller.currentMessage()).toBe("B");
		harness.current.components.workingLine.messages.values = ["C"];
		harness.controller.reconcile(harness.ctx);
		expect(harness.controller.currentMessage()).toBe("C");
		harness.current.components.workingLine.messages.custom = false;
		harness.controller.reconcile(harness.ctx);
		expect(harness.controller.currentMessage()).toBe("Working…");
		harness.current.components.workingLine.messages = { custom: true, values: ["A", "B"] };
		harness.controller.reconcile(harness.ctx);
		expect(harness.controller.currentMessage()).toBe("A");
		expect(random).toHaveBeenCalledTimes(1);
	});

	it("reinstalls full rows only for visible token/tool changes and tracks parallel tools", () => {
		const harness = runtime(true);
		harness.current.components.workingLine.segments.elapsed = false;
		harness.controller.startSession(harness.ctx);
		expect(harness.calls[0]).toEqual(["message", ""]);
		harness.clock.start();
		harness.controller.startAgent(harness.ctx);
		harness.controller.startTurn(harness.ctx);
		harness.calls.length = 0;
		const usage = { role: "assistant" as const, usage: { input: 120, output: 7 } };
		harness.controller.updateTokens(usage.usage, harness.ctx);
		harness.controller.updateTokens(usage.usage, harness.ctx);
		harness.controller.startTool("a", "read", harness.ctx);
		harness.controller.startTool("b", "bash", harness.ctx);
		harness.controller.startTool("b", "bash", harness.ctx);
		const text = () =>
			stripTerminalSequences(
				(harness.calls.at(-1)?.[1] as { frames?: string[] } | undefined)?.frames?.[0] ?? "",
			);
		expect(text()).toMatch(/B · bash · ↑120 ↓7/);
		harness.controller.finishTool("b", harness.ctx);
		expect(text()).toMatch(/B · read · ↑120 ↓7/);
		harness.controller.finishTool("a", harness.ctx);
		expect(text()).toMatch(/B · ↑120 ↓7/);
		expect(harness.calls.every(([name]) => name === "indicator")).toBe(true);
		expect(harness.calls).toHaveLength(5);
		harness.controller.finishTool("missing", harness.ctx);
		expect(harness.calls).toHaveLength(5);
		harness.controller.startTurn(harness.ctx);
		expect(text()).toMatch(/↑120 ↓7/);
		expect(harness.calls).toHaveLength(5);
		harness.current.components.workingLine.segments.tool = false;
		harness.controller.reconcile(harness.ctx);
		expect(harness.calls).toHaveLength(5);
		harness.controller.dispose(harness.ctx);
		harness.clock.reset();
	});

	it.each([
		["classic", "star-bloom", 900],
		["classic", "pulse", 900],
		["kitt", "star-bloom", 1400],
		["kitt", "pulse", 1400],
	] as const)(
		"preserves %s spatial position, KITT direction, and %s phase across token/tool widths",
		(animation, spinner, firstChangeAt) => {
			let now = 0;
			const harness = runtime(
				true,
				() => 0,
				() => now,
			);
			harness.current.components.workingLine.messages.values = ["Stable"];
			harness.current.components.workingLine.spinner = spinner;
			harness.current.components.workingLine.textAnimation = animation;
			harness.current.components.workingLine.segments.elapsed = false;
			harness.controller.startSession(harness.ctx);
			harness.controller.startAgent(harness.ctx);
			harness.controller.startTurn(harness.ctx);
			const activation = harness.calls.at(-1)?.[1] as {
				frames: string[];
				intervalMs: number;
			};

			now = firstChangeAt;
			const activationIndex =
				Math.floor(firstChangeAt / activation.intervalMs) % activation.frames.length;
			harness.controller.updateTokens({ input: 12, output: 3 }, harness.ctx);
			const withTokens = harness.calls.at(-1)?.[1] as { frames: string[] };
			const beforeSignature = phaseSignature(activation.frames[activationIndex] ?? "");
			const afterSignature = phaseSignature(withTokens.frames[0] ?? "");
			expect(afterSignature[0]).toBe(beforeSignature[0]);
			if (beforeSignature[1] !== undefined) expect(afterSignature[1]).toBe(beforeSignature[1]);

			now += 100;
			harness.controller.startTool("one", "read", harness.ctx);
			const withTool = harness.calls.at(-1)?.[1] as { frames: string[]; intervalMs: number };
			const carriedRemainder = firstChangeAt % withTool.intervalMs;
			const withTokensIndex = Math.floor((carriedRemainder + 100) / withTool.intervalMs);
			expect(phaseSignature(withTool.frames[0] ?? "")).toEqual(
				phaseSignature(withTokens.frames[withTokensIndex] ?? ""),
			);
		},
	);

	it.each([
		[
			"speed",
			(current: PolishedTuiConfig): void => {
				current.components.workingLine.spinnerIntervalMs = 60;
			},
		],
		[
			"preset",
			(current: PolishedTuiConfig): void => {
				current.components.workingLine.spinner = "pulse";
			},
		],
		[
			"width",
			(current: PolishedTuiConfig): void => {
				current.components.workingLine.messages.values = ["A much wider stable message"];
			},
		],
		[
			"animation",
			(current: PolishedTuiConfig): void => {
				current.components.workingLine.textAnimation = "kitt";
			},
		],
	] as const)("carries fractional phase across a live %s change", (_kind, change) => {
		let now = 0;
		const harness = runtime(
			true,
			() => 0,
			() => now,
		);
		harness.current.components.workingLine.messages.values = ["Stable"];
		harness.current.components.workingLine.spinnerIntervalMs = 100;
		harness.current.components.workingLine.textIntervalMs = 100;
		harness.current.components.workingLine.segments.elapsed = false;
		harness.controller.startSession(harness.ctx);
		const before = harness.calls.at(-1)?.[1] as { frames: string[]; intervalMs: number };

		now = 250;
		change(harness.current);
		harness.controller.reconcile(harness.ctx);
		const after = harness.calls.at(-1)?.[1] as { frames: string[]; intervalMs: number };
		const sampledIndex = Math.floor(250 / before.intervalMs);
		if (_kind !== "preset") {
			expect(phaseSignature(after.frames[0] ?? "")[0]).toBe(
				phaseSignature(before.frames[sampledIndex] ?? "")[0],
			);
		} else {
			expect(after.frames[0]).toBeDefined();
		}

		now = 250 + Math.ceil(after.intervalMs / 2);
		harness.controller.updateTokens({ input: 1, output: 1 }, harness.ctx);
		const carried = harness.calls.at(-1)?.[1] as { frames: string[] };
		expect(phaseSignature(carried.frames[0] ?? "")[0]).toBe(
			phaseSignature(after.frames[1] ?? "")[0],
		);
	});

	it("advances logical frame zero on rapid rebuilds without relying on Loader ticks", () => {
		let now = 0;
		const harness = runtime(
			true,
			() => 0,
			() => now,
		);
		harness.current.components.workingLine.messages.values = ["Stable"];
		harness.current.components.workingLine.spinner = "pulse";
		harness.current.components.workingLine.spinnerIntervalMs = 100;
		harness.current.components.workingLine.textAnimation = "disabled";
		harness.current.components.workingLine.segments.elapsed = false;
		harness.controller.startSession(harness.ctx);
		const original = harness.calls.at(-1)?.[1] as { frames: string[] };
		for (now = 20; now <= 200; now += 20) {
			harness.controller.updateTokens({ input: now, output: 1 }, harness.ctx);
			const rebuilt = harness.calls.at(-1)?.[1] as { frames: string[] };
			const expectedIndex = Math.floor(now / 100);
			expect(phaseSignature(rebuilt.frames[0] ?? "")[0]).toBe(
				phaseSignature(original.frames[expectedIndex] ?? "")[0],
			);
		}
	});

	it("matches uninterrupted exact independent spinner/text schedules during rapid rebuilds", () => {
		let now = 0;
		const harness = runtime(
			true,
			() => 0,
			() => now,
		);
		harness.current.components.workingLine.messages.values = ["Stable"];
		harness.current.components.workingLine.spinnerIntervalMs = 100;
		harness.current.components.workingLine.textIntervalMs = 60;
		harness.current.components.workingLine.textAnimation = "classic";
		harness.current.components.workingLine.segments.elapsed = false;
		harness.controller.startSession(harness.ctx);
		const uninterrupted = harness.calls.at(-1)?.[1] as { frames: string[]; intervalMs: number };
		expect(uninterrupted.intervalMs).toBe(30);
		for (now = 30; now <= 600; now += 30) {
			harness.controller.updateTokens({ input: now, output: 1 }, harness.ctx);
			const rebuilt = harness.calls.at(-1)?.[1] as { frames: string[] };
			expect(phaseSignature(rebuilt.frames[0] ?? "")).toEqual(
				phaseSignature(uninterrupted.frames[(now / 30) % uninterrupted.frames.length] ?? ""),
			);
		}
	});

	it("preserves bounded fallback phase across its frame-array wrap", () => {
		let now = 0;
		const harness = runtime(
			true,
			() => 0,
			() => now,
		);
		harness.current.components.workingLine.messages.values = ["Stable"];
		harness.current.components.workingLine.spinnerIntervalMs = 997;
		harness.current.components.workingLine.textIntervalMs = 900;
		harness.current.components.workingLine.textAnimation = "classic";
		harness.current.components.workingLine.segments.elapsed = false;
		harness.controller.startSession(harness.ctx);
		const uninterrupted = harness.calls.at(-1)?.[1] as { frames: string[]; intervalMs: number };
		const wrapAt = uninterrupted.frames.length * uninterrupted.intervalMs;
		now = wrapAt + uninterrupted.intervalMs;
		harness.controller.updateTokens({ input: 1, output: 1 }, harness.ctx);
		const rebuilt = harness.calls.at(-1)?.[1] as { frames: string[] };
		expect(phaseSignature(rebuilt.frames[0] ?? "")).toEqual(
			phaseSignature(uninterrupted.frames[1] ?? ""),
		);
	});

	it("bounds visible Loader reset jitter below one replacement interval", () => {
		vi.useFakeTimers();
		try {
			let now = 0;
			let loader: Loader | undefined;
			const harness = runtime(
				true,
				() => 0,
				() => now,
			);
			harness.current.components.workingLine.messages.values = ["Stable"];
			harness.current.components.workingLine.spinnerIntervalMs = 100;
			harness.current.components.workingLine.textAnimation = "disabled";
			harness.current.components.workingLine.segments.elapsed = false;
			const recordIndicator = harness.ctx.ui.setWorkingIndicator.bind(harness.ctx.ui);
			harness.ctx.ui.setWorkingIndicator = (value?: unknown) => {
				recordIndicator(value);
				if (value !== undefined) {
					const indicator = value as { frames: string[]; intervalMs: number };
					if (loader) loader.setIndicator(indicator);
					else
						loader = new Loader(
							{ requestRender() {} } as never,
							(text) => text,
							(text) => text,
							"",
							indicator,
						);
				}
			};
			harness.controller.startSession(harness.ctx);
			now = 90;
			harness.controller.updateTokens({ input: 1, output: 1 }, harness.ctx);
			const replacement = harness.calls.at(-1)?.[1] as { frames: string[]; intervalMs: number };
			const logicalBoundaryAt = 100;
			const visibleReplacementBoundaryAt = now + replacement.intervalMs;
			expect(visibleReplacementBoundaryAt - logicalBoundaryAt).toBeLessThan(replacement.intervalMs);
			expect(stripTerminalSequences(loader?.render(40)[1] ?? "")).toContain(
				stripTerminalSequences(replacement.frames[0] ?? ""),
			);
			now = 100;
			harness.controller.updateTokens({ input: 2, output: 1 }, harness.ctx);
			const corrected = harness.calls.at(-1)?.[1] as { frames: string[] };
			expect(phaseSignature(corrected.frames[0] ?? "")[0]).toBe(
				phaseSignature(replacement.frames[1] ?? "")[0],
			);
			loader?.stop();
		} finally {
			vi.useRealTimers();
		}
	});

	it("rebases frame zero at successful agent_start installation time", () => {
		let now = 0;
		const harness = runtime(
			true,
			() => 0,
			() => now,
		);
		harness.current.components.workingLine.messages.values = ["Stable"];
		harness.current.components.workingLine.spinner = "pulse";
		harness.current.components.workingLine.spinnerIntervalMs = 100;
		harness.current.components.workingLine.textAnimation = "disabled";
		harness.current.components.workingLine.segments.elapsed = false;
		harness.controller.startSession(harness.ctx);
		now = 250;
		harness.controller.startAgent(harness.ctx);
		const rebased = harness.calls.at(-1)?.[1] as { frames: string[] };
		expect(phaseSignature(rebased.frames[0] ?? "")[0]).toBe("⠀⠶⠀");
		now = 349;
		harness.controller.updateTokens({ input: 1, output: 1 }, harness.ctx);
		const beforeTick = harness.calls.at(-1)?.[1] as { frames: string[] };
		expect(phaseSignature(beforeTick.frames[0] ?? "")[0]).toBe("⠀⠶⠀");
		now = 350;
		harness.controller.updateTokens({ input: 2, output: 1 }, harness.ctx);
		const afterTick = harness.calls.at(-1)?.[1] as { frames: string[] };
		expect(phaseSignature(afterTick.frames[0] ?? "")[0]).toBe("⠰⣿⠆");
	});

	it.each(["classic", "kitt"] as const)(
		"keeps %s on its logical epoch when frame generation and setters advance the clock",
		(animation) => {
			let now = 0;
			let generationPending = true;
			const delayedTheme = theme();
			const baseFg = delayedTheme.fg.bind(delayedTheme);
			delayedTheme.fg = (color, text) => {
				if (generationPending) {
					now += 250;
					generationPending = false;
				}
				return baseFg(color, text);
			};
			const harness = runtime(
				true,
				() => 0,
				() => now,
				() => delayedTheme,
			);
			const control = runtime(
				true,
				() => 0,
				() => now,
			);
			for (const current of [harness.current, control.current]) {
				current.components.workingLine.messages.values = ["Stable"];
				current.components.workingLine.spinner = "pulse";
				current.components.workingLine.spinnerIntervalMs = 100;
				current.components.workingLine.textIntervalMs = 100;
				current.components.workingLine.textAnimation = animation;
				current.components.workingLine.segments.elapsed = false;
			}
			control.controller.startSession(control.ctx);
			const recordIndicator = harness.ctx.ui.setWorkingIndicator.bind(harness.ctx.ui);
			harness.ctx.ui.setWorkingIndicator = (value?: unknown) => {
				recordIndicator(value);
				now += 40;
				generationPending = true;
			};
			harness.controller.startSession(harness.ctx);
			expect(now).toBe(290);

			now += 560;
			control.controller.updateTokens({ input: 12, output: 3 }, control.ctx);
			harness.controller.updateTokens({ input: 12, output: 3 }, harness.ctx);
			const expected = control.calls.at(-1)?.[1] as { frames: string[] };
			const rebuilt = harness.calls.at(-1)?.[1] as { frames: string[] };
			expect(phaseMotionSignature(rebuilt.frames, 0)).toEqual(
				phaseMotionSignature(expected.frames, 0),
			);

			now += 560;
			control.controller.startTool("one", "read", control.ctx);
			harness.controller.startTool("one", "read", harness.ctx);
			const expectedAgain = control.calls.at(-1)?.[1] as { frames: string[] };
			const rebuiltAgain = harness.calls.at(-1)?.[1] as { frames: string[] };
			expect(phaseMotionSignature(rebuiltAgain.frames, 0)).toEqual(
				phaseMotionSignature(expectedAgain.frames, 0),
			);
		},
	);

	it("recovers the last successful epoch when reconcile mutates then throws and retries on tokens", () => {
		let now = 0;
		let failSetter = false;
		let setterCalls = 0;
		let failedAtMs = 0;
		let indicatorSurface: unknown;
		let failedAttempt: { frames: string[]; intervalMs: number } | undefined;
		const harness = runtime(
			true,
			() => 0,
			() => now,
		);
		const control = runtime(
			true,
			() => 0,
			() => now,
		);
		const recordIndicator = harness.ctx.ui.setWorkingIndicator.bind(harness.ctx.ui);
		harness.ctx.ui.setWorkingIndicator = (value?: unknown) => {
			setterCalls += 1;
			indicatorSurface = value;
			if (failSetter) {
				failSetter = false;
				failedAtMs = now;
				failedAttempt = value as { frames: string[]; intervalMs: number };
				now += 4500;
				throw new Error("setter unavailable");
			}
			recordIndicator(value);
		};
		for (const current of [harness.current, control.current]) {
			current.components.workingLine.messages.values = ["Stable"];
			current.components.workingLine.spinner = "pulse";
			current.components.workingLine.spinnerIntervalMs = 100;
			current.components.workingLine.textIntervalMs = 100;
			current.components.workingLine.textAnimation = "classic";
			current.components.workingLine.segments.elapsed = false;
		}
		harness.controller.startSession(harness.ctx);
		control.controller.startSession(control.ctx);
		const lastSuccessfulSurface = indicatorSurface;

		now = 100;
		for (const current of [harness.current, control.current]) {
			current.components.workingLine.spinnerIntervalMs = 200;
			current.components.workingLine.textIntervalMs = 200;
			current.components.workingLine.textAnimation = "kitt";
		}
		failSetter = true;
		expect(harness.controller.reconcile(harness.ctx).applied).toBe(false);
		expect(indicatorSurface).toBe(lastSuccessfulSurface);
		failSetter = false;
		control.controller.updateTokens({ input: 12, output: 3 }, control.ctx);
		harness.controller.updateTokens({ input: 12, output: 3 }, harness.ctx);

		expect(setterCalls).toBe(4);
		expect(harness.calls.filter(([name]) => name === "indicator")).toHaveLength(3);
		const retried = harness.calls.at(-1)?.[1] as { frames: string[] };
		const expected = control.calls.at(-1)?.[1] as { frames: string[] };
		expect(phaseMotionSignature(retried.frames, 0)).toEqual(
			phaseMotionSignature(expected.frames, 0),
		);
		const failed = failedAttempt as unknown as { frames: string[]; intervalMs: number };
		const incorrectlyPublishedIndex =
			Math.floor((now - failedAtMs) / failed.intervalMs) % failed.frames.length;
		expect(phaseMotionSignature(retried.frames, 0)).not.toEqual(
			phaseMotionSignature(failed.frames, incorrectlyPublishedIndex),
		);
	});

	it("preserves the elapsed subscription while recovering a transient reinstall failure", () => {
		vi.useFakeTimers();
		try {
			const harness = runtime(true, () => 0);
			harness.current.components.workingLine.messages.values = ["Stable"];
			let failSetter = false;
			const setter = harness.ctx.ui.setWorkingIndicator.bind(harness.ctx.ui);
			harness.ctx.ui.setWorkingIndicator = (value?: unknown) => {
				if (failSetter) {
					failSetter = false;
					throw new Error("mutated before throwing");
				}
				setter(value);
			};
			harness.controller.startSession(harness.ctx);
			harness.clock.start();
			harness.controller.startAgent(harness.ctx);
			expect(vi.getTimerCount()).toBe(1);
			harness.current.components.workingLine.spinnerIntervalMs += 1;
			failSetter = true;
			expect(harness.controller.reconcile(harness.ctx).applied).toBe(false);
			expect(vi.getTimerCount()).toBe(1);
			harness.controller.updateTokens({ input: 1, output: 1 }, harness.ctx);
			expect(vi.getTimerCount()).toBe(1);
			harness.controller.dispose(harness.ctx);
			harness.clock.reset();
		} finally {
			vi.useRealTimers();
		}
	});

	it("restores the previous message and phase when startTurn installation fails", () => {
		let now = 0;
		let failSetter = false;
		let indicatorSurface: unknown;
		const harness = runtime(
			true,
			() => 0.75,
			() => now,
		);
		harness.current.components.workingLine.messages.values = ["A", "B"];
		harness.current.components.workingLine.spinner = "pulse";
		harness.current.components.workingLine.spinnerIntervalMs = 100;
		harness.current.components.workingLine.textAnimation = "disabled";
		harness.current.components.workingLine.segments.elapsed = false;
		const setter = harness.ctx.ui.setWorkingIndicator.bind(harness.ctx.ui);
		harness.ctx.ui.setWorkingIndicator = (value?: unknown) => {
			indicatorSurface = value;
			if (failSetter) {
				failSetter = false;
				now = 250;
				throw new Error("mutated before throwing");
			}
			setter(value);
		};
		harness.controller.startSession(harness.ctx);
		const lastSuccessfulSurface = indicatorSurface;
		expect(harness.controller.currentMessage()).toBe("A");

		failSetter = true;
		expect(harness.controller.startTurn(harness.ctx).applied).toBe(false);
		expect(indicatorSurface).toBe(lastSuccessfulSurface);
		expect(harness.controller.currentMessage()).toBe("A");
		harness.controller.updateTokens({ input: 1, output: 1 }, harness.ctx);
		const retried = harness.calls.at(-1)?.[1] as { frames: string[] };
		expect(stripTerminalSequences(retried.frames[0] ?? "")).toContain("A");
		expect(phaseSignature(retried.frames[0] ?? "")[0]).toBe("⢾⣉⡷");
	});

	it("does not publish a failed forced agent-start rebase epoch", () => {
		let now = 0;
		let failSetter = false;
		let indicatorSurface: unknown;
		const harness = runtime(
			true,
			() => 0,
			() => now,
		);
		harness.current.components.workingLine.messages.values = ["Stable"];
		harness.current.components.workingLine.spinner = "pulse";
		harness.current.components.workingLine.spinnerIntervalMs = 100;
		harness.current.components.workingLine.textAnimation = "disabled";
		harness.current.components.workingLine.segments.elapsed = false;
		const setter = harness.ctx.ui.setWorkingIndicator.bind(harness.ctx.ui);
		harness.ctx.ui.setWorkingIndicator = (value?: unknown) => {
			indicatorSurface = value;
			if (failSetter) {
				failSetter = false;
				now = 350;
				throw new Error("mutated before throwing");
			}
			setter(value);
		};
		harness.controller.startSession(harness.ctx);
		const lastSuccessfulSurface = indicatorSurface;
		now = 250;
		failSetter = true;
		harness.controller.startAgent(harness.ctx);
		expect(indicatorSurface).toBe(lastSuccessfulSurface);
		harness.controller.updateTokens({ input: 1, output: 1 }, harness.ctx);
		const retried = harness.calls.at(-1)?.[1] as { frames: string[] };
		expect(phaseSignature(retried.frames[0] ?? "")[0]).toBe("⣏⠀⣹");
	});

	it("releases ownership when recovery also throws and waits for a clean reinstall", () => {
		const current = config();
		current.components.workingLine.enabled = true;
		current.components.workingLine.messages.values = ["Stable"];
		current.components.workingLine.segments.elapsed = false;
		const calls: string[] = [];
		let indicatorSurface: unknown;
		let messageSurface: string | undefined;
		let failureSets = 0;
		const ctx = {
			hasUI: true,
			mode: "tui",
			ui: {
				setWorkingMessage(value?: string) {
					messageSurface = value;
					calls.push(value === undefined ? "message-reset" : "message-set");
				},
				setWorkingIndicator(value?: unknown) {
					indicatorSurface = value;
					calls.push(value === undefined ? "indicator-reset" : "indicator-set");
					if (value !== undefined && failureSets > 0) {
						failureSets -= 1;
						throw new Error("setter mutated before throwing");
					}
				},
			},
		};
		const controller = new WorkingLineController(() => current, theme);
		expect(controller.startSession(ctx).applied).toBe(true);
		current.components.workingLine.spinnerIntervalMs += 1;
		failureSets = 2;
		expect(controller.reconcile(ctx).applied).toBe(false);
		expect(calls.slice(-4)).toEqual([
			"indicator-set",
			"indicator-set",
			"indicator-reset",
			"message-reset",
		]);
		expect(indicatorSurface).toBeUndefined();
		expect(messageSurface).toBeUndefined();
		const afterRelease = calls.length;
		controller.updateTokens({ input: 1, output: 1 }, ctx);
		expect(calls).toHaveLength(afterRelease);
		expect(controller.reconcile(ctx).applied).toBe(true);
		expect(calls.slice(-2)).toEqual(["message-set", "indicator-set"]);
	});

	it.each(["classic", "kitt"] as const)(
		"preserves %s phase across the 9s to 10s elapsed-width change",
		(animation) => {
			vi.useFakeTimers();
			vi.setSystemTime(0);
			try {
				const harness = runtime(true, () => 0);
				harness.current.components.workingLine.messages.values = ["Stable"];
				harness.current.components.workingLine.textAnimation = animation;
				harness.controller.startSession(harness.ctx);
				harness.clock.start(0);
				harness.controller.startAgent(harness.ctx);
				harness.controller.startTurn(harness.ctx);
				vi.advanceTimersByTime(9000);
				const atNine = harness.calls.at(-1)?.[1] as { frames: string[]; intervalMs: number };
				expect(stripTerminalSequences(atNine.frames[0] ?? "")).toContain(" · 9s");
				vi.advanceTimersByTime(1000);
				const atTen = harness.calls.at(-1)?.[1] as { frames: string[] };
				expect(stripTerminalSequences(atTen.frames[0] ?? "")).toContain(" · 10s");
				const sampledIndex = Math.floor(1000 / atNine.intervalMs) % atNine.frames.length;
				expect(phaseSignature(atTen.frames[0] ?? "")).toEqual(
					phaseSignature(atNine.frames[sampledIndex] ?? ""),
				);
				harness.controller.dispose(harness.ctx);
				harness.clock.reset();
			} finally {
				vi.useRealTimers();
			}
		},
	);

	it("writes elapsed only when its one-second label changes", () => {
		vi.useFakeTimers();
		const harness = runtime(true);
		harness.controller.startSession(harness.ctx);
		harness.clock.start();
		harness.controller.startAgent(harness.ctx);
		harness.controller.startTurn(harness.ctx);
		harness.calls.length = 0;
		vi.advanceTimersByTime(999);
		expect(harness.calls).toEqual([]);
		vi.advanceTimersByTime(1);
		expect(harness.calls).toHaveLength(1);
		expect(harness.calls[0]?.[0]).toBe("indicator");
		expect(
			stripTerminalSequences(
				(harness.calls[0]?.[1] as { frames?: string[] } | undefined)?.frames?.[0] ?? "",
			),
		).toContain(" · 1s");
		vi.advanceTimersByTime(1000);
		expect(harness.calls).toHaveLength(2);
		expect(
			stripTerminalSequences(
				(harness.calls.at(-1)?.[1] as { frames?: string[] } | undefined)?.frames?.[0] ?? "",
			),
		).toContain(" · 2s");
		harness.controller.dispose(harness.ctx);
		harness.clock.reset();
		vi.useRealTimers();
	});

	it("keeps one shared clock subscription through frequent eligible updates", () => {
		vi.useFakeTimers();
		try {
			const harness = runtime(true);
			harness.controller.startSession(harness.ctx);
			harness.clock.start();
			harness.controller.startAgent(harness.ctx);
			harness.controller.startTurn(harness.ctx);
			for (let elapsed = 0; elapsed < 1_000; elapsed += 100) {
				harness.controller.updateMetrics(
					{ input: elapsed, output: 1 },
					{ durationMs: elapsed, active: true },
					harness.ctx,
				);
				harness.controller.reconcile(harness.ctx);
				vi.advanceTimersByTime(100);
				expect(vi.getTimerCount()).toBe(1);
			}
			const latest = stripTerminalSequences(
				(harness.calls.at(-1)?.[1] as { frames?: string[] } | undefined)?.frames?.[0] ?? "",
			);
			expect(latest).toContain(" · 1s");
			harness.controller.dispose(harness.ctx);
			expect(vi.getTimerCount()).toBe(0);
		} finally {
			vi.useRealTimers();
		}
	});

	it("transitions thought-only clock subscription strictly with active thought", () => {
		vi.useFakeTimers();
		try {
			const harness = runtime(true);
			harness.current.components.workingLine.segments.elapsed = false;
			harness.current.components.workingLine.segments.thought = true;
			harness.controller.startSession(harness.ctx);
			harness.clock.start();
			harness.controller.startAgent(harness.ctx);
			expect(vi.getTimerCount()).toBe(0);
			harness.controller.updateMetrics(undefined, { durationMs: 0, active: true }, harness.ctx);
			expect(vi.getTimerCount()).toBe(1);
			harness.controller.updateMetrics(undefined, { durationMs: 1, active: true }, harness.ctx);
			harness.controller.startTurn(harness.ctx);
			expect(vi.getTimerCount()).toBe(1);
			harness.controller.updateMetrics(undefined, { durationMs: 2, active: false }, harness.ctx);
			expect(vi.getTimerCount()).toBe(0);
			harness.current.components.workingLine.enabled = false;
			harness.controller.reconcile(harness.ctx);
			expect(vi.getTimerCount()).toBe(0);
			harness.current.components.workingLine.enabled = true;
			harness.controller.reconcile(harness.ctx);
			harness.controller.updateMetrics(undefined, { durationMs: 3, active: true }, harness.ctx);
			expect(vi.getTimerCount()).toBe(1);
			harness.controller.finishAgent(harness.ctx);
			expect(vi.getTimerCount()).toBe(0);
		} finally {
			vi.useRealTimers();
		}
	});

	it("releases a first message setter that mutates then throws before a clean retry", () => {
		const current = config();
		current.components.workingLine.enabled = true;
		const calls: string[] = [];
		let failFirstMessageSet = true;
		const ctx = {
			hasUI: true,
			mode: "tui",
			ui: {
				setWorkingMessage(value?: string) {
					calls.push(value === undefined ? "message-reset" : "message-set");
					if (value === "" && failFirstMessageSet) {
						failFirstMessageSet = false;
						throw new Error("message setter mutated before throwing");
					}
				},
				setWorkingIndicator(value?: unknown) {
					calls.push(value === undefined ? "indicator-reset" : "indicator-set");
				},
			},
		};
		const controller = new WorkingLineController(() => current, theme);

		expect(controller.startSession(ctx).applied).toBe(false);
		expect(calls).toEqual(["message-set", "message-reset"]);
		controller.dispose(ctx);
		expect(calls).toEqual(["message-set", "message-reset"]);

		expect(controller.startSession(ctx).applied).toBe(true);
		expect(calls.slice(-2)).toEqual(["message-set", "indicator-set"]);
		const afterRetry = calls.length;
		expect(controller.reconcile(ctx).applied).toBe(true);
		expect(calls).toHaveLength(afterRetry);
		controller.dispose(ctx);
		controller.dispose(ctx);
		expect(calls.slice(-2)).toEqual(["indicator-reset", "message-reset"]);
	});

	it("releases a first indicator setter that mutates then throws before a phase-clean retry", () => {
		const current = config();
		current.components.workingLine.enabled = true;
		current.components.workingLine.messages.values = ["Stable"];
		current.components.workingLine.segments.elapsed = false;
		let now = 0;
		let failFirstIndicatorSet = true;
		const calls: string[] = [];
		let failedFrames: string[] | undefined;
		let retriedFrames: string[] | undefined;
		const ctx = {
			hasUI: true,
			mode: "tui",
			ui: {
				setWorkingMessage(value?: string) {
					calls.push(value === undefined ? "message-reset" : "message-set");
				},
				setWorkingIndicator(value?: unknown) {
					calls.push(value === undefined ? "indicator-reset" : "indicator-set");
					if (value !== undefined && failFirstIndicatorSet) {
						failedFrames = (value as { frames: string[] }).frames;
						failFirstIndicatorSet = false;
						now = 500;
						throw new Error("indicator setter mutated before throwing");
					}
					if (value !== undefined) retriedFrames = (value as { frames: string[] }).frames;
				},
			},
		};
		const controller = new WorkingLineController(
			() => current,
			theme,
			new AgentDurationClock(),
			() => 0,
			() => now,
		);

		expect(controller.startSession(ctx).applied).toBe(false);
		expect(calls).toEqual(["message-set", "indicator-set", "indicator-reset", "message-reset"]);
		controller.dispose(ctx);
		expect(calls).toHaveLength(4);

		expect(controller.startSession(ctx).applied).toBe(true);
		expect(calls.slice(-2)).toEqual(["message-set", "indicator-set"]);
		expect(retriedFrames).toEqual(failedFrames);
		const afterRetry = calls.length;
		expect(controller.reconcile(ctx).applied).toBe(true);
		expect(calls).toHaveLength(afterRetry);
		controller.dispose(ctx);
		controller.dispose(ctx);
		expect(calls.slice(-2)).toEqual(["indicator-reset", "message-reset"]);
	});

	it("contains cleanup API failures and stays idempotent", () => {
		const current = config();
		current.components.workingLine.enabled = true;
		current.components.workingLine.messages.custom = true;
		const calls: string[] = [];
		const ctx = {
			hasUI: true,
			mode: "tui",
			ui: {
				setWorkingMessage(value?: string) {
					calls.push(value === undefined ? "message-reset" : "message-set");
				},
				setWorkingIndicator(value?: unknown) {
					calls.push(value === undefined ? "indicator-reset" : "indicator-set");
					if (value === undefined) throw new Error("reset unavailable");
				},
			},
		};
		const controller = new WorkingLineController(() => current, theme);
		expect(controller.startSession(ctx).applied).toBe(true);
		expect(() => controller.dispose(ctx)).not.toThrow();
		expect(() => controller.dispose(ctx)).not.toThrow();
		expect(calls).toEqual(["message-set", "indicator-set", "indicator-reset", "message-reset"]);
	});

	it("live-enables and resets indicator then message exactly once on disable or cleanup", () => {
		const harness = runtime(false);
		harness.controller.startTurn(harness.ctx);
		harness.current.components.workingLine.enabled = true;
		expect(harness.controller.reconcile(harness.ctx).applied).toBe(true);
		expect(harness.controller.currentMessage()).toBe("B");
		harness.current.components.workingLine.enabled = false;
		harness.controller.reconcile(harness.ctx);
		harness.controller.dispose(harness.ctx);
		harness.controller.dispose(harness.ctx);
		expect(
			harness.calls.map(([name, value]) => [name, value === undefined ? "reset" : "set"]),
		).toEqual([
			["message", "set"],
			["indicator", "set"],
			["indicator", "reset"],
			["message", "reset"],
		]);
	});
});