@selesai/code 0.13.15 → 0.13.18

package/dist/extensions/pi-zentui/test/settings-command.test.ts

@@ -13,6 +13,7 @@ import {
 	type UserMessagesComponentConfig,
 	type WorkingLineComponentPatch,
 } from "../extensions/zentui/config";
+import { componentPresets, getComponentPreset, type PresetId } from "../extensions/zentui/presets";
 import { SessionLifecycle } from "../extensions/zentui/session-lifecycle";
 import { registerZentuiSettingsCommand } from "../extensions/zentui/settings-command";
 
@@ -128,6 +129,7 @@ function createHarness(
 	let doneCalls = 0;
 	const sessionLifecycle = new SessionLifecycle();
 	const calls = {
+		presets: [] as PresetId[],
 		editor: [] as Partial<EditorComponentConfig>[],
 		polished: [] as Array<Record<string, unknown>>,
 		polishedCopyFriendly: [] as Array<Record<string, unknown>>,
@@ -149,6 +151,15 @@ function createHarness(
 	const deps = {
 		sessionLifecycle,
 		getConfig: () => config,
+		applyPreset(id: PresetId) {
+			calls.presets.push(id);
+			const preset = getComponentPreset(id);
+			for (const owner of ["editor", "footer", "userMessages"] as const) {
+				Object.assign(config.components[owner], preset?.components[owner]);
+			}
+			return { applied: true };
+		},
+		reconcilePresetEditor: () => ({ applied: true }),
 		setEditorComponent(patch: Partial<EditorComponentConfig>) {
 			calls.editor.push(patch);
 			Object.assign(config.components.editor, patch);
@@ -337,6 +348,7 @@ describe("component-oriented /zentui settings", () => {
 		await harness.command().handler("", harness.ctx);
 		const component = harness.component();
 		expectFocusOrder(component, [
+			"Preset",
 			"Selector borders",
 			"Selector border style",
 			"Selector border colors",
@@ -756,7 +768,9 @@ describe("component-oriented /zentui settings", () => {
 				.getArgumentCompletions("")
 				?.map((item) => item.value) ?? [];
 		expect(values).toContain("messages toggle");
-		expect(values.some((value) => value.includes("copy-friendly"))).toBe(false);
+		expect(values.filter((value) => value.includes("copy-friendly"))).toEqual([
+			"preset opencode-copy-friendly",
+		]);
 		expect(values.join("\n")).not.toMatch(/fixed[-_ ]editor/i);
 	});
 
@@ -1661,3 +1675,193 @@ describe("component-oriented /zentui settings", () => {
 		expect(harness.component().render(40)[1]).toContain(section);
 	});
 });
+
+describe("preset commands and Appearance selection", () => {
+	it.each(["snapshot", "non-string", "preparation"])(
+		"does not open a destructive panel after %s fails",
+		async (failure) => {
+			const custom = vi.fn();
+			const setEditorText = vi.fn(() => {
+				if (failure === "preparation") throw new Error("preparation failed");
+			});
+			const harness = createHarness(
+				cloneConfig(),
+				{},
+				{
+					custom,
+					getEditorText() {
+						if (failure === "snapshot") throw new Error("snapshot failed");
+						return failure === "non-string" ? undefined : "draft";
+					},
+					setEditorText,
+				},
+			);
+			await harness.command().handler("", harness.ctx);
+			expect(custom).not.toHaveBeenCalled();
+			expect(harness.notificationEvents).toEqual([
+				{
+					severity: "error",
+					message: expect.stringContaining("Could not open Zentui settings safely"),
+				},
+			]);
+			if (failure !== "preparation") expect(setEditorText).not.toHaveBeenCalled();
+		},
+	);
+
+	it.each(componentPresets)("applies $id as a single command dependency", async ({ id }) => {
+		const harness = createHarness();
+		await harness.command().handler(`preset ${id}`, harness.ctx);
+		expect(harness.calls.presets).toEqual([id]);
+		expect(harness.calls.editor).toEqual([]);
+		expect(harness.calls.messages).toEqual([]);
+		expect(harness.calls.footer).toEqual([]);
+		expect(harness.calls.selectors).toEqual([]);
+		expect(harness.notifications.at(-1)).toContain("Preset saved:");
+	});
+
+	it.each([
+		"preset",
+		"preset custom",
+		"preset invalid",
+		"preset Opencode",
+		"preset opencode_copy_friendly",
+		"preset opencode extra",
+		"preset opencode enable",
+		"preset rail minimalist",
+	])("rejects malformed input %s without a save", async (args) => {
+		const harness = createHarness();
+		await harness.command().handler(args, harness.ctx);
+		expect(harness.calls.presets).toEqual([]);
+		expect(harness.calls.editor).toEqual([]);
+		expect(harness.notifications.at(-1)).toContain("/zentui preset <");
+	});
+
+	it("completes exact hyphenated IDs", () => {
+		const harness = createHarness();
+		expect(
+			harness
+				.command()
+				.getArgumentCompletions("preset ")
+				?.map(({ value }) => value),
+		).toEqual(componentPresets.map(({ id }) => `preset ${id}`));
+		expect(harness.command().getArgumentCompletions("preset opencode-")).toEqual([
+			{ value: "preset opencode-copy-friendly", label: "preset opencode-copy-friendly" },
+		]);
+		expect(harness.command().getArgumentCompletions("preset nope")).toBeNull();
+	});
+
+	it("derives Custom on reopen and restores a name when selections match again", async () => {
+		const harness = createHarness();
+		await harness.command().handler("", harness.ctx);
+		expect(focusedRow(harness.component())).toMatch(/Preset.*Opencode/);
+		harness.config.components.userMessages.style = "labeled";
+		await harness.command().handler("", harness.ctx);
+		expect(focusedRow(harness.component())).toMatch(/Preset.*Custom/);
+		harness.config.components.userMessages.style = "framed";
+		await harness.command().handler("", harness.ctx);
+		expect(focusedRow(harness.component())).toMatch(/Preset.*Opencode/);
+	});
+
+	it("keeps focus while cycling presets from Custom and recomputes Custom after individual changes", async () => {
+		const config = cloneConfig();
+		config.components.editor.enabled = false;
+		const harness = createHarness(config);
+		harness.sessionLifecycle.start();
+		await harness.command().handler("", harness.ctx);
+		const component = harness.component();
+		expect(focusedRow(component)).toContain("Custom");
+		for (const preset of componentPresets) {
+			component.handleInput("\r");
+			expect(focusedRow(component)).toContain(preset.label);
+			expect(component.render(200)[1]).toContain("Appearance");
+			expect(harness.doneCalls()).toBe(0);
+		}
+		expect(harness.calls.presets).toEqual(componentPresets.map(({ id }) => id));
+		component.handleInput("\t");
+		component.handleInput("\x1b[B");
+		component.handleInput("\r");
+		expect(focusedRow(component)).toContain("Editor style");
+		component.handleInput("\x1b[Z");
+		expect(focusedRow(component)).toContain("Custom");
+		component.handleInput("\x1b");
+		expect(harness.doneCalls()).toBe(1);
+		harness.sessionLifecycle.shutdown();
+	});
+
+	it("ignores preset input after shutdown without saving", async () => {
+		const harness = createHarness();
+		harness.sessionLifecycle.start();
+		await harness.command().handler("", harness.ctx);
+		harness.sessionLifecycle.shutdown();
+		harness.component().handleInput("\r");
+		expect(harness.calls.presets).toEqual([]);
+	});
+
+	it.each(["direct", "settings"])(
+		"reports saved-but-blocked editor outcomes through %s",
+		async (source) => {
+			vi.useFakeTimers();
+			const harness = createHarness(cloneConfig(), {
+				applyPreset: () => ({ applied: false, reason: "editor blocked; reload Pi" }),
+			});
+			harness.sessionLifecycle.start();
+			if (source === "direct") await harness.command().handler("preset rail", harness.ctx);
+			else {
+				await harness.command().handler("", harness.ctx);
+				harness.component().handleInput("\r");
+				vi.runAllTimers();
+			}
+			expect(harness.notificationEvents.at(-1)).toMatchObject({
+				severity: "warning",
+				message: expect.stringContaining("editor blocked; reload Pi"),
+			});
+			harness.sessionLifecycle.shutdown();
+		},
+	);
+
+	it.each(["direct", "settings"])(
+		"reports save errors without claiming success through %s",
+		async (source) => {
+			vi.useFakeTimers();
+			const config = cloneConfig();
+			const before = structuredClone(config);
+			const harness = createHarness(config, {
+				applyPreset: () => {
+					throw new Error("disk full");
+				},
+			});
+			harness.sessionLifecycle.start();
+			if (source === "direct") await harness.command().handler("preset rail", harness.ctx);
+			else {
+				await harness.command().handler("", harness.ctx);
+				harness.component().handleInput("\r");
+				vi.runAllTimers();
+			}
+			expect(config).toEqual(before);
+			if (source === "settings") {
+				expect(harness.doneCalls()).toBe(0);
+				expect(focusedRow(harness.component())).toMatch(/Preset.*Opencode/);
+				harness.component().handleInput("\r");
+				expect(focusedRow(harness.component())).toMatch(/Preset.*Opencode/);
+				harness.notificationEvents.pop();
+			}
+			expect(harness.notificationEvents).toEqual([
+				{ severity: "error", message: "Could not update Zentui settings: disk full" },
+			]);
+			harness.sessionLifecycle.shutdown();
+		},
+	);
+
+	it.each(["rpc", "print", "json"])(
+		"supports direct persistence without custom UI in %s",
+		async (mode) => {
+			const custom = vi.fn();
+			const harness = createHarness(cloneConfig(), {}, { custom });
+			harness.ctx.mode = mode;
+			harness.ctx.hasUI = mode === "rpc";
+			await harness.command().handler("preset minimalist", harness.ctx);
+			expect(harness.calls.presets).toEqual(["minimalist"]);
+			expect(custom).not.toHaveBeenCalled();
+		},
+	);
+});

package/dist/extensions/pi-zentui/test/working-line-extension-segments.test.ts

@@ -0,0 +1,139 @@
+import type { EventBus } from "@earendil-works/pi-coding-agent";
+import { describe, expect, it, vi } from "vitest";
+import {
+	MAX_WORKING_LINE_EXTENSION_KEY_CODE_UNITS,
+	MAX_WORKING_LINE_EXTENSION_SEGMENTS,
+	MAX_WORKING_LINE_EXTENSION_TEXT_CODE_UNITS,
+	WorkingLineExtensionSegments,
+	ZENTUI_WORKING_LINE_SEGMENT_CAPABILITY_EVENT,
+	ZENTUI_WORKING_LINE_SEGMENT_EVENT,
+	ZENTUI_WORKING_LINE_SEGMENT_PROTOCOL_VERSION,
+} from "../extensions/zentui/working-line-extension-segments";
+
+function eventBus(): EventBus {
+	const handlers = new Map<string, Set<(data: unknown) => void>>();
+	return {
+		emit(channel, data) {
+			for (const handler of handlers.get(channel) ?? []) handler(data);
+		},
+		on(channel, handler) {
+			const current = handlers.get(channel) ?? new Set();
+			current.add(handler);
+			handlers.set(channel, current);
+			return () => current.delete(handler);
+		},
+	};
+}
+
+describe("working-line extension segments", () => {
+	it("reports support and whether the integration is currently active", () => {
+		const events = eventBus();
+		let active = false;
+		new WorkingLineExtensionSegments(
+			events,
+			() => active,
+			() => undefined,
+		);
+		const capability = { supported: false, active: false };
+		events.emit(ZENTUI_WORKING_LINE_SEGMENT_CAPABILITY_EVENT, capability);
+		expect(capability).toEqual({
+			supported: true,
+			active: false,
+			version: ZENTUI_WORKING_LINE_SEGMENT_PROTOCOL_VERSION,
+		});
+		active = true;
+		events.emit(ZENTUI_WORKING_LINE_SEGMENT_CAPABILITY_EVENT, capability);
+		expect(capability).toEqual({
+			supported: true,
+			active: true,
+			version: ZENTUI_WORKING_LINE_SEGMENT_PROTOCOL_VERSION,
+		});
+	});
+
+	it("ignores segment values while the Working line is inactive", () => {
+		const events = eventBus();
+		const onChange = vi.fn();
+		new WorkingLineExtensionSegments(events, () => false, onChange);
+		events.emit(ZENTUI_WORKING_LINE_SEGMENT_EVENT, { key: "inactive", text: "hidden" });
+		expect(onChange).not.toHaveBeenCalled();
+	});
+
+	it("publishes keyed segments in deterministic order and supports update, removal, and clear", () => {
+		const events = eventBus();
+		const onChange = vi.fn();
+		const segments = new WorkingLineExtensionSegments(events, () => true, onChange);
+		events.emit(ZENTUI_WORKING_LINE_SEGMENT_EVENT, { key: "zeta", text: "second" });
+		events.emit(ZENTUI_WORKING_LINE_SEGMENT_EVENT, { key: "alpha", text: "first" });
+		expect(onChange).toHaveBeenLastCalledWith(["first", "second"]);
+		const calls = onChange.mock.calls.length;
+		events.emit(ZENTUI_WORKING_LINE_SEGMENT_EVENT, { key: "alpha", text: "first" });
+		expect(onChange).toHaveBeenCalledTimes(calls);
+		events.emit(ZENTUI_WORKING_LINE_SEGMENT_EVENT, { key: "alpha", text: "updated" });
+		expect(onChange).toHaveBeenLastCalledWith(["updated", "second"]);
+		events.emit(ZENTUI_WORKING_LINE_SEGMENT_EVENT, { key: "zeta" });
+		expect(onChange).toHaveBeenLastCalledWith(["updated"]);
+		segments.clear();
+		expect(onChange).toHaveBeenLastCalledWith([]);
+	});
+
+	it("retries an identical keyed snapshot after its first publication is rejected", () => {
+		const events = eventBus();
+		const onChange = vi.fn().mockReturnValueOnce(false).mockReturnValue(true);
+		new WorkingLineExtensionSegments(events, () => true, onChange);
+		const update = { key: "@scope/publisher:queue", text: "queue 2" };
+		events.emit(ZENTUI_WORKING_LINE_SEGMENT_EVENT, update);
+		events.emit(ZENTUI_WORKING_LINE_SEGMENT_EVENT, update);
+		expect(onChange).toHaveBeenCalledTimes(2);
+		expect(onChange).toHaveBeenNthCalledWith(1, ["queue 2"]);
+		expect(onChange).toHaveBeenNthCalledWith(2, ["queue 2"]);
+		events.emit(ZENTUI_WORKING_LINE_SEGMENT_EVENT, update);
+		expect(onChange).toHaveBeenCalledTimes(2);
+	});
+
+	it("invalidates keyed state when a rejected publication makes the integration inactive", () => {
+		const events = eventBus();
+		let active = true;
+		const onChange = vi.fn(() => {
+			active = false;
+			return false;
+		});
+		new WorkingLineExtensionSegments(events, () => active, onChange);
+		const update = { key: "@scope/publisher:queue", text: "queue 2" };
+		events.emit(ZENTUI_WORKING_LINE_SEGMENT_EVENT, update);
+		expect(onChange).toHaveBeenCalledTimes(1);
+
+		events.emit(ZENTUI_WORKING_LINE_SEGMENT_EVENT, update);
+		expect(onChange).toHaveBeenCalledTimes(1);
+		active = true;
+		onChange.mockReturnValue(true);
+		events.emit(ZENTUI_WORKING_LINE_SEGMENT_EVENT, update);
+		expect(onChange).toHaveBeenCalledTimes(2);
+	});
+
+	it("rejects malformed and over-limit updates and bounds unique keys", () => {
+		const events = eventBus();
+		const onChange = vi.fn();
+		new WorkingLineExtensionSegments(events, () => true, onChange);
+		for (const value of [
+			null,
+			{},
+			{ key: "" },
+			{ key: "x".repeat(MAX_WORKING_LINE_EXTENSION_KEY_CODE_UNITS + 1), text: "value" },
+			{ key: "wrong-text", text: 1 },
+			{
+				key: "long-text",
+				text: "x".repeat(MAX_WORKING_LINE_EXTENSION_TEXT_CODE_UNITS + 1),
+			},
+		]) {
+			events.emit(ZENTUI_WORKING_LINE_SEGMENT_EVENT, value);
+		}
+		expect(onChange).not.toHaveBeenCalled();
+		for (let index = 0; index < MAX_WORKING_LINE_EXTENSION_SEGMENTS + 1; index += 1) {
+			events.emit(ZENTUI_WORKING_LINE_SEGMENT_EVENT, {
+				key: `segment-${index}`,
+				text: `${index}`,
+			});
+		}
+		expect(onChange).toHaveBeenCalledTimes(MAX_WORKING_LINE_EXTENSION_SEGMENTS);
+	});
+});

package/dist/extensions/pi-zentui/test/working-line-lifecycle.integration.test.ts

@@ -1,5 +1,5 @@
 import { stripVTControlCharacters } from "node:util";
-import type { Theme } from "@earendil-works/pi-coding-agent";
+import type { EventBus, Theme } from "@earendil-works/pi-coding-agent";
 import { Loader, visibleWidth } from "@earendil-works/pi-tui";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
@@ -14,6 +14,24 @@ const runtime = vi.hoisted(() => ({
 	textIntervalMs: 60,
 }));
 
+const startupGate = vi.hoisted(() => ({
+	pending: undefined as Promise<void> | undefined,
+}));
+
+vi.mock("../extensions/zentui/accent-rail-layout-patch", async (importOriginal) => {
+	const actual =
+		await importOriginal<typeof import("../extensions/zentui/accent-rail-layout-patch")>();
+	return {
+		...actual,
+		async retainAccentRailLayoutPatchInstallation(
+			...args: Parameters<typeof actual.retainAccentRailLayoutPatchInstallation>
+		) {
+			if (startupGate.pending) await startupGate.pending;
+			return actual.retainAccentRailLayoutPatchInstallation(...args);
+		},
+	};
+});
+
 vi.mock("../extensions/zentui/config", async (importOriginal) => {
 	const actual = await importOriginal<typeof import("../extensions/zentui/config")>();
 	return {
@@ -40,6 +58,11 @@ vi.mock("../extensions/zentui/config", async (importOriginal) => {
 });
 
 import zentui from "../extensions/zentui/index";
+import {
+	ZENTUI_WORKING_LINE_SEGMENT_CAPABILITY_EVENT,
+	ZENTUI_WORKING_LINE_SEGMENT_EVENT,
+	ZENTUI_WORKING_LINE_SEGMENT_PROTOCOL_VERSION,
+} from "../extensions/zentui/working-line-extension-segments";
 
 type Handler = (event: unknown, ctx: unknown) => unknown | Promise<unknown>;
 
@@ -73,11 +96,27 @@ function loaderPhase(rendered: string): [string, number | undefined] {
 	];
 }
 
-function loadExtension() {
-	const handlers = new Map<string, Handler[]>();
+type LoadedHandlers = Map<string, Handler[]> & { events: EventBus };
+
+function loadExtension(): LoadedHandlers {
+	const handlers = new Map<string, Handler[]>() as LoadedHandlers;
+	const eventHandlers = new Map<string, Set<(data: unknown) => void>>();
+	const events: EventBus = {
+		emit(channel, data) {
+			for (const handler of eventHandlers.get(channel) ?? []) handler(data);
+		},
+		on(channel, handler) {
+			const current = eventHandlers.get(channel) ?? new Set();
+			current.add(handler);
+			eventHandlers.set(channel, current);
+			return () => current.delete(handler);
+		},
+	};
+	handlers.events = events;
 	zentui({
 		registerEntryRenderer() {},
 		appendEntry() {},
+		events,
 		on(name: string, handler: Handler) {
 			handlers.set(name, [...(handlers.get(name) ?? []), handler]);
 		},
@@ -96,6 +135,12 @@ async function emit(
 	for (const handler of handlers.get(name) ?? []) await handler(event, ctx);
 }
 
+function capability(handlers: LoadedHandlers) {
+	const result = { supported: false, active: false };
+	handlers.events.emit(ZENTUI_WORKING_LINE_SEGMENT_CAPABILITY_EVENT, result);
+	return result as typeof result & { version: number };
+}
+
 function harness() {
 	const calls: Array<[string, unknown?]> = [];
 	const forbidden = vi.fn();
@@ -152,6 +197,7 @@ beforeEach(() => {
 	runtime.spinner = "star-bloom";
 	runtime.spinnerIntervalMs = 100;
 	runtime.textIntervalMs = 60;
+	startupGate.pending = undefined;
 });
 
 describe("working-line extension lifecycle integration", () => {
@@ -228,6 +274,194 @@ describe("working-line extension lifecycle integration", () => {
 		expect(current.forbidden).not.toHaveBeenCalled();
 	});
 
+	it("composes keyed extension segments into the owned animated row", 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(capability(handlers)).toEqual({
+			supported: true,
+			active: true,
+			version: ZENTUI_WORKING_LINE_SEGMENT_PROTOCOL_VERSION,
+		});
+		handlers.events.emit(ZENTUI_WORKING_LINE_SEGMENT_EVENT, {
+			key: "tps",
+			text: "24.3 tok/s · TTFT 820ms",
+		});
+		expect(row()).toContain("Stable · 24.3 tok/s · TTFT 820ms");
+		handlers.events.emit(ZENTUI_WORKING_LINE_SEGMENT_EVENT, {
+			key: "queue",
+			text: "queue 2",
+		});
+		expect(row()).toContain("queue 2 · 24.3 tok/s · TTFT 820ms");
+		handlers.events.emit(ZENTUI_WORKING_LINE_SEGMENT_EVENT, { key: "tps" });
+		expect(row()).toContain("Stable · queue 2");
+		expect(row()).not.toContain("tok/s");
+		await emit(handlers, "session_shutdown", current.ctx);
+		expect(capability(handlers).active).toBe(false);
+	});
+
+	it("suspends capability and routing synchronously while a replacement session starts", async () => {
+		const handlers = loadExtension();
+		const first = harness();
+		await emit(handlers, "session_start", first.ctx);
+		handlers.events.emit(ZENTUI_WORKING_LINE_SEGMENT_EVENT, {
+			key: "@scope/publisher:session",
+			text: "session A",
+		});
+		expect(capability(handlers).active).toBe(true);
+
+		let releaseStartup = () => {};
+		startupGate.pending = new Promise<void>((resolve) => {
+			releaseStartup = resolve;
+		});
+		const second = harness();
+		const starting = emit(handlers, "session_start", second.ctx);
+		expect(capability(handlers).active).toBe(false);
+		const firstCallsAfterSuspension = first.calls.length;
+		handlers.events.emit(ZENTUI_WORKING_LINE_SEGMENT_EVENT, {
+			key: "@scope/publisher:session",
+			text: "must not reach session A",
+		});
+		expect(first.calls).toHaveLength(firstCallsAfterSuspension);
+		expect(second.calls).toEqual([]);
+
+		releaseStartup();
+		await starting;
+		startupGate.pending = undefined;
+		expect(capability(handlers).active).toBe(true);
+		const installed = second.calls
+			.filter(([name, value]) => name === "indicator" && value !== undefined)
+			.at(-1)?.[1] as { frames?: string[] } | undefined;
+		expect(stripTerminalSequences(installed?.frames?.[0] ?? "")).not.toContain("session A");
+		expect(stripTerminalSequences(installed?.frames?.[0] ?? "")).not.toContain("must not reach");
+		await emit(handlers, "session_shutdown", second.ctx);
+	});
+
+	it("reports inactive across missing APIs, disable, re-enable, and session boundaries", async () => {
+		const handlers = loadExtension();
+		const missingApi = harness();
+		(missingApi.ctx.ui as { setWorkingIndicator?: unknown }).setWorkingIndicator = undefined;
+		await emit(handlers, "session_start", missingApi.ctx);
+		expect(capability(handlers)).toEqual({
+			supported: true,
+			active: false,
+			version: ZENTUI_WORKING_LINE_SEGMENT_PROTOCOL_VERSION,
+		});
+		await emit(handlers, "session_shutdown", missingApi.ctx);
+		expect(capability(handlers).active).toBe(false);
+
+		const enabled = harness();
+		await emit(handlers, "session_start", enabled.ctx);
+		expect(capability(handlers).active).toBe(true);
+		await emit(handlers, "session_shutdown", enabled.ctx);
+		expect(capability(handlers).active).toBe(false);
+
+		runtime.enabled = false;
+		const disabled = harness();
+		await emit(handlers, "session_start", disabled.ctx);
+		expect(capability(handlers).active).toBe(false);
+		await emit(handlers, "session_shutdown", disabled.ctx);
+
+		runtime.enabled = true;
+		const reenabled = harness();
+		await emit(handlers, "session_start", reenabled.ctx);
+		expect(capability(handlers).active).toBe(true);
+		await emit(handlers, "session_shutdown", reenabled.ctx);
+		expect(capability(handlers).active).toBe(false);
+	});
+
+	it("reports inactive when the initial indicator setter fails", async () => {
+		const handlers = loadExtension();
+		const current = harness();
+		const setIndicator = current.ctx.ui.setWorkingIndicator.bind(current.ctx.ui);
+		let fail = true;
+		current.ctx.ui.setWorkingIndicator = (value?: unknown) => {
+			if (value !== undefined && fail) {
+				fail = false;
+				throw new Error("indicator unavailable");
+			}
+			setIndicator(value);
+		};
+		await emit(handlers, "session_start", current.ctx);
+		expect(capability(handlers).active).toBe(false);
+		await emit(handlers, "session_shutdown", current.ctx);
+	});
+
+	it("invalidates released state, ignores inactive updates, and accepts a current republish", async () => {
+		const handlers = loadExtension();
+		const current = harness();
+		await emit(handlers, "session_start", current.ctx);
+		expect(capability(handlers).active).toBe(true);
+		const setIndicator = current.ctx.ui.setWorkingIndicator.bind(current.ctx.ui);
+		let failures = 2;
+		current.ctx.ui.setWorkingIndicator = (value?: unknown) => {
+			if (value !== undefined && failures > 0) {
+				failures -= 1;
+				throw new Error("indicator unavailable");
+			}
+			setIndicator(value);
+		};
+		handlers.events.emit(ZENTUI_WORKING_LINE_SEGMENT_EVENT, {
+			key: "@scope/publisher:queue",
+			text: "stale queue 2",
+		});
+		expect(capability(handlers).active).toBe(false);
+		handlers.events.emit(ZENTUI_WORKING_LINE_SEGMENT_EVENT, {
+			key: "@scope/publisher:queue",
+			text: "current queue 3",
+		});
+
+		await emit(handlers, "agent_start", current.ctx);
+		expect(capability(handlers).active).toBe(true);
+		const reinstalled = current.calls
+			.filter(([name, value]) => name === "indicator" && value !== undefined)
+			.at(-1)?.[1] as { frames?: string[] } | undefined;
+		expect(stripTerminalSequences(reinstalled?.frames?.[0] ?? "")).not.toContain("stale queue");
+		expect(stripTerminalSequences(reinstalled?.frames?.[0] ?? "")).not.toContain("current queue");
+
+		handlers.events.emit(ZENTUI_WORKING_LINE_SEGMENT_EVENT, {
+			key: "@scope/publisher:queue",
+			text: "current queue 3",
+		});
+		const republished = current.calls
+			.filter(([name, value]) => name === "indicator" && value !== undefined)
+			.at(-1)?.[1] as { frames?: string[] } | undefined;
+		expect(stripTerminalSequences(republished?.frames?.[0] ?? "")).toContain("current queue 3");
+		await emit(handlers, "session_shutdown", current.ctx);
+	});
+
+	it("renders an identical keyed replay after a transient segment update failure", async () => {
+		const handlers = loadExtension();
+		const current = harness();
+		await emit(handlers, "session_start", current.ctx);
+		const setIndicator = current.ctx.ui.setWorkingIndicator.bind(current.ctx.ui);
+		let fail = true;
+		current.ctx.ui.setWorkingIndicator = (value?: unknown) => {
+			if (value !== undefined && fail) {
+				fail = false;
+				throw new Error("transient indicator failure");
+			}
+			setIndicator(value);
+		};
+		const update = { key: "@scope/publisher:queue", text: "queue 2" };
+		handlers.events.emit(ZENTUI_WORKING_LINE_SEGMENT_EVENT, update);
+		const afterFailure = current.calls
+			.filter(([name, value]) => name === "indicator" && value !== undefined)
+			.at(-1)?.[1] as { frames?: string[] } | undefined;
+		expect(stripTerminalSequences(afterFailure?.frames?.[0] ?? "")).not.toContain("queue 2");
+		handlers.events.emit(ZENTUI_WORKING_LINE_SEGMENT_EVENT, update);
+		const afterReplay = current.calls
+			.filter(([name, value]) => name === "indicator" && value !== undefined)
+			.at(-1)?.[1] as { frames?: string[] } | undefined;
+		expect(stripTerminalSequences(afterReplay?.frames?.[0] ?? "")).toContain("queue 2");
+		expect(capability(handlers).active).toBe(true);
+		await emit(handlers, "session_shutdown", current.ctx);
+	});
+
 	it("compacts live provider usage", async () => {
 		const handlers = loadExtension();
 		const current = harness();